You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@tvm.apache.org by GitBox <gi...@apache.org> on 2022/09/06 03:22:12 UTC
[GitHub] [tvm] honghuichao opened a new issue, #12707: [Bug] a bug about fake quantize to intege and split op.
honghuichao opened a new issue, #12707:
URL: https://github.com/apache/tvm/issues/12707
Thanks for participating in the TVM community! We use https://discuss.tvm.ai for any general usage questions and discussions. The issue tracker is used for actionable items such as feature proposals discussion, roadmaps, and bug tracking. You are always welcomed to post on the forum first :smile_cat:
Issues that are inactive for a period of time may get closed. We adopt this policy so that we won't lose track of actionable issues that may fall at the bottom of the pile. Feel free to reopen a new one if you feel there is an additional problem that needs attention when an old one gets closed.
### Expected behavior
What you were expecting
### Actual behavior
What actually happened
### Environment
Any environment details, such as: Operating System, TVM version, etc
### Steps to reproduce
affine_types_.Set(out, Downcast<AffineType>(vals[1]));
if (call_node == quantize_node_) {
std::cout<<AsText(out,false);
std::cout<<vals[1].as<TensorAffineType>;
out = qnn::MakeDequantize(out, vals[1].as<TensorAffineTypeNode>()->scale,
vals[1].as<TensorAffineTypeNode>()->zero_point,
vals[1].as<TensorAffineTypeNode>()->axis);
}
I print the value of vals[1].as<TensorAffineType>,the value is equal to 0, may be it is a TupleAfineType. and "out" also a Tuple Type and split op.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@tvm.apache.org.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [tvm] mbrookhart commented on issue #12707: [Bug] a bug about fake quantize to intege and split op.
Posted by GitBox <gi...@apache.org>.
mbrookhart commented on issue #12707:
URL: https://github.com/apache/tvm/issues/12707#issuecomment-1239664889
Yes, the pass is kind of implicitly assuming scale and zero point are constant on the C++ side. I think Constant folding will get around the issue in the short term, but we should come up with a cleaner design to handle that. I'll think about it.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@tvm.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [tvm] honghuichao commented on issue #12707: [Bug] a bug about fake quantize to intege and split op.
Posted by GitBox <gi...@apache.org>.
honghuichao commented on issue #12707:
URL: https://github.com/apache/tvm/issues/12707#issuecomment-1238135390
@mbrookhart Would you mind helping me?
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@tvm.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [tvm] honghuichao commented on issue #12707: [Bug] a bug about fake quantize to intege and split op.
Posted by GitBox <gi...@apache.org>.
honghuichao commented on issue #12707:
URL: https://github.com/apache/tvm/issues/12707#issuecomment-1239636254
thank you very much
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@tvm.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [tvm] honghuichao commented on issue #12707: [Bug] a bug about fake quantize to intege and split op.
Posted by GitBox <gi...@apache.org>.
honghuichao commented on issue #12707:
URL: https://github.com/apache/tvm/issues/12707#issuecomment-1320781146
@mbrookhart The sum of two int8 data is greater than the data range represented by int8
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@tvm.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [tvm] honghuichao commented on issue #12707: [Bug] a bug about fake quantize to intege and split op.
Posted by GitBox <gi...@apache.org>.
honghuichao commented on issue #12707:
URL: https://github.com/apache/tvm/issues/12707#issuecomment-1238864157
@mbrookhart
1. for first problem：I add some code, segement fault is disappear. but I don't know if it's reasonable.
if (call_node == quantize_node_) {
/*if (tvm::relay::transform::InferTypeLocal(out).as<TupleTypeNode>()) {
Array<Expr> outs;
for (size_t i = 0; i < Downcast<Tuple>(out)->fields.size(); i++) {
auto tmp = Downcast<Tuple>(out)->fields[i];
auto quantize_info = vals[1].as<TupleAffineTypeNode>()->types[i];
auto new_out = qnn::MakeDequantize(tmp, quantize_info.as<TensorAffineTypeNode>()->scale,
quantize_info.as<TensorAffineTypeNode>()->zero_point,
quantize_info.as<TensorAffineTypeNode>()->axis);
outs.push_back(new_out);
}
out = Tuple(outs);*/
//} else {
out = qnn::MakeDequantize(out, vals[1].as<TensorAffineTypeNode>()->scale,
vals[1].as<TensorAffineTypeNode>()->zero_point,
vals[1].as<TensorAffineTypeNode>()->axis);
//}
}
}
2.for second problem: I write a simple demo.
import tvm
mod = tvm.parser.parse_expr(
'''
fn (%x1: Tensor[(1, 3, 224, 224), float32] /* ty=Tensor[(1, 3, 224, 224), float32] */, %x2: Tensor[(1, 3, 224, 224), float32] /* ty=Tensor[(1, 3, 224, 224), float32] */) -> Tensor[(1, 6, 224, 224), float32] {
%0 = power(2f, 1f /* ty=float32 */);
%1 = divide(1f, %0);
%2 = qnn.quantize(%x1, %1, 0, out_dtype="int8");
%3 = clip(%2, a_min=-127f, a_max=127f);
%4 = power(2f, 1f /* ty=float32 */);
%5 = divide(1f, %4);
%6 = qnn.quantize(%x2, %5, 0, out_dtype="int8");
%7 = clip(%6, a_min=-127f, a_max=127f);
%8 = qnn.dequantize(%3, %1, 0);
%9 = qnn.dequantize(%7, %5, 0);
%10 = (%8, %9) /* ty=(Tensor[(1, 3, 224, 224), float32], Tensor[(1, 3, 224, 224), float32]) */;
%11 = power(2f, 1f /* ty=float32 */);
%12 = concatenate(%10, axis=1) /* ty=Tensor[(1, 6, 224, 224), float32] */;
%13 = divide(1f, %11);
%14 = qnn.quantize(%12, %13, 0, out_dtype="int8");
%15 = clip(%14, a_min=-127f, a_max=127f);
qnn.dequantize(%15, %13, 0)
} /* ty=fn (Tensor[(1, 3, 224, 224), float32], Tensor[(1, 3, 224, 224), float32]) -> Tensor[(1, 6, 224, 224), float32] */
'''
)
mod = tvm.IRModule.from_expr(mod)
mod = relay.transform.InferType()(mod)
mod = tvm.relay.transform.FakeQuantizationToInteger(False, True)(mod)
I think in this network, concat op will transform into qnn.concat.but, I run " mod = tvm.relay.transform.FakeQuantizationToInteger(False, True)(mod)"
the result is :
fn (%x1: Tensor[(1, 3, 224, 224), float32] /* ty=Tensor[(1, 3, 224, 224), float32] */, %x2: Tensor[(1, 3, 224, 224), float32] /* ty=Tensor[(1, 3, 224, 224), float32] */) -> Tensor[(1, 6, 224, 224), float32] {
%0 = power(2f, 1f /* ty=float32 */);
%1 = divide(1f, %0);
%2 = qnn.quantize(%x1, %1, 0, out_dtype="int8");
%3 = clip(%2, a_min=-127f, a_max=127f);
%4 = power(2f, 1f /* ty=float32 */);
%5 = divide(1f, %4);
%6 = qnn.quantize(%x2, %5, 0, out_dtype="int8");
%7 = clip(%6, a_min=-127f, a_max=127f);
%8 = qnn.dequantize(%3, %1, 0);
%9 = qnn.dequantize(%7, %5, 0);
%10 = (%8, %9) /* ty=(Tensor[(1, 3, 224, 224), float32], Tensor[(1, 3, 224, 224), float32]) */;
%11 = power(2f, 1f /* ty=float32 */);
%12 = concatenate(%10, axis=1) /* ty=Tensor[(1, 6, 224, 224), float32] */;
%13 = divide(1f, %11);
%14 = qnn.quantize(%12, %13, 0, out_dtype="int8");
%15 = clip(%14, a_min=-127f, a_max=127f);
qnn.dequantize(%15, %13, 0)
} /* ty=
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@tvm.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [tvm] honghuichao commented on issue #12707: [Bug] a bug about fake quantize to intege and split op.
Posted by GitBox <gi...@apache.org>.
honghuichao commented on issue #12707:
URL: https://github.com/apache/tvm/issues/12707#issuecomment-1320781127
@mbrookhart The sum of two int8 data is greater than the data range represented by int8
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@tvm.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [tvm] mbrookhart commented on issue #12707: [Bug] a bug about fake quantize to intege and split op.
Posted by GitBox <gi...@apache.org>.
mbrookhart commented on issue #12707:
URL: https://github.com/apache/tvm/issues/12707#issuecomment-1239618078
Where did you add the code?
Something is going wrong with the pass because you have expressions as scales and zero points. If I run FoldConstant before FQ2I, it works:
```
import tvm
from tvm import relay
mod = tvm.parser.parse_expr(
'''
fn (%x1: Tensor[(1, 3, 224, 224), float32], %x2: Tensor[(1, 3, 224, 224), float32]){
%0 = power(2f, 1f);
%1 = divide(1f, %0);
%2 = qnn.quantize(%x1, %1, 0, out_dtype="int8");
%3 = clip(%2, a_min=-127f, a_max=127f);
%4 = power(2f, 1f);
%5 = divide(1f, %4);
%6 = qnn.quantize(%x2, %5, 0, out_dtype="int8");
%7 = clip(%6, a_min=-127f, a_max=127f);
%8 = qnn.dequantize(%3, %1, 0);
%9 = qnn.dequantize(%7, %5, 0);
%10 = (%8, %9);
%11 = power(2f, 1f);
%12 = concatenate(%10, axis=1);
%13 = divide(1f, %11);
%14 = qnn.quantize(%12, %13, 0, out_dtype="int8");
%15 = clip(%14, a_min=-127f, a_max=127f);
qnn.dequantize(%15, %13, 0)
}
'''
)
mod = tvm.IRModule.from_expr(mod)
mod = relay.transform.InferType()(mod)
mod = relay.transform.FoldConstant()(mod)
mod = tvm.relay.transform.FakeQuantizationToInteger(False, True)(mod)
print(mod)
```
```
def @main(%x1: Tensor[(1, 3, 224, 224), float32] /* ty=Tensor[(1, 3, 224, 224), float32] span=string:5:19 */, %x2: Tensor[(1, 3, 224, 224), float32] /* ty=Tensor[(1, 3, 224, 224), float32] span=string:9:19 */) -> Tensor[(1, 6, 224, 224), float32] {
%0 = qnn.quantize(%x1, 0.5f /* ty=float32 */, 0 /* ty=int32 span=string:5:29 */, out_dtype="int8") /* ty=Tensor[(1, 3, 224, 224), int8] span=string:6:11 */;
%1 = qnn.quantize(%x2, 0.5f /* ty=float32 */, 0 /* ty=int32 span=string:9:29 */, out_dtype="int8") /* ty=Tensor[(1, 3, 224, 224), int8] span=string:10:11 */;
%2 = clip(%0, a_min=-127f, a_max=127f) /* ty=Tensor[(1, 3, 224, 224), int8] span=string:11:21 */;
%3 = clip(%1, a_min=-127f, a_max=127f) /* ty=Tensor[(1, 3, 224, 224), int8] span=string:12:21 */;
%4 = (%2, %3) /* ty=(Tensor[(1, 3, 224, 224), int8], Tensor[(1, 3, 224, 224), int8]) span=string:15:19 */;
%5 = (0.5f /* ty=float32 */, 0.5f /* ty=float32 */) /* ty=(float32, float32) */;
%6 = (0 /* ty=int32 span=string:11:30 */, 0 /* ty=int32 span=string:12:30 */) /* ty=(int32, int32) */;
%7 = qnn.concatenate(%4, %5, %6, 0.5f /* ty=float32 */, 0 /* ty=int32 span=string:17:31 */, axis=1) /* ty=Tensor[(1, 6, 224, 224), int8] */;
%8 = clip(%7, a_min=-127f, a_max=127f) /* ty=Tensor[(1, 6, 224, 224), int8] span=string:19:16 */;
qnn.dequantize(%8, 0.5f /* ty=float32 */, 0 /* ty=int32 span=string:19:27 */) /* ty=Tensor[(1, 6, 224, 224), float32] span=string:3:1 */
}
```
I'll try to figure out why the pass is failing with Expr scale and zero point
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@tvm.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [tvm] mbrookhart commented on issue #12707: [Bug] a bug about fake quantize to intege and split op.
Posted by GitBox <gi...@apache.org>.
mbrookhart commented on issue #12707:
URL: https://github.com/apache/tvm/issues/12707#issuecomment-1255479227
Hi @honghuichao. I'm way behind on this, I think I see a fix.
I did special handling for quantize and dequantize in the [extractor](https://github.com/apache/tvm/blob/195ae72b5c6f0df68fac41f7808d125d155a6345/src/relay/transforms/fake_quantization_to_integer.cc#L140-L161), but it seems that I forgot to handle the special case of quantize in the [mutator](https://github.com/apache/tvm/blob/195ae72b5c6f0df68fac41f7808d125d155a6345/src/relay/transforms/fake_quantization_to_integer.cc#L213-L220), so it's failing trying to rewrite the scale and zero point of the quantize, which is invalid.
I've got a busy couple of days, but I'll see if I or someone else familiar with the pass can get a fix up soon. If you want to tackle it, go for it!
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@tvm.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [tvm] honghuichao commented on issue #12707: [Bug] a bug about fake quantize to intege and split op.
Posted by GitBox <gi...@apache.org>.
honghuichao commented on issue #12707:
URL: https://github.com/apache/tvm/issues/12707#issuecomment-1320804337
and I also find a problem I am not sure whether it a bug or not .
https://discuss.tvm.apache.org/t/about-the-output-scale-and-output-zero-point-of-qnn-requantize-is-limited-to-a-scalar/13366
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@tvm.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [tvm] honghuichao commented on issue #12707: [Bug] a bug about fake quantize to intege and split op.
Posted by GitBox <gi...@apache.org>.
honghuichao commented on issue #12707:
URL: https://github.com/apache/tvm/issues/12707#issuecomment-1237615902
core dump was happend.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@tvm.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [tvm] honghuichao commented on issue #12707: [Bug] a bug about fake quantize to intege and split op.
Posted by GitBox <gi...@apache.org>.
honghuichao commented on issue #12707:
URL: https://github.com/apache/tvm/issues/12707#issuecomment-1238083686
and if a concat op ,it is inputs with dequantize ,such as data +dequantize+concat. I think fakequantize to int pass will transform it into data +qnn.concat. but in this pass.it seem doese not work.
def @main(%input: Tensor[(1, 3, 544, 960), float32] /* ty=Tensor[(1, 3, 544, 960), float32] */, %im_info: Tensor[(1, 3), float32] /* ty=Tensor[(1, 3), float32] */) -> Tensor[(32640, 11), float32] {
%0 = power(2f /* ty=float32 */, -1f /* ty=float32 */) /* ty=float32 */;
%1 = divide(1f /* ty=float32 */, %0) /* ty=float32 */;
%2 = qnn.quantize(%input, %1, 0 /* ty=int32 */, out_dtype="int8") /* ty=Tensor[(1, 3, 544, 960), int8] */;
%3 = power(2f /* ty=float32 */, 28f /* ty=float32 */) /* ty=float32 */;
%4 = divide(1f /* ty=float32 */, %3) /* ty=float32 */;
%5 = multiply(%4, meta[relay.Constant][1] /* ty=Tensor[(64, 1, 1, 1), float32] */) /* ty=Tensor[(64, 1, 1, 1), float32] */;
%6 = clip(%2, a_min=-127f, a_max=127f) /* ty=Tensor[(1, 3, 544, 960), int8] */;
%7 = qnn.quantize(meta[relay.Constant][0] /* ty=Tensor[(64, 3, 5, 5), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int8", axis=0) /* ty=Tensor[(64, 3, 5, 5), int8] */;
%8 = squeeze(%5) /* ty=Tensor[(64), float32] */;
%9 = power(2f /* ty=float32 */, 27f /* ty=float32 */) /* ty=float32 */;
%10 = qnn.quantize(meta[relay.Constant][2] /* ty=Tensor[(64), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int32") /* ty=Tensor[(64), int32] */;
%11 = divide(1f /* ty=float32 */, %9) /* ty=float32 */;
%12 = qnn.conv2d(%6, %7, 0 /* ty=int32 */, 0 /* ty=int32 */, %1, %8, strides=[4, 4], padding=[2, 2, 2, 2], channels=64, kernel_size=[5, 5], out_dtype="int32") /* ty=Tensor[(1, 64, 136, 240), int32] */;
%13 = qnn.requantize(%10, %11, 0 /* ty=int32 */, meta[relay.Constant][3] /* ty=Tensor[(64), float32] */, meta[relay.Constant][4] /* ty=Tensor[(64), int32] */, axis=0, out_dtype="int32") /* ty=Tensor[(64), int32] */;
%14 = nn.bias_add(%12, %13) /* ty=Tensor[(1, 64, 136, 240), int32] */;
%15 = power(2f /* ty=float32 */, 3f /* ty=float32 */) /* ty=float32 */;
%16 = qnn.dequantize(%14, meta[relay.Constant][3] /* ty=Tensor[(64), float32] */, meta[relay.Constant][4] /* ty=Tensor[(64), int32] */, axis=1) /* ty=Tensor[(1, 64, 136, 240), float32] */;
%17 = divide(1f /* ty=float32 */, %15) /* ty=float32 */;
%18 = qnn.quantize(%16, %17, 0 /* ty=int32 */, out_dtype="int8") /* ty=Tensor[(1, 64, 136, 240), int8] */;
%19 = clip(%18, a_min=-127f, a_max=127f) /* ty=Tensor[(1, 64, 136, 240), int8] */;
%20 = power(2f /* ty=float32 */, 23f /* ty=float32 */) /* ty=float32 */;
%21 = divide(1f /* ty=float32 */, %20) /* ty=float32 */;
%22 = multiply(%21, meta[relay.Constant][7] /* ty=Tensor[(16, 1, 1, 1), float32] */) /* ty=Tensor[(16, 1, 1, 1), float32] */;
%23 = maximum(%19, meta[relay.Constant][5] /* ty=int8 */) /* ty=Tensor[(1, 64, 136, 240), int8] */;
%24 = qnn.quantize(meta[relay.Constant][6] /* ty=Tensor[(16, 64, 1, 1), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int8", axis=0) /* ty=Tensor[(16, 64, 1, 1), int8] */;
%25 = squeeze(%22) /* ty=Tensor[(16), float32] */;
%26 = power(2f /* ty=float32 */, 26f /* ty=float32 */) /* ty=float32 */;
%27 = qnn.quantize(meta[relay.Constant][8] /* ty=Tensor[(16), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int32") /* ty=Tensor[(16), int32] */;
%28 = divide(1f /* ty=float32 */, %26) /* ty=float32 */;
%29 = qnn.conv2d(%23, %24, 0 /* ty=int32 */, 0 /* ty=int32 */, %17, %25, padding=[0, 0, 0, 0], channels=16, kernel_size=[1, 1], out_dtype="int32") /* ty=Tensor[(1, 16, 136, 240), int32] */;
%30 = qnn.requantize(%27, %28, 0 /* ty=int32 */, meta[relay.Constant][9] /* ty=Tensor[(16), float32] */, meta[relay.Constant][10] /* ty=Tensor[(16), int32] */, axis=0, out_dtype="int32") /* ty=Tensor[(16), int32] */;
%31 = nn.bias_add(%29, %30) /* ty=Tensor[(1, 16, 136, 240), int32] */;
%32 = power(2f /* ty=float32 */, 3f /* ty=float32 */) /* ty=float32 */;
%33 = qnn.dequantize(%31, meta[relay.Constant][9] /* ty=Tensor[(16), float32] */, meta[relay.Constant][10] /* ty=Tensor[(16), int32] */, axis=1) /* ty=Tensor[(1, 16, 136, 240), float32] */;
%34 = divide(1f /* ty=float32 */, %32) /* ty=float32 */;
%35 = qnn.quantize(%33, %34, 0 /* ty=int32 */, out_dtype="int8") /* ty=Tensor[(1, 16, 136, 240), int8] */;
%36 = clip(%35, a_min=-127f, a_max=127f) /* ty=Tensor[(1, 16, 136, 240), int8] */;
%37 = power(2f /* ty=float32 */, 21f /* ty=float32 */) /* ty=float32 */;
%38 = divide(1f /* ty=float32 */, %37) /* ty=float32 */;
%39 = multiply(%38, meta[relay.Constant][13] /* ty=Tensor[(32, 1, 1, 1), float32] */) /* ty=Tensor[(32, 1, 1, 1), float32] */;
%40 = maximum(%36, meta[relay.Constant][11] /* ty=int8 */) /* ty=Tensor[(1, 16, 136, 240), int8] */;
%41 = qnn.quantize(meta[relay.Constant][12] /* ty=Tensor[(32, 16, 1, 1), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int8", axis=0) /* ty=Tensor[(32, 16, 1, 1), int8] */;
%42 = squeeze(%39) /* ty=Tensor[(32), float32] */;
%43 = power(2f /* ty=float32 */, 24f /* ty=float32 */) /* ty=float32 */;
%44 = qnn.quantize(meta[relay.Constant][14] /* ty=Tensor[(32), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int32") /* ty=Tensor[(32), int32] */;
%45 = divide(1f /* ty=float32 */, %43) /* ty=float32 */;
%46 = qnn.conv2d(%40, %41, 0 /* ty=int32 */, 0 /* ty=int32 */, %34, %42, padding=[0, 0, 0, 0], channels=32, kernel_size=[1, 1], out_dtype="int32") /* ty=Tensor[(1, 32, 136, 240), int32] */;
%47 = qnn.requantize(%44, %45, 0 /* ty=int32 */, meta[relay.Constant][15] /* ty=Tensor[(32), float32] */, meta[relay.Constant][16] /* ty=Tensor[(32), int32] */, axis=0, out_dtype="int32") /* ty=Tensor[(32), int32] */;
%48 = nn.bias_add(%46, %47) /* ty=Tensor[(1, 32, 136, 240), int32] */;
%49 = power(2f /* ty=float32 */, 4f /* ty=float32 */) /* ty=float32 */;
%50 = qnn.dequantize(%48, meta[relay.Constant][15] /* ty=Tensor[(32), float32] */, meta[relay.Constant][16] /* ty=Tensor[(32), int32] */, axis=1) /* ty=Tensor[(1, 32, 136, 240), float32] */;
%51 = divide(1f /* ty=float32 */, %49) /* ty=float32 */;
%52 = qnn.quantize(%50, %51, 0 /* ty=int32 */, out_dtype="int8") /* ty=Tensor[(1, 32, 136, 240), int8] */;
%53 = clip(%52, a_min=-127f, a_max=127f) /* ty=Tensor[(1, 32, 136, 240), int8] */;
%54 = maximum(%53, meta[relay.Constant][17] /* ty=int8 */) /* ty=Tensor[(1, 32, 136, 240), int8] */;
%55 = power(2f /* ty=float32 */, 22f /* ty=float32 */) /* ty=float32 */;
%56 = divide(1f /* ty=float32 */, %55) /* ty=float32 */;
%57 = multiply(%56, meta[relay.Constant][19] /* ty=Tensor[(32, 1, 1, 1), float32] */) /* ty=Tensor[(32, 1, 1, 1), float32] */;
%58 = qnn.quantize(meta[relay.Constant][18] /* ty=Tensor[(32, 16, 3, 3), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int8", axis=0) /* ty=Tensor[(32, 16, 3, 3), int8] */;
%59 = squeeze(%57) /* ty=Tensor[(32), float32] */;
%60 = power(2f /* ty=float32 */, 25f /* ty=float32 */) /* ty=float32 */;
%61 = qnn.quantize(meta[relay.Constant][20] /* ty=Tensor[(32), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int32") /* ty=Tensor[(32), int32] */;
%62 = divide(1f /* ty=float32 */, %60) /* ty=float32 */;
%63 = qnn.conv2d(%40, %58, 0 /* ty=int32 */, 0 /* ty=int32 */, %34, %59, padding=[1, 1, 1, 1], channels=32, kernel_size=[3, 3], out_dtype="int32") /* ty=Tensor[(1, 32, 136, 240), int32] */;
%64 = qnn.requantize(%61, %62, 0 /* ty=int32 */, meta[relay.Constant][21] /* ty=Tensor[(32), float32] */, meta[relay.Constant][22] /* ty=Tensor[(32), int32] */, axis=0, out_dtype="int32") /* ty=Tensor[(32), int32] */;
%65 = nn.bias_add(%63, %64) /* ty=Tensor[(1, 32, 136, 240), int32] */;
%66 = power(2f /* ty=float32 */, 3f /* ty=float32 */) /* ty=float32 */;
%67 = qnn.dequantize(%65, meta[relay.Constant][21] /* ty=Tensor[(32), float32] */, meta[relay.Constant][22] /* ty=Tensor[(32), int32] */, axis=1) /* ty=Tensor[(1, 32, 136, 240), float32] */;
%68 = divide(1f /* ty=float32 */, %66) /* ty=float32 */;
%69 = qnn.quantize(%67, %68, 0 /* ty=int32 */, out_dtype="int8") /* ty=Tensor[(1, 32, 136, 240), int8] */;
%70 = clip(%69, a_min=-127f, a_max=127f) /* ty=Tensor[(1, 32, 136, 240), int8] */;
%71 = maximum(%70, meta[relay.Constant][23] /* ty=int8 */) /* ty=Tensor[(1, 32, 136, 240), int8] */;
%72 = qnn.dequantize(%54, %51, 0 /* ty=int32 */) /* ty=Tensor[(1, 32, 136, 240), float32] */;
%73 = qnn.dequantize(%71, %68, 0 /* ty=int32 */) /* ty=Tensor[(1, 32, 136, 240), float32] */;
%74 = (%72, %73) /* ty=(Tensor[(1, 32, 136, 240), float32], Tensor[(1, 32, 136, 240), float32]) */;
%75 = power(2f /* ty=float32 */, 3f /* ty=float32 */) /* ty=float32 */;
%76 = concatenate(%74, axis=1) /* ty=Tensor[(1, 64, 136, 240), float32] */;
%77 = divide(1f /* ty=float32 */, %75) /* ty=float32 */;
%78 = qnn.quantize(%76, %77, 0 /* ty=int32 */, out_dtype="int8") /* ty=Tensor[(1, 64, 136, 240), int8] */;
%79 = power(2f /* ty=float32 */, 23f /* ty=float32 */) /* ty=float32 */;
%80 = divide(1f /* ty=float32 */, %79) /* ty=float32 */;
%81 = multiply(%80, meta[relay.Constant][25] /* ty=Tensor[(16, 1, 1, 1), float32] */) /* ty=Tensor[(16, 1, 1, 1), float32] */;
%82 = clip(%78, a_min=-127f, a_max=127f) /* ty=Tensor[(1, 64, 136, 240), int8] */;
%83 = qnn.quantize(meta[relay.Constant][24] /* ty=Tensor[(16, 64, 1, 1), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int8", axis=0) /* ty=Tensor[(16, 64, 1, 1), int8] */;
%84 = squeeze(%81) /* ty=Tensor[(16), float32] */;
%85 = power(2f /* ty=float32 */, 26f /* ty=float32 */) /* ty=float32 */;
%86 = qnn.quantize(meta[relay.Constant][26] /* ty=Tensor[(16), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int32") /* ty=Tensor[(16), int32] */;
%87 = divide(1f /* ty=float32 */, %85) /* ty=float32 */;
%88 = qnn.conv2d(%82, %83, 0 /* ty=int32 */, 0 /* ty=int32 */, %77, %84, padding=[0, 0, 0, 0], channels=16, kernel_size=[1, 1], out_dtype="int32") /* ty=Tensor[(1, 16, 136, 240), int32] */;
%89 = qnn.requantize(%86, %87, 0 /* ty=int32 */, meta[relay.Constant][27] /* ty=Tensor[(16), float32] */, meta[relay.Constant][28] /* ty=Tensor[(16), int32] */, axis=0, out_dtype="int32") /* ty=Tensor[(16), int32] */;
%90 = nn.bias_add(%88, %89) /* ty=Tensor[(1, 16, 136, 240), int32] */;
%91 = power(2f /* ty=float32 */, 3f /* ty=float32 */) /* ty=float32 */;
%92 = qnn.dequantize(%90, meta[relay.Constant][27] /* ty=Tensor[(16), float32] */, meta[relay.Constant][28] /* ty=Tensor[(16), int32] */, axis=1) /* ty=Tensor[(1, 16, 136, 240), float32] */;
%93 = divide(1f /* ty=float32 */, %91) /* ty=float32 */;
%94 = qnn.quantize(%92, %93, 0 /* ty=int32 */, out_dtype="int8") /* ty=Tensor[(1, 16, 136, 240), int8] */;
%95 = clip(%94, a_min=-127f, a_max=127f) /* ty=Tensor[(1, 16, 136, 240), int8] */;
%96 = power(2f /* ty=float32 */, 22f /* ty=float32 */) /* ty=float32 */;
%97 = divide(1f /* ty=float32 */, %96) /* ty=float32 */;
%98 = multiply(%97, meta[relay.Constant][31] /* ty=Tensor[(32, 1, 1, 1), float32] */) /* ty=Tensor[(32, 1, 1, 1), float32] */;
%99 = maximum(%95, meta[relay.Constant][29] /* ty=int8 */) /* ty=Tensor[(1, 16, 136, 240), int8] */;
%100 = qnn.quantize(meta[relay.Constant][30] /* ty=Tensor[(32, 16, 1, 1), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int8", axis=0) /* ty=Tensor[(32, 16, 1, 1), int8] */;
%101 = squeeze(%98) /* ty=Tensor[(32), float32] */;
%102 = power(2f /* ty=float32 */, 25f /* ty=float32 */) /* ty=float32 */;
%103 = qnn.quantize(meta[relay.Constant][32] /* ty=Tensor[(32), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int32") /* ty=Tensor[(32), int32] */;
%104 = divide(1f /* ty=float32 */, %102) /* ty=float32 */;
%105 = qnn.conv2d(%99, %100, 0 /* ty=int32 */, 0 /* ty=int32 */, %93, %101, padding=[0, 0, 0, 0], channels=32, kernel_size=[1, 1], out_dtype="int32") /* ty=Tensor[(1, 32, 136, 240), int32] */;
%106 = qnn.requantize(%103, %104, 0 /* ty=int32 */, meta[relay.Constant][33] /* ty=Tensor[(32), float32] */, meta[relay.Constant][34] /* ty=Tensor[(32), int32] */, axis=0, out_dtype="int32") /* ty=Tensor[(32), int32] */;
%107 = nn.bias_add(%105, %106) /* ty=Tensor[(1, 32, 136, 240), int32] */;
%108 = power(2f /* ty=float32 */, 4f /* ty=float32 */) /* ty=float32 */;
%109 = qnn.dequantize(%107, meta[relay.Constant][33] /* ty=Tensor[(32), float32] */, meta[relay.Constant][34] /* ty=Tensor[(32), int32] */, axis=1) /* ty=Tensor[(1, 32, 136, 240), float32] */;
%110 = divide(1f /* ty=float32 */, %108) /* ty=float32 */;
%111 = qnn.quantize(%109, %110, 0 /* ty=int32 */, out_dtype="int8") /* ty=Tensor[(1, 32, 136, 240), int8] */;
%112 = clip(%111, a_min=-127f, a_max=127f) /* ty=Tensor[(1, 32, 136, 240), int8] */;
%113 = maximum(%112, meta[relay.Constant][35] /* ty=int8 */) /* ty=Tensor[(1, 32, 136, 240), int8] */;
%114 = power(2f /* ty=float32 */, 23f /* ty=float32 */) /* ty=float32 */;
%115 = divide(1f /* ty=float32 */, %114) /* ty=float32 */;
%116 = multiply(%115, meta[relay.Constant][37] /* ty=Tensor[(32, 1, 1, 1), float32] */) /* ty=Tensor[(32, 1, 1, 1), float32] */;
%117 = qnn.quantize(meta[relay.Constant][36] /* ty=Tensor[(32, 16, 3, 3), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int8", axis=0) /* ty=Tensor[(32, 16, 3, 3), int8] */;
%118 = squeeze(%116) /* ty=Tensor[(32), float32] */;
%119 = power(2f /* ty=float32 */, 26f /* ty=float32 */) /* ty=float32 */;
%120 = qnn.quantize(meta[relay.Constant][38] /* ty=Tensor[(32), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int32") /* ty=Tensor[(32), int32] */;
%121 = divide(1f /* ty=float32 */, %119) /* ty=float32 */;
%122 = qnn.conv2d(%99, %117, 0 /* ty=int32 */, 0 /* ty=int32 */, %93, %118, padding=[1, 1, 1, 1], channels=32, kernel_size=[3, 3], out_dtype="int32") /* ty=Tensor[(1, 32, 136, 240), int32] */;
%123 = qnn.requantize(%120, %121, 0 /* ty=int32 */, meta[relay.Constant][39] /* ty=Tensor[(32), float32] */, meta[relay.Constant][40] /* ty=Tensor[(32), int32] */, axis=0, out_dtype="int32") /* ty=Tensor[(32), int32] */;
%124 = nn.bias_add(%122, %123) /* ty=Tensor[(1, 32, 136, 240), int32] */;
%125 = power(2f /* ty=float32 */, 4f /* ty=float32 */) /* ty=float32 */;
%126 = qnn.dequantize(%124, meta[relay.Constant][39] /* ty=Tensor[(32), float32] */, meta[relay.Constant][40] /* ty=Tensor[(32), int32] */, axis=1) /* ty=Tensor[(1, 32, 136, 240), float32] */;
%127 = divide(1f /* ty=float32 */, %125) /* ty=float32 */;
%128 = qnn.quantize(%126, %127, 0 /* ty=int32 */, out_dtype="int8") /* ty=Tensor[(1, 32, 136, 240), int8] */;
%129 = clip(%128, a_min=-127f, a_max=127f) /* ty=Tensor[(1, 32, 136, 240), int8] */;
%130 = maximum(%129, meta[relay.Constant][41] /* ty=int8 */) /* ty=Tensor[(1, 32, 136, 240), int8] */;
%131 = qnn.dequantize(%113, %110, 0 /* ty=int32 */) /* ty=Tensor[(1, 32, 136, 240), float32] */;
%132 = qnn.dequantize(%130, %127, 0 /* ty=int32 */) /* ty=Tensor[(1, 32, 136, 240), float32] */;
%133 = (%131, %132) /* ty=(Tensor[(1, 32, 136, 240), float32], Tensor[(1, 32, 136, 240), float32]) */;
%134 = power(2f /* ty=float32 */, 4f /* ty=float32 */) /* ty=float32 */;
%135 = concatenate(%133, axis=1) /* ty=Tensor[(1, 64, 136, 240), float32] */;
%136 = divide(1f /* ty=float32 */, %134) /* ty=float32 */;
%137 = qnn.quantize(%135, %136, 0 /* ty=int32 */, out_dtype="int8") /* ty=Tensor[(1, 64, 136, 240), int8] */;
%138 = clip(%137, a_min=-127f, a_max=127f) /* ty=Tensor[(1, 64, 136, 240), int8] */;
%139 = power(2f /* ty=float32 */, 3f /* ty=float32 */) /* ty=float32 */;
%140 = qnn.dequantize(%138, %136, 0 /* ty=int32 */) /* ty=Tensor[(1, 64, 136, 240), float32] */;
%141 = divide(1f /* ty=float32 */, %139) /* ty=float32 */;
%142 = qnn.quantize(%140, %141, 0 /* ty=int32 */, out_dtype="int8") /* ty=Tensor[(1, 64, 136, 240), int8] */;
%143 = clip(%142, a_min=-127f, a_max=127f) /* ty=Tensor[(1, 64, 136, 240), int8] */;
%144 = power(2f /* ty=float32 */, 23f /* ty=float32 */) /* ty=float32 */;
%145 = divide(1f /* ty=float32 */, %144) /* ty=float32 */;
%146 = multiply(%145, meta[relay.Constant][43] /* ty=Tensor[(32, 1, 1, 1), float32] */) /* ty=Tensor[(32, 1, 1, 1), float32] */;
%147 = nn.max_pool2d(%143, pool_size=[3, 3], strides=[2, 2], padding=[0, 0, 0, 0], ceil_mode=True) /* ty=Tensor[(1, 64, 68, 120), int8] */;
%148 = qnn.quantize(meta[relay.Constant][42] /* ty=Tensor[(32, 64, 1, 1), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int8", axis=0) /* ty=Tensor[(32, 64, 1, 1), int8] */;
%149 = squeeze(%146) /* ty=Tensor[(32), float32] */;
%150 = power(2f /* ty=float32 */, 26f /* ty=float32 */) /* ty=float32 */;
%151 = qnn.quantize(meta[relay.Constant][44] /* ty=Tensor[(32), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int32") /* ty=Tensor[(32), int32] */;
%152 = divide(1f /* ty=float32 */, %150) /* ty=float32 */;
%153 = qnn.conv2d(%147, %148, 0 /* ty=int32 */, 0 /* ty=int32 */, %141, %149, padding=[0, 0, 0, 0], channels=32, kernel_size=[1, 1], out_dtype="int32") /* ty=Tensor[(1, 32, 68, 120), int32] */;
%154 = qnn.requantize(%151, %152, 0 /* ty=int32 */, meta[relay.Constant][45] /* ty=Tensor[(32), float32] */, meta[relay.Constant][46] /* ty=Tensor[(32), int32] */, axis=0, out_dtype="int32") /* ty=Tensor[(32), int32] */;
%155 = nn.bias_add(%153, %154) /* ty=Tensor[(1, 32, 68, 120), int32] */;
%156 = power(2f /* ty=float32 */, 4f /* ty=float32 */) /* ty=float32 */;
%157 = qnn.dequantize(%155, meta[relay.Constant][45] /* ty=Tensor[(32), float32] */, meta[relay.Constant][46] /* ty=Tensor[(32), int32] */, axis=1) /* ty=Tensor[(1, 32, 68, 120), float32] */;
%158 = divide(1f /* ty=float32 */, %156) /* ty=float32 */;
%159 = qnn.quantize(%157, %158, 0 /* ty=int32 */, out_dtype="int8") /* ty=Tensor[(1, 32, 68, 120), int8] */;
%160 = clip(%159, a_min=-127f, a_max=127f) /* ty=Tensor[(1, 32, 68, 120), int8] */;
%161 = power(2f /* ty=float32 */, 23f /* ty=float32 */) /* ty=float32 */;
%162 = divide(1f /* ty=float32 */, %161) /* ty=float32 */;
%163 = multiply(%162, meta[relay.Constant][49] /* ty=Tensor[(64, 1, 1, 1), float32] */) /* ty=Tensor[(64, 1, 1, 1), float32] */;
%164 = maximum(%160, meta[relay.Constant][47] /* ty=int8 */) /* ty=Tensor[(1, 32, 68, 120), int8] */;
%165 = qnn.quantize(meta[relay.Constant][48] /* ty=Tensor[(64, 32, 1, 1), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int8", axis=0) /* ty=Tensor[(64, 32, 1, 1), int8] */;
%166 = squeeze(%163) /* ty=Tensor[(64), float32] */;
%167 = power(2f /* ty=float32 */, 27f /* ty=float32 */) /* ty=float32 */;
%168 = qnn.quantize(meta[relay.Constant][50] /* ty=Tensor[(64), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int32") /* ty=Tensor[(64), int32] */;
%169 = divide(1f /* ty=float32 */, %167) /* ty=float32 */;
%170 = qnn.conv2d(%164, %165, 0 /* ty=int32 */, 0 /* ty=int32 */, %158, %166, padding=[0, 0, 0, 0], channels=64, kernel_size=[1, 1], out_dtype="int32") /* ty=Tensor[(1, 64, 68, 120), int32] */;
%171 = qnn.requantize(%168, %169, 0 /* ty=int32 */, meta[relay.Constant][51] /* ty=Tensor[(64), float32] */, meta[relay.Constant][52] /* ty=Tensor[(64), int32] */, axis=0, out_dtype="int32") /* ty=Tensor[(64), int32] */;
%172 = nn.bias_add(%170, %171) /* ty=Tensor[(1, 64, 68, 120), int32] */;
%173 = power(2f /* ty=float32 */, 5f /* ty=float32 */) /* ty=float32 */;
%174 = qnn.dequantize(%172, meta[relay.Constant][51] /* ty=Tensor[(64), float32] */, meta[relay.Constant][52] /* ty=Tensor[(64), int32] */, axis=1) /* ty=Tensor[(1, 64, 68, 120), float32] */;
%175 = divide(1f /* ty=float32 */, %173) /* ty=float32 */;
%176 = qnn.quantize(%174, %175, 0 /* ty=int32 */, out_dtype="int8") /* ty=Tensor[(1, 64, 68, 120), int8] */;
%177 = clip(%176, a_min=-127f, a_max=127f) /* ty=Tensor[(1, 64, 68, 120), int8] */;
%178 = maximum(%177, meta[relay.Constant][53] /* ty=int8 */) /* ty=Tensor[(1, 64, 68, 120), int8] */;
%179 = power(2f /* ty=float32 */, 24f /* ty=float32 */) /* ty=float32 */;
%180 = divide(1f /* ty=float32 */, %179) /* ty=float32 */;
%181 = multiply(%180, meta[relay.Constant][55] /* ty=Tensor[(64, 1, 1, 1), float32] */) /* ty=Tensor[(64, 1, 1, 1), float32] */;
%182 = qnn.quantize(meta[relay.Constant][54] /* ty=Tensor[(64, 32, 3, 3), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int8", axis=0) /* ty=Tensor[(64, 32, 3, 3), int8] */;
%183 = squeeze(%181) /* ty=Tensor[(64), float32] */;
%184 = power(2f /* ty=float32 */, 28f /* ty=float32 */) /* ty=float32 */;
%185 = qnn.quantize(meta[relay.Constant][56] /* ty=Tensor[(64), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int32") /* ty=Tensor[(64), int32] */;
%186 = divide(1f /* ty=float32 */, %184) /* ty=float32 */;
%187 = qnn.conv2d(%164, %182, 0 /* ty=int32 */, 0 /* ty=int32 */, %158, %183, padding=[1, 1, 1, 1], channels=64, kernel_size=[3, 3], out_dtype="int32") /* ty=Tensor[(1, 64, 68, 120), int32] */;
%188 = qnn.requantize(%185, %186, 0 /* ty=int32 */, meta[relay.Constant][57] /* ty=Tensor[(64), float32] */, meta[relay.Constant][58] /* ty=Tensor[(64), int32] */, axis=0, out_dtype="int32") /* ty=Tensor[(64), int32] */;
%189 = nn.bias_add(%187, %188) /* ty=Tensor[(1, 64, 68, 120), int32] */;
%190 = power(2f /* ty=float32 */, 4f /* ty=float32 */) /* ty=float32 */;
%191 = qnn.dequantize(%189, meta[relay.Constant][57] /* ty=Tensor[(64), float32] */, meta[relay.Constant][58] /* ty=Tensor[(64), int32] */, axis=1) /* ty=Tensor[(1, 64, 68, 120), float32] */;
%192 = divide(1f /* ty=float32 */, %190) /* ty=float32 */;
%193 = qnn.quantize(%191, %192, 0 /* ty=int32 */, out_dtype="int8") /* ty=Tensor[(1, 64, 68, 120), int8] */;
%194 = clip(%193, a_min=-127f, a_max=127f) /* ty=Tensor[(1, 64, 68, 120), int8] */;
%195 = maximum(%194, meta[relay.Constant][59] /* ty=int8 */) /* ty=Tensor[(1, 64, 68, 120), int8] */;
%196 = qnn.dequantize(%178, %175, 0 /* ty=int32 */) /* ty=Tensor[(1, 64, 68, 120), float32] */;
%197 = qnn.dequantize(%195, %192, 0 /* ty=int32 */) /* ty=Tensor[(1, 64, 68, 120), float32] */;
%198 = (%196, %197) /* ty=(Tensor[(1, 64, 68, 120), float32], Tensor[(1, 64, 68, 120), float32]) */;
%199 = power(2f /* ty=float32 */, 4f /* ty=float32 */) /* ty=float32 */;
%200 = concatenate(%198, axis=1) /* ty=Tensor[(1, 128, 68, 120), float32] */;
%201 = divide(1f /* ty=float32 */, %199) /* ty=float32 */;
%202 = qnn.quantize(%200, %201, 0 /* ty=int32 */, out_dtype="int8") /* ty=Tensor[(1, 128, 68, 120), int8] */;
%203 = power(2f /* ty=float32 */, 24f /* ty=float32 */) /* ty=float32 */;
%204 = divide(1f /* ty=float32 */, %203) /* ty=float32 */;
%205 = multiply(%204, meta[relay.Constant][61] /* ty=Tensor[(8, 1, 1, 1), float32] */) /* ty=Tensor[(8, 1, 1, 1), float32] */;
%206 = clip(%202, a_min=-127f, a_max=127f) /* ty=Tensor[(1, 128, 68, 120), int8] */;
%207 = qnn.quantize(meta[relay.Constant][60] /* ty=Tensor[(8, 128, 1, 1), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int8", axis=0) /* ty=Tensor[(8, 128, 1, 1), int8] */;
%208 = squeeze(%205) /* ty=Tensor[(8), float32] */;
%209 = power(2f /* ty=float32 */, 28f /* ty=float32 */) /* ty=float32 */;
%210 = qnn.quantize(meta[relay.Constant][62] /* ty=Tensor[(8), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int32") /* ty=Tensor[(8), int32] */;
%211 = divide(1f /* ty=float32 */, %209) /* ty=float32 */;
%212 = qnn.conv2d(%206, %207, 0 /* ty=int32 */, 0 /* ty=int32 */, %201, %208, padding=[0, 0, 0, 0], channels=8, kernel_size=[1, 1], out_dtype="int32") /* ty=Tensor[(1, 8, 68, 120), int32] */;
%213 = qnn.requantize(%210, %211, 0 /* ty=int32 */, meta[relay.Constant][63] /* ty=Tensor[(8), float32] */, meta[relay.Constant][64] /* ty=Tensor[(8), int32] */, axis=0, out_dtype="int32") /* ty=Tensor[(8), int32] */;
%214 = nn.bias_add(%212, %213) /* ty=Tensor[(1, 8, 68, 120), int32] */;
%215 = power(2f /* ty=float32 */, 4f /* ty=float32 */) /* ty=float32 */;
%216 = qnn.dequantize(%214, meta[relay.Constant][63] /* ty=Tensor[(8), float32] */, meta[relay.Constant][64] /* ty=Tensor[(8), int32] */, axis=1) /* ty=Tensor[(1, 8, 68, 120), float32] */;
%217 = divide(1f /* ty=float32 */, %215) /* ty=float32 */;
%218 = qnn.quantize(%216, %217, 0 /* ty=int32 */, out_dtype="int8") /* ty=Tensor[(1, 8, 68, 120), int8] */;
%219 = clip(%218, a_min=-127f, a_max=127f) /* ty=Tensor[(1, 8, 68, 120), int8] */;
%220 = power(2f /* ty=float32 */, 22f /* ty=float32 */) /* ty=float32 */;
%221 = divide(1f /* ty=float32 */, %220) /* ty=float32 */;
%222 = multiply(%221, meta[relay.Constant][67] /* ty=Tensor[(16, 1, 1, 1), float32] */) /* ty=Tensor[(16, 1, 1, 1), float32] */;
%223 = maximum(%219, meta[relay.Constant][65] /* ty=int8 */) /* ty=Tensor[(1, 8, 68, 120), int8] */;
%224 = qnn.quantize(meta[relay.Constant][66] /* ty=Tensor[(16, 8, 1, 1), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int8", axis=0) /* ty=Tensor[(16, 8, 1, 1), int8] */;
%225 = squeeze(%222) /* ty=Tensor[(16), float32] */;
%226 = power(2f /* ty=float32 */, 26f /* ty=float32 */) /* ty=float32 */;
%227 = qnn.quantize(meta[relay.Constant][68] /* ty=Tensor[(16), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int32") /* ty=Tensor[(16), int32] */;
%228 = divide(1f /* ty=float32 */, %226) /* ty=float32 */;
%229 = qnn.conv2d(%223, %224, 0 /* ty=int32 */, 0 /* ty=int32 */, %217, %225, padding=[0, 0, 0, 0], channels=16, kernel_size=[1, 1], out_dtype="int32") /* ty=Tensor[(1, 16, 68, 120), int32] */;
%230 = qnn.requantize(%227, %228, 0 /* ty=int32 */, meta[relay.Constant][69] /* ty=Tensor[(16), float32] */, meta[relay.Constant][70] /* ty=Tensor[(16), int32] */, axis=0, out_dtype="int32") /* ty=Tensor[(16), int32] */;
%231 = nn.bias_add(%229, %230) /* ty=Tensor[(1, 16, 68, 120), int32] */;
%232 = power(2f /* ty=float32 */, 3f /* ty=float32 */) /* ty=float32 */;
%233 = qnn.dequantize(%231, meta[relay.Constant][69] /* ty=Tensor[(16), float32] */, meta[relay.Constant][70] /* ty=Tensor[(16), int32] */, axis=1) /* ty=Tensor[(1, 16, 68, 120), float32] */;
%234 = divide(1f /* ty=float32 */, %232) /* ty=float32 */;
%235 = qnn.quantize(%233, %234, 0 /* ty=int32 */, out_dtype="int8") /* ty=Tensor[(1, 16, 68, 120), int8] */;
%236 = clip(%235, a_min=-127f, a_max=127f) /* ty=Tensor[(1, 16, 68, 120), int8] */;
%237 = maximum(%236, meta[relay.Constant][71] /* ty=int8 */) /* ty=Tensor[(1, 16, 68, 120), int8] */;
%238 = power(2f /* ty=float32 */, 23f /* ty=float32 */) /* ty=float32 */;
%239 = divide(1f /* ty=float32 */, %238) /* ty=float32 */;
%240 = multiply(%239, meta[relay.Constant][73] /* ty=Tensor[(16, 1, 1, 1), float32] */) /* ty=Tensor[(16, 1, 1, 1), float32] */;
%241 = qnn.quantize(meta[relay.Constant][72] /* ty=Tensor[(16, 8, 3, 3), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int8", axis=0) /* ty=Tensor[(16, 8, 3, 3), int8] */;
%242 = squeeze(%240) /* ty=Tensor[(16), float32] */;
%243 = power(2f /* ty=float32 */, 27f /* ty=float32 */) /* ty=float32 */;
%244 = qnn.quantize(meta[relay.Constant][74] /* ty=Tensor[(16), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int32") /* ty=Tensor[(16), int32] */;
%245 = divide(1f /* ty=float32 */, %243) /* ty=float32 */;
%246 = qnn.conv2d(%223, %241, 0 /* ty=int32 */, 0 /* ty=int32 */, %217, %242, padding=[1, 1, 1, 1], channels=16, kernel_size=[3, 3], out_dtype="int32") /* ty=Tensor[(1, 16, 68, 120), int32] */;
%247 = qnn.requantize(%244, %245, 0 /* ty=int32 */, meta[relay.Constant][75] /* ty=Tensor[(16), float32] */, meta[relay.Constant][76] /* ty=Tensor[(16), int32] */, axis=0, out_dtype="int32") /* ty=Tensor[(16), int32] */;
%248 = nn.bias_add(%246, %247) /* ty=Tensor[(1, 16, 68, 120), int32] */;
%249 = power(2f /* ty=float32 */, 3f /* ty=float32 */) /* ty=float32 */;
%250 = qnn.dequantize(%248, meta[relay.Constant][75] /* ty=Tensor[(16), float32] */, meta[relay.Constant][76] /* ty=Tensor[(16), int32] */, axis=1) /* ty=Tensor[(1, 16, 68, 120), float32] */;
%251 = divide(1f /* ty=float32 */, %249) /* ty=float32 */;
%252 = qnn.quantize(%250, %251, 0 /* ty=int32 */, out_dtype="int8") /* ty=Tensor[(1, 16, 68, 120), int8] */;
%253 = clip(%252, a_min=-127f, a_max=127f) /* ty=Tensor[(1, 16, 68, 120), int8] */;
%254 = maximum(%253, meta[relay.Constant][77] /* ty=int8 */) /* ty=Tensor[(1, 16, 68, 120), int8] */;
%255 = qnn.dequantize(%237, %234, 0 /* ty=int32 */) /* ty=Tensor[(1, 16, 68, 120), float32] */;
%256 = qnn.dequantize(%254, %251, 0 /* ty=int32 */) /* ty=Tensor[(1, 16, 68, 120), float32] */;
%257 = (%255, %256) /* ty=(Tensor[(1, 16, 68, 120), float32], Tensor[(1, 16, 68, 120), float32]) */;
%258 = power(2f /* ty=float32 */, 3f /* ty=float32 */) /* ty=float32 */;
%259 = concatenate(%257, axis=1) /* ty=Tensor[(1, 32, 68, 120), float32] */;
%260 = divide(1f /* ty=float32 */, %258) /* ty=float32 */;
%261 = qnn.quantize(%259, %260, 0 /* ty=int32 */, out_dtype="int8") /* ty=Tensor[(1, 32, 68, 120), int8] */;
%262 = clip(%261, a_min=-127f, a_max=127f) /* ty=Tensor[(1, 32, 68, 120), int8] */;
%263 = power(2f /* ty=float32 */, 3f /* ty=float32 */) /* ty=float32 */;
%264 = qnn.dequantize(%262, %260, 0 /* ty=int32 */) /* ty=Tensor[(1, 32, 68, 120), float32] */;
%265 = divide(1f /* ty=float32 */, %263) /* ty=float32 */;
%266 = qnn.quantize(%264, %265, 0 /* ty=int32 */, out_dtype="int8") /* ty=Tensor[(1, 32, 68, 120), int8] */;
%267 = clip(%266, a_min=-127f, a_max=127f) /* ty=Tensor[(1, 32, 68, 120), int8] */;
%268 = power(2f /* ty=float32 */, 23f /* ty=float32 */) /* ty=float32 */;
%269 = divide(1f /* ty=float32 */, %268) /* ty=float32 */;
%270 = multiply(%269, meta[relay.Constant][79] /* ty=Tensor[(16, 1, 1, 1), float32] */) /* ty=Tensor[(16, 1, 1, 1), float32] */;
%271 = nn.max_pool2d(%267, pool_size=[3, 3], strides=[2, 2], padding=[0, 0, 0, 0], ceil_mode=True) /* ty=Tensor[(1, 32, 34, 60), int8] */;
%272 = qnn.quantize(meta[relay.Constant][78] /* ty=Tensor[(16, 32, 1, 1), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int8", axis=0) /* ty=Tensor[(16, 32, 1, 1), int8] */;
%273 = squeeze(%270) /* ty=Tensor[(16), float32] */;
%274 = power(2f /* ty=float32 */, 26f /* ty=float32 */) /* ty=float32 */;
%275 = qnn.quantize(meta[relay.Constant][80] /* ty=Tensor[(16), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int32") /* ty=Tensor[(16), int32] */;
%276 = divide(1f /* ty=float32 */, %274) /* ty=float32 */;
%277 = qnn.conv2d(%271, %272, 0 /* ty=int32 */, 0 /* ty=int32 */, %265, %273, padding=[0, 0, 0, 0], channels=16, kernel_size=[1, 1], out_dtype="int32") /* ty=Tensor[(1, 16, 34, 60), int32] */;
%278 = qnn.requantize(%275, %276, 0 /* ty=int32 */, meta[relay.Constant][81] /* ty=Tensor[(16), float32] */, meta[relay.Constant][82] /* ty=Tensor[(16), int32] */, axis=0, out_dtype="int32") /* ty=Tensor[(16), int32] */;
%279 = nn.bias_add(%277, %278) /* ty=Tensor[(1, 16, 34, 60), int32] */;
%280 = power(2f /* ty=float32 */, 4f /* ty=float32 */) /* ty=float32 */;
%281 = qnn.dequantize(%279, meta[relay.Constant][81] /* ty=Tensor[(16), float32] */, meta[relay.Constant][82] /* ty=Tensor[(16), int32] */, axis=1) /* ty=Tensor[(1, 16, 34, 60), float32] */;
%282 = divide(1f /* ty=float32 */, %280) /* ty=float32 */;
%283 = qnn.quantize(%281, %282, 0 /* ty=int32 */, out_dtype="int8") /* ty=Tensor[(1, 16, 34, 60), int8] */;
%284 = clip(%283, a_min=-127f, a_max=127f) /* ty=Tensor[(1, 16, 34, 60), int8] */;
%285 = power(2f /* ty=float32 */, 23f /* ty=float32 */) /* ty=float32 */;
%286 = divide(1f /* ty=float32 */, %285) /* ty=float32 */;
%287 = multiply(%286, meta[relay.Constant][85] /* ty=Tensor[(32, 1, 1, 1), float32] */) /* ty=Tensor[(32, 1, 1, 1), float32] */;
%288 = maximum(%284, meta[relay.Constant][83] /* ty=int8 */) /* ty=Tensor[(1, 16, 34, 60), int8] */;
%289 = qnn.quantize(meta[relay.Constant][84] /* ty=Tensor[(32, 16, 1, 1), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int8", axis=0) /* ty=Tensor[(32, 16, 1, 1), int8] */;
%290 = squeeze(%287) /* ty=Tensor[(32), float32] */;
%291 = power(2f /* ty=float32 */, 27f /* ty=float32 */) /* ty=float32 */;
%292 = qnn.quantize(meta[relay.Constant][86] /* ty=Tensor[(32), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int32") /* ty=Tensor[(32), int32] */;
%293 = divide(1f /* ty=float32 */, %291) /* ty=float32 */;
%294 = qnn.conv2d(%288, %289, 0 /* ty=int32 */, 0 /* ty=int32 */, %282, %290, padding=[0, 0, 0, 0], channels=32, kernel_size=[1, 1], out_dtype="int32") /* ty=Tensor[(1, 32, 34, 60), int32] */;
%295 = qnn.requantize(%292, %293, 0 /* ty=int32 */, meta[relay.Constant][87] /* ty=Tensor[(32), float32] */, meta[relay.Constant][88] /* ty=Tensor[(32), int32] */, axis=0, out_dtype="int32") /* ty=Tensor[(32), int32] */;
%296 = nn.bias_add(%294, %295) /* ty=Tensor[(1, 32, 34, 60), int32] */;
%297 = power(2f /* ty=float32 */, 5f /* ty=float32 */) /* ty=float32 */;
%298 = qnn.dequantize(%296, meta[relay.Constant][87] /* ty=Tensor[(32), float32] */, meta[relay.Constant][88] /* ty=Tensor[(32), int32] */, axis=1) /* ty=Tensor[(1, 32, 34, 60), float32] */;
%299 = divide(1f /* ty=float32 */, %297) /* ty=float32 */;
%300 = qnn.quantize(%298, %299, 0 /* ty=int32 */, out_dtype="int8") /* ty=Tensor[(1, 32, 34, 60), int8] */;
%301 = clip(%300, a_min=-127f, a_max=127f) /* ty=Tensor[(1, 32, 34, 60), int8] */;
%302 = maximum(%301, meta[relay.Constant][89] /* ty=int8 */) /* ty=Tensor[(1, 32, 34, 60), int8] */;
%303 = power(2f /* ty=float32 */, 23f /* ty=float32 */) /* ty=float32 */;
%304 = divide(1f /* ty=float32 */, %303) /* ty=float32 */;
%305 = multiply(%304, meta[relay.Constant][91] /* ty=Tensor[(32, 1, 1, 1), float32] */) /* ty=Tensor[(32, 1, 1, 1), float32] */;
%306 = qnn.quantize(meta[relay.Constant][90] /* ty=Tensor[(32, 16, 3, 3), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int8", axis=0) /* ty=Tensor[(32, 16, 3, 3), int8] */;
%307 = squeeze(%305) /* ty=Tensor[(32), float32] */;
%308 = power(2f /* ty=float32 */, 27f /* ty=float32 */) /* ty=float32 */;
%309 = qnn.quantize(meta[relay.Constant][92] /* ty=Tensor[(32), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int32") /* ty=Tensor[(32), int32] */;
%310 = divide(1f /* ty=float32 */, %308) /* ty=float32 */;
%311 = qnn.conv2d(%288, %306, 0 /* ty=int32 */, 0 /* ty=int32 */, %282, %307, padding=[1, 1, 1, 1], channels=32, kernel_size=[3, 3], out_dtype="int32") /* ty=Tensor[(1, 32, 34, 60), int32] */;
%312 = qnn.requantize(%309, %310, 0 /* ty=int32 */, meta[relay.Constant][93] /* ty=Tensor[(32), float32] */, meta[relay.Constant][94] /* ty=Tensor[(32), int32] */, axis=0, out_dtype="int32") /* ty=Tensor[(32), int32] */;
%313 = nn.bias_add(%311, %312) /* ty=Tensor[(1, 32, 34, 60), int32] */;
%314 = power(2f /* ty=float32 */, 3f /* ty=float32 */) /* ty=float32 */;
%315 = qnn.dequantize(%313, meta[relay.Constant][93] /* ty=Tensor[(32), float32] */, meta[relay.Constant][94] /* ty=Tensor[(32), int32] */, axis=1) /* ty=Tensor[(1, 32, 34, 60), float32] */;
%316 = divide(1f /* ty=float32 */, %314) /* ty=float32 */;
%317 = qnn.quantize(%315, %316, 0 /* ty=int32 */, out_dtype="int8") /* ty=Tensor[(1, 32, 34, 60), int8] */;
%318 = clip(%317, a_min=-127f, a_max=127f) /* ty=Tensor[(1, 32, 34, 60), int8] */;
%319 = maximum(%318, meta[relay.Constant][95] /* ty=int8 */) /* ty=Tensor[(1, 32, 34, 60), int8] */;
%320 = qnn.dequantize(%302, %299, 0 /* ty=int32 */) /* ty=Tensor[(1, 32, 34, 60), float32] */;
%321 = qnn.dequantize(%319, %316, 0 /* ty=int32 */) /* ty=Tensor[(1, 32, 34, 60), float32] */;
%322 = (%320, %321) /* ty=(Tensor[(1, 32, 34, 60), float32], Tensor[(1, 32, 34, 60), float32]) */;
%323 = power(2f /* ty=float32 */, 4f /* ty=float32 */) /* ty=float32 */;
%324 = concatenate(%322, axis=1) /* ty=Tensor[(1, 64, 34, 60), float32] */;
%325 = divide(1f /* ty=float32 */, %323) /* ty=float32 */;
%326 = qnn.quantize(%324, %325, 0 /* ty=int32 */, out_dtype="int8") /* ty=Tensor[(1, 64, 34, 60), int8] */;
%327 = power(2f /* ty=float32 */, 23f /* ty=float32 */) /* ty=float32 */;
%328 = divide(1f /* ty=float32 */, %327) /* ty=float32 */;
%329 = multiply(%328, meta[relay.Constant][97] /* ty=Tensor[(16, 1, 1, 1), float32] */) /* ty=Tensor[(16, 1, 1, 1), float32] */;
%330 = clip(%326, a_min=-127f, a_max=127f) /* ty=Tensor[(1, 64, 34, 60), int8] */;
%331 = qnn.quantize(meta[relay.Constant][96] /* ty=Tensor[(16, 64, 1, 1), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int8", axis=0) /* ty=Tensor[(16, 64, 1, 1), int8] */;
%332 = squeeze(%329) /* ty=Tensor[(16), float32] */;
%333 = power(2f /* ty=float32 */, 27f /* ty=float32 */) /* ty=float32 */;
%334 = qnn.quantize(meta[relay.Constant][98] /* ty=Tensor[(16), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int32") /* ty=Tensor[(16), int32] */;
%335 = divide(1f /* ty=float32 */, %333) /* ty=float32 */;
%336 = qnn.conv2d(%330, %331, 0 /* ty=int32 */, 0 /* ty=int32 */, %325, %332, padding=[0, 0, 0, 0], channels=16, kernel_size=[1, 1], out_dtype="int32") /* ty=Tensor[(1, 16, 34, 60), int32] */;
%337 = qnn.requantize(%334, %335, 0 /* ty=int32 */, meta[relay.Constant][99] /* ty=Tensor[(16), float32] */, meta[relay.Constant][100] /* ty=Tensor[(16), int32] */, axis=0, out_dtype="int32") /* ty=Tensor[(16), int32] */;
%338 = nn.bias_add(%336, %337) /* ty=Tensor[(1, 16, 34, 60), int32] */;
%339 = power(2f /* ty=float32 */, 4f /* ty=float32 */) /* ty=float32 */;
%340 = qnn.dequantize(%338, meta[relay.Constant][99] /* ty=Tensor[(16), float32] */, meta[relay.Constant][100] /* ty=Tensor[(16), int32] */, axis=1) /* ty=Tensor[(1, 16, 34, 60), float32] */;
%341 = divide(1f /* ty=float32 */, %339) /* ty=float32 */;
%342 = qnn.quantize(%340, %341, 0 /* ty=int32 */, out_dtype="int8") /* ty=Tensor[(1, 16, 34, 60), int8] */;
%343 = clip(%342, a_min=-127f, a_max=127f) /* ty=Tensor[(1, 16, 34, 60), int8] */;
%344 = power(2f /* ty=float32 */, 22f /* ty=float32 */) /* ty=float32 */;
%345 = divide(1f /* ty=float32 */, %344) /* ty=float32 */;
%346 = multiply(%345, meta[relay.Constant][103] /* ty=Tensor[(32, 1, 1, 1), float32] */) /* ty=Tensor[(32, 1, 1, 1), float32] */;
%347 = maximum(%343, meta[relay.Constant][101] /* ty=int8 */) /* ty=Tensor[(1, 16, 34, 60), int8] */;
%348 = qnn.quantize(meta[relay.Constant][102] /* ty=Tensor[(32, 16, 1, 1), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int8", axis=0) /* ty=Tensor[(32, 16, 1, 1), int8] */;
%349 = squeeze(%346) /* ty=Tensor[(32), float32] */;
%350 = power(2f /* ty=float32 */, 26f /* ty=float32 */) /* ty=float32 */;
%351 = qnn.quantize(meta[relay.Constant][104] /* ty=Tensor[(32), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int32") /* ty=Tensor[(32), int32] */;
%352 = divide(1f /* ty=float32 */, %350) /* ty=float32 */;
%353 = qnn.conv2d(%347, %348, 0 /* ty=int32 */, 0 /* ty=int32 */, %341, %349, padding=[0, 0, 0, 0], channels=32, kernel_size=[1, 1], out_dtype="int32") /* ty=Tensor[(1, 32, 34, 60), int32] */;
%354 = qnn.requantize(%351, %352, 0 /* ty=int32 */, meta[relay.Constant][105] /* ty=Tensor[(32), float32] */, meta[relay.Constant][106] /* ty=Tensor[(32), int32] */, axis=0, out_dtype="int32") /* ty=Tensor[(32), int32] */;
%355 = nn.bias_add(%353, %354) /* ty=Tensor[(1, 32, 34, 60), int32] */;
%356 = power(2f /* ty=float32 */, 4f /* ty=float32 */) /* ty=float32 */;
%357 = qnn.dequantize(%355, meta[relay.Constant][105] /* ty=Tensor[(32), float32] */, meta[relay.Constant][106] /* ty=Tensor[(32), int32] */, axis=1) /* ty=Tensor[(1, 32, 34, 60), float32] */;
%358 = divide(1f /* ty=float32 */, %356) /* ty=float32 */;
%359 = qnn.quantize(%357, %358, 0 /* ty=int32 */, out_dtype="int8") /* ty=Tensor[(1, 32, 34, 60), int8] */;
%360 = clip(%359, a_min=-127f, a_max=127f) /* ty=Tensor[(1, 32, 34, 60), int8] */;
%361 = maximum(%360, meta[relay.Constant][107] /* ty=int8 */) /* ty=Tensor[(1, 32, 34, 60), int8] */;
%362 = power(2f /* ty=float32 */, 23f /* ty=float32 */) /* ty=float32 */;
%363 = divide(1f /* ty=float32 */, %362) /* ty=float32 */;
%364 = multiply(%363, meta[relay.Constant][109] /* ty=Tensor[(32, 1, 1, 1), float32] */) /* ty=Tensor[(32, 1, 1, 1), float32] */;
%365 = qnn.quantize(meta[relay.Constant][108] /* ty=Tensor[(32, 16, 3, 3), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int8", axis=0) /* ty=Tensor[(32, 16, 3, 3), int8] */;
%366 = squeeze(%364) /* ty=Tensor[(32), float32] */;
%367 = power(2f /* ty=float32 */, 27f /* ty=float32 */) /* ty=float32 */;
%368 = qnn.quantize(meta[relay.Constant][110] /* ty=Tensor[(32), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int32") /* ty=Tensor[(32), int32] */;
%369 = divide(1f /* ty=float32 */, %367) /* ty=float32 */;
%370 = qnn.conv2d(%347, %365, 0 /* ty=int32 */, 0 /* ty=int32 */, %341, %366, padding=[1, 1, 1, 1], channels=32, kernel_size=[3, 3], out_dtype="int32") /* ty=Tensor[(1, 32, 34, 60), int32] */;
%371 = qnn.requantize(%368, %369, 0 /* ty=int32 */, meta[relay.Constant][111] /* ty=Tensor[(32), float32] */, meta[relay.Constant][112] /* ty=Tensor[(32), int32] */, axis=0, out_dtype="int32") /* ty=Tensor[(32), int32] */;
%372 = nn.bias_add(%370, %371) /* ty=Tensor[(1, 32, 34, 60), int32] */;
%373 = power(2f /* ty=float32 */, 3f /* ty=float32 */) /* ty=float32 */;
%374 = qnn.dequantize(%372, meta[relay.Constant][111] /* ty=Tensor[(32), float32] */, meta[relay.Constant][112] /* ty=Tensor[(32), int32] */, axis=1) /* ty=Tensor[(1, 32, 34, 60), float32] */;
%375 = divide(1f /* ty=float32 */, %373) /* ty=float32 */;
%376 = qnn.quantize(%374, %375, 0 /* ty=int32 */, out_dtype="int8") /* ty=Tensor[(1, 32, 34, 60), int8] */;
%377 = clip(%376, a_min=-127f, a_max=127f) /* ty=Tensor[(1, 32, 34, 60), int8] */;
%378 = maximum(%377, meta[relay.Constant][113] /* ty=int8 */) /* ty=Tensor[(1, 32, 34, 60), int8] */;
%379 = qnn.dequantize(%361, %358, 0 /* ty=int32 */) /* ty=Tensor[(1, 32, 34, 60), float32] */;
%380 = qnn.dequantize(%378, %375, 0 /* ty=int32 */) /* ty=Tensor[(1, 32, 34, 60), float32] */;
%381 = (%379, %380) /* ty=(Tensor[(1, 32, 34, 60), float32], Tensor[(1, 32, 34, 60), float32]) */;
%382 = power(2f /* ty=float32 */, 3f /* ty=float32 */) /* ty=float32 */;
%383 = concatenate(%381, axis=1) /* ty=Tensor[(1, 64, 34, 60), float32] */;
%384 = divide(1f /* ty=float32 */, %382) /* ty=float32 */;
%385 = qnn.quantize(%383, %384, 0 /* ty=int32 */, out_dtype="int8") /* ty=Tensor[(1, 64, 34, 60), int8] */;
%386 = clip(%385, a_min=-127f, a_max=127f) /* ty=Tensor[(1, 64, 34, 60), int8] */;
%387 = power(2f /* ty=float32 */, 3f /* ty=float32 */) /* ty=float32 */;
%388 = qnn.dequantize(%386, %384, 0 /* ty=int32 */) /* ty=Tensor[(1, 64, 34, 60), float32] */;
%389 = divide(1f /* ty=float32 */, %387) /* ty=float32 */;
%390 = qnn.quantize(%388, %389, 0 /* ty=int32 */, out_dtype="int8") /* ty=Tensor[(1, 64, 34, 60), int8] */;
%391 = clip(%390, a_min=-127f, a_max=127f) /* ty=Tensor[(1, 64, 34, 60), int8] */;
%392 = power(2f /* ty=float32 */, 24f /* ty=float32 */) /* ty=float32 */;
%393 = divide(1f /* ty=float32 */, %392) /* ty=float32 */;
%394 = multiply(%393, meta[relay.Constant][115] /* ty=Tensor[(16, 1, 1, 1), float32] */) /* ty=Tensor[(16, 1, 1, 1), float32] */;
%395 = nn.max_pool2d(%391, pool_size=[3, 3], strides=[2, 2], padding=[0, 0, 0, 0], ceil_mode=True) /* ty=Tensor[(1, 64, 17, 30), int8] */;
%396 = qnn.quantize(meta[relay.Constant][114] /* ty=Tensor[(16, 64, 1, 1), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int8", axis=0) /* ty=Tensor[(16, 64, 1, 1), int8] */;
%397 = squeeze(%394) /* ty=Tensor[(16), float32] */;
%398 = power(2f /* ty=float32 */, 27f /* ty=float32 */) /* ty=float32 */;
%399 = qnn.quantize(meta[relay.Constant][116] /* ty=Tensor[(16), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int32") /* ty=Tensor[(16), int32] */;
%400 = divide(1f /* ty=float32 */, %398) /* ty=float32 */;
%401 = qnn.conv2d(%395, %396, 0 /* ty=int32 */, 0 /* ty=int32 */, %389, %397, padding=[0, 0, 0, 0], channels=16, kernel_size=[1, 1], out_dtype="int32") /* ty=Tensor[(1, 16, 17, 30), int32] */;
%402 = qnn.requantize(%399, %400, 0 /* ty=int32 */, meta[relay.Constant][117] /* ty=Tensor[(16), float32] */, meta[relay.Constant][118] /* ty=Tensor[(16), int32] */, axis=0, out_dtype="int32") /* ty=Tensor[(16), int32] */;
%403 = nn.bias_add(%401, %402) /* ty=Tensor[(1, 16, 17, 30), int32] */;
%404 = power(2f /* ty=float32 */, 4f /* ty=float32 */) /* ty=float32 */;
%405 = qnn.dequantize(%403, meta[relay.Constant][117] /* ty=Tensor[(16), float32] */, meta[relay.Constant][118] /* ty=Tensor[(16), int32] */, axis=1) /* ty=Tensor[(1, 16, 17, 30), float32] */;
%406 = divide(1f /* ty=float32 */, %404) /* ty=float32 */;
%407 = qnn.quantize(%405, %406, 0 /* ty=int32 */, out_dtype="int8") /* ty=Tensor[(1, 16, 17, 30), int8] */;
%408 = clip(%407, a_min=-127f, a_max=127f) /* ty=Tensor[(1, 16, 17, 30), int8] */;
%409 = power(2f /* ty=float32 */, 23f /* ty=float32 */) /* ty=float32 */;
%410 = divide(1f /* ty=float32 */, %409) /* ty=float32 */;
%411 = multiply(%410, meta[relay.Constant][121] /* ty=Tensor[(32, 1, 1, 1), float32] */) /* ty=Tensor[(32, 1, 1, 1), float32] */;
%412 = maximum(%408, meta[relay.Constant][119] /* ty=int8 */) /* ty=Tensor[(1, 16, 17, 30), int8] */;
%413 = qnn.quantize(meta[relay.Constant][120] /* ty=Tensor[(32, 16, 1, 1), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int8", axis=0) /* ty=Tensor[(32, 16, 1, 1), int8] */;
%414 = squeeze(%411) /* ty=Tensor[(32), float32] */;
%415 = power(2f /* ty=float32 */, 27f /* ty=float32 */) /* ty=float32 */;
%416 = qnn.quantize(meta[relay.Constant][122] /* ty=Tensor[(32), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int32") /* ty=Tensor[(32), int32] */;
%417 = divide(1f /* ty=float32 */, %415) /* ty=float32 */;
%418 = qnn.conv2d(%412, %413, 0 /* ty=int32 */, 0 /* ty=int32 */, %406, %414, padding=[0, 0, 0, 0], channels=32, kernel_size=[1, 1], out_dtype="int32") /* ty=Tensor[(1, 32, 17, 30), int32] */;
%419 = qnn.requantize(%416, %417, 0 /* ty=int32 */, meta[relay.Constant][123] /* ty=Tensor[(32), float32] */, meta[relay.Constant][124] /* ty=Tensor[(32), int32] */, axis=0, out_dtype="int32") /* ty=Tensor[(32), int32] */;
%420 = nn.bias_add(%418, %419) /* ty=Tensor[(1, 32, 17, 30), int32] */;
%421 = power(2f /* ty=float32 */, 5f /* ty=float32 */) /* ty=float32 */;
%422 = qnn.dequantize(%420, meta[relay.Constant][123] /* ty=Tensor[(32), float32] */, meta[relay.Constant][124] /* ty=Tensor[(32), int32] */, axis=1) /* ty=Tensor[(1, 32, 17, 30), float32] */;
%423 = divide(1f /* ty=float32 */, %421) /* ty=float32 */;
%424 = qnn.quantize(%422, %423, 0 /* ty=int32 */, out_dtype="int8") /* ty=Tensor[(1, 32, 17, 30), int8] */;
%425 = clip(%424, a_min=-127f, a_max=127f) /* ty=Tensor[(1, 32, 17, 30), int8] */;
%426 = maximum(%425, meta[relay.Constant][125] /* ty=int8 */) /* ty=Tensor[(1, 32, 17, 30), int8] */;
%427 = power(2f /* ty=float32 */, 24f /* ty=float32 */) /* ty=float32 */;
%428 = divide(1f /* ty=float32 */, %427) /* ty=float32 */;
%429 = multiply(%428, meta[relay.Constant][127] /* ty=Tensor[(32, 1, 1, 1), float32] */) /* ty=Tensor[(32, 1, 1, 1), float32] */;
%430 = qnn.quantize(meta[relay.Constant][126] /* ty=Tensor[(32, 16, 3, 3), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int8", axis=0) /* ty=Tensor[(32, 16, 3, 3), int8] */;
%431 = squeeze(%429) /* ty=Tensor[(32), float32] */;
%432 = power(2f /* ty=float32 */, 28f /* ty=float32 */) /* ty=float32 */;
%433 = qnn.quantize(meta[relay.Constant][128] /* ty=Tensor[(32), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int32") /* ty=Tensor[(32), int32] */;
%434 = divide(1f /* ty=float32 */, %432) /* ty=float32 */;
%435 = qnn.conv2d(%412, %430, 0 /* ty=int32 */, 0 /* ty=int32 */, %406, %431, padding=[1, 1, 1, 1], channels=32, kernel_size=[3, 3], out_dtype="int32") /* ty=Tensor[(1, 32, 17, 30), int32] */;
%436 = qnn.requantize(%433, %434, 0 /* ty=int32 */, meta[relay.Constant][129] /* ty=Tensor[(32), float32] */, meta[relay.Constant][130] /* ty=Tensor[(32), int32] */, axis=0, out_dtype="int32") /* ty=Tensor[(32), int32] */;
%437 = nn.bias_add(%435, %436) /* ty=Tensor[(1, 32, 17, 30), int32] */;
%438 = power(2f /* ty=float32 */, 4f /* ty=float32 */) /* ty=float32 */;
%439 = qnn.dequantize(%437, meta[relay.Constant][129] /* ty=Tensor[(32), float32] */, meta[relay.Constant][130] /* ty=Tensor[(32), int32] */, axis=1) /* ty=Tensor[(1, 32, 17, 30), float32] */;
%440 = divide(1f /* ty=float32 */, %438) /* ty=float32 */;
%441 = qnn.quantize(%439, %440, 0 /* ty=int32 */, out_dtype="int8") /* ty=Tensor[(1, 32, 17, 30), int8] */;
%442 = clip(%441, a_min=-127f, a_max=127f) /* ty=Tensor[(1, 32, 17, 30), int8] */;
%443 = maximum(%442, meta[relay.Constant][131] /* ty=int8 */) /* ty=Tensor[(1, 32, 17, 30), int8] */;
%444 = qnn.dequantize(%426, %423, 0 /* ty=int32 */) /* ty=Tensor[(1, 32, 17, 30), float32] */;
%445 = qnn.dequantize(%443, %440, 0 /* ty=int32 */) /* ty=Tensor[(1, 32, 17, 30), float32] */;
%446 = (%444, %445) /* ty=(Tensor[(1, 32, 17, 30), float32], Tensor[(1, 32, 17, 30), float32]) */;
%447 = power(2f /* ty=float32 */, 4f /* ty=float32 */) /* ty=float32 */;
%448 = concatenate(%446, axis=1) /* ty=Tensor[(1, 64, 17, 30), float32] */;
%449 = divide(1f /* ty=float32 */, %447) /* ty=float32 */;
%450 = qnn.quantize(%448, %449, 0 /* ty=int32 */, out_dtype="int8") /* ty=Tensor[(1, 64, 17, 30), int8] */;
%451 = power(2f /* ty=float32 */, 23f /* ty=float32 */) /* ty=float32 */;
%452 = divide(1f /* ty=float32 */, %451) /* ty=float32 */;
%453 = multiply(%452, meta[relay.Constant][133] /* ty=Tensor[(16, 1, 1, 1), float32] */) /* ty=Tensor[(16, 1, 1, 1), float32] */;
%454 = clip(%450, a_min=-127f, a_max=127f) /* ty=Tensor[(1, 64, 17, 30), int8] */;
%455 = qnn.quantize(meta[relay.Constant][132] /* ty=Tensor[(16, 64, 1, 1), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int8", axis=0) /* ty=Tensor[(16, 64, 1, 1), int8] */;
%456 = squeeze(%453) /* ty=Tensor[(16), float32] */;
%457 = power(2f /* ty=float32 */, 27f /* ty=float32 */) /* ty=float32 */;
%458 = qnn.quantize(meta[relay.Constant][134] /* ty=Tensor[(16), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int32") /* ty=Tensor[(16), int32] */;
%459 = divide(1f /* ty=float32 */, %457) /* ty=float32 */;
%460 = qnn.conv2d(%454, %455, 0 /* ty=int32 */, 0 /* ty=int32 */, %449, %456, padding=[0, 0, 0, 0], channels=16, kernel_size=[1, 1], out_dtype="int32") /* ty=Tensor[(1, 16, 17, 30), int32] */;
%461 = qnn.requantize(%458, %459, 0 /* ty=int32 */, meta[relay.Constant][135] /* ty=Tensor[(16), float32] */, meta[relay.Constant][136] /* ty=Tensor[(16), int32] */, axis=0, out_dtype="int32") /* ty=Tensor[(16), int32] */;
%462 = nn.bias_add(%460, %461) /* ty=Tensor[(1, 16, 17, 30), int32] */;
%463 = power(2f /* ty=float32 */, 4f /* ty=float32 */) /* ty=float32 */;
%464 = qnn.dequantize(%462, meta[relay.Constant][135] /* ty=Tensor[(16), float32] */, meta[relay.Constant][136] /* ty=Tensor[(16), int32] */, axis=1) /* ty=Tensor[(1, 16, 17, 30), float32] */;
%465 = divide(1f /* ty=float32 */, %463) /* ty=float32 */;
%466 = qnn.quantize(%464, %465, 0 /* ty=int32 */, out_dtype="int8") /* ty=Tensor[(1, 16, 17, 30), int8] */;
%467 = clip(%466, a_min=-127f, a_max=127f) /* ty=Tensor[(1, 16, 17, 30), int8] */;
%468 = power(2f /* ty=float32 */, 23f /* ty=float32 */) /* ty=float32 */;
%469 = divide(1f /* ty=float32 */, %468) /* ty=float32 */;
%470 = multiply(%469, meta[relay.Constant][139] /* ty=Tensor[(32, 1, 1, 1), float32] */) /* ty=Tensor[(32, 1, 1, 1), float32] */;
%471 = maximum(%467, meta[relay.Constant][137] /* ty=int8 */) /* ty=Tensor[(1, 16, 17, 30), int8] */;
%472 = qnn.quantize(meta[relay.Constant][138] /* ty=Tensor[(32, 16, 1, 1), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int8", axis=0) /* ty=Tensor[(32, 16, 1, 1), int8] */;
%473 = squeeze(%470) /* ty=Tensor[(32), float32] */;
%474 = power(2f /* ty=float32 */, 27f /* ty=float32 */) /* ty=float32 */;
%475 = qnn.quantize(meta[relay.Constant][140] /* ty=Tensor[(32), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int32") /* ty=Tensor[(32), int32] */;
%476 = divide(1f /* ty=float32 */, %474) /* ty=float32 */;
%477 = qnn.conv2d(%471, %472, 0 /* ty=int32 */, 0 /* ty=int32 */, %465, %473, padding=[0, 0, 0, 0], channels=32, kernel_size=[1, 1], out_dtype="int32") /* ty=Tensor[(1, 32, 17, 30), int32] */;
%478 = qnn.requantize(%475, %476, 0 /* ty=int32 */, meta[relay.Constant][141] /* ty=Tensor[(32), float32] */, meta[relay.Constant][142] /* ty=Tensor[(32), int32] */, axis=0, out_dtype="int32") /* ty=Tensor[(32), int32] */;
%479 = nn.bias_add(%477, %478) /* ty=Tensor[(1, 32, 17, 30), int32] */;
%480 = power(2f /* ty=float32 */, 4f /* ty=float32 */) /* ty=float32 */;
%481 = qnn.dequantize(%479, meta[relay.Constant][141] /* ty=Tensor[(32), float32] */, meta[relay.Constant][142] /* ty=Tensor[(32), int32] */, axis=1) /* ty=Tensor[(1, 32, 17, 30), float32] */;
%482 = divide(1f /* ty=float32 */, %480) /* ty=float32 */;
%483 = qnn.quantize(%481, %482, 0 /* ty=int32 */, out_dtype="int8") /* ty=Tensor[(1, 32, 17, 30), int8] */;
%484 = clip(%483, a_min=-127f, a_max=127f) /* ty=Tensor[(1, 32, 17, 30), int8] */;
%485 = maximum(%484, meta[relay.Constant][143] /* ty=int8 */) /* ty=Tensor[(1, 32, 17, 30), int8] */;
%486 = power(2f /* ty=float32 */, 23f /* ty=float32 */) /* ty=float32 */;
%487 = divide(1f /* ty=float32 */, %486) /* ty=float32 */;
%488 = multiply(%487, meta[relay.Constant][145] /* ty=Tensor[(32, 1, 1, 1), float32] */) /* ty=Tensor[(32, 1, 1, 1), float32] */;
%489 = qnn.quantize(meta[relay.Constant][144] /* ty=Tensor[(32, 16, 3, 3), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int8", axis=0) /* ty=Tensor[(32, 16, 3, 3), int8] */;
%490 = squeeze(%488) /* ty=Tensor[(32), float32] */;
%491 = power(2f /* ty=float32 */, 27f /* ty=float32 */) /* ty=float32 */;
%492 = qnn.quantize(meta[relay.Constant][146] /* ty=Tensor[(32), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int32") /* ty=Tensor[(32), int32] */;
%493 = divide(1f /* ty=float32 */, %491) /* ty=float32 */;
%494 = qnn.conv2d(%471, %489, 0 /* ty=int32 */, 0 /* ty=int32 */, %465, %490, padding=[1, 1, 1, 1], channels=32, kernel_size=[3, 3], out_dtype="int32") /* ty=Tensor[(1, 32, 17, 30), int32] */;
%495 = qnn.requantize(%492, %493, 0 /* ty=int32 */, meta[relay.Constant][147] /* ty=Tensor[(32), float32] */, meta[relay.Constant][148] /* ty=Tensor[(32), int32] */, axis=0, out_dtype="int32") /* ty=Tensor[(32), int32] */;
%496 = nn.bias_add(%494, %495) /* ty=Tensor[(1, 32, 17, 30), int32] */;
%497 = power(2f /* ty=float32 */, 4f /* ty=float32 */) /* ty=float32 */;
%498 = qnn.dequantize(%496, meta[relay.Constant][147] /* ty=Tensor[(32), float32] */, meta[relay.Constant][148] /* ty=Tensor[(32), int32] */, axis=1) /* ty=Tensor[(1, 32, 17, 30), float32] */;
%499 = divide(1f /* ty=float32 */, %497) /* ty=float32 */;
%500 = qnn.quantize(%498, %499, 0 /* ty=int32 */, out_dtype="int8") /* ty=Tensor[(1, 32, 17, 30), int8] */;
%501 = clip(%500, a_min=-127f, a_max=127f) /* ty=Tensor[(1, 32, 17, 30), int8] */;
%502 = maximum(%501, meta[relay.Constant][149] /* ty=int8 */) /* ty=Tensor[(1, 32, 17, 30), int8] */;
%503 = qnn.dequantize(%485, %482, 0 /* ty=int32 */) /* ty=Tensor[(1, 32, 17, 30), float32] */;
%504 = qnn.dequantize(%502, %499, 0 /* ty=int32 */) /* ty=Tensor[(1, 32, 17, 30), float32] */;
%505 = (%503, %504) /* ty=(Tensor[(1, 32, 17, 30), float32], Tensor[(1, 32, 17, 30), float32]) */;
%506 = power(2f /* ty=float32 */, 4f /* ty=float32 */) /* ty=float32 */;
%507 = concatenate(%505, axis=1) /* ty=Tensor[(1, 64, 17, 30), float32] */;
%508 = divide(1f /* ty=float32 */, %506) /* ty=float32 */;
%509 = qnn.quantize(%507, %508, 0 /* ty=int32 */, out_dtype="int8") /* ty=Tensor[(1, 64, 17, 30), int8] */;
%510 = power(2f /* ty=float32 */, 23f /* ty=float32 */) /* ty=float32 */;
%511 = divide(1f /* ty=float32 */, %510) /* ty=float32 */;
%512 = multiply(%511, meta[relay.Constant][151] /* ty=Tensor[(16, 1, 1, 1), float32] */) /* ty=Tensor[(16, 1, 1, 1), float32] */;
%513 = clip(%509, a_min=-127f, a_max=127f) /* ty=Tensor[(1, 64, 17, 30), int8] */;
%514 = qnn.quantize(meta[relay.Constant][150] /* ty=Tensor[(16, 64, 1, 1), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int8", axis=0) /* ty=Tensor[(16, 64, 1, 1), int8] */;
%515 = squeeze(%512) /* ty=Tensor[(16), float32] */;
%516 = power(2f /* ty=float32 */, 27f /* ty=float32 */) /* ty=float32 */;
%517 = qnn.quantize(meta[relay.Constant][152] /* ty=Tensor[(16), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int32") /* ty=Tensor[(16), int32] */;
%518 = divide(1f /* ty=float32 */, %516) /* ty=float32 */;
%519 = qnn.conv2d(%513, %514, 0 /* ty=int32 */, 0 /* ty=int32 */, %508, %515, padding=[0, 0, 0, 0], channels=16, kernel_size=[1, 1], out_dtype="int32") /* ty=Tensor[(1, 16, 17, 30), int32] */;
%520 = qnn.requantize(%517, %518, 0 /* ty=int32 */, meta[relay.Constant][153] /* ty=Tensor[(16), float32] */, meta[relay.Constant][154] /* ty=Tensor[(16), int32] */, axis=0, out_dtype="int32") /* ty=Tensor[(16), int32] */;
%521 = nn.bias_add(%519, %520) /* ty=Tensor[(1, 16, 17, 30), int32] */;
%522 = power(2f /* ty=float32 */, 4f /* ty=float32 */) /* ty=float32 */;
%523 = qnn.dequantize(%521, meta[relay.Constant][153] /* ty=Tensor[(16), float32] */, meta[relay.Constant][154] /* ty=Tensor[(16), int32] */, axis=1) /* ty=Tensor[(1, 16, 17, 30), float32] */;
%524 = divide(1f /* ty=float32 */, %522) /* ty=float32 */;
%525 = qnn.quantize(%523, %524, 0 /* ty=int32 */, out_dtype="int8") /* ty=Tensor[(1, 16, 17, 30), int8] */;
%526 = clip(%525, a_min=-127f, a_max=127f) /* ty=Tensor[(1, 16, 17, 30), int8] */;
%527 = power(2f /* ty=float32 */, 23f /* ty=float32 */) /* ty=float32 */;
%528 = divide(1f /* ty=float32 */, %527) /* ty=float32 */;
%529 = multiply(%528, meta[relay.Constant][157] /* ty=Tensor[(32, 1, 1, 1), float32] */) /* ty=Tensor[(32, 1, 1, 1), float32] */;
%530 = maximum(%526, meta[relay.Constant][155] /* ty=int8 */) /* ty=Tensor[(1, 16, 17, 30), int8] */;
%531 = qnn.quantize(meta[relay.Constant][156] /* ty=Tensor[(32, 16, 1, 1), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int8", axis=0) /* ty=Tensor[(32, 16, 1, 1), int8] */;
%532 = squeeze(%529) /* ty=Tensor[(32), float32] */;
%533 = power(2f /* ty=float32 */, 27f /* ty=float32 */) /* ty=float32 */;
%534 = qnn.quantize(meta[relay.Constant][158] /* ty=Tensor[(32), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int32") /* ty=Tensor[(32), int32] */;
%535 = divide(1f /* ty=float32 */, %533) /* ty=float32 */;
%536 = qnn.conv2d(%530, %531, 0 /* ty=int32 */, 0 /* ty=int32 */, %524, %532, padding=[0, 0, 0, 0], channels=32, kernel_size=[1, 1], out_dtype="int32") /* ty=Tensor[(1, 32, 17, 30), int32] */;
%537 = qnn.requantize(%534, %535, 0 /* ty=int32 */, meta[relay.Constant][159] /* ty=Tensor[(32), float32] */, meta[relay.Constant][160] /* ty=Tensor[(32), int32] */, axis=0, out_dtype="int32") /* ty=Tensor[(32), int32] */;
%538 = nn.bias_add(%536, %537) /* ty=Tensor[(1, 32, 17, 30), int32] */;
%539 = power(2f /* ty=float32 */, 5f /* ty=float32 */) /* ty=float32 */;
%540 = qnn.dequantize(%538, meta[relay.Constant][159] /* ty=Tensor[(32), float32] */, meta[relay.Constant][160] /* ty=Tensor[(32), int32] */, axis=1) /* ty=Tensor[(1, 32, 17, 30), float32] */;
%541 = divide(1f /* ty=float32 */, %539) /* ty=float32 */;
%542 = qnn.quantize(%540, %541, 0 /* ty=int32 */, out_dtype="int8") /* ty=Tensor[(1, 32, 17, 30), int8] */;
%543 = clip(%542, a_min=-127f, a_max=127f) /* ty=Tensor[(1, 32, 17, 30), int8] */;
%544 = maximum(%543, meta[relay.Constant][161] /* ty=int8 */) /* ty=Tensor[(1, 32, 17, 30), int8] */;
%545 = power(2f /* ty=float32 */, 23f /* ty=float32 */) /* ty=float32 */;
%546 = divide(1f /* ty=float32 */, %545) /* ty=float32 */;
%547 = multiply(%546, meta[relay.Constant][163] /* ty=Tensor[(32, 1, 1, 1), float32] */) /* ty=Tensor[(32, 1, 1, 1), float32] */;
%548 = qnn.quantize(meta[relay.Constant][162] /* ty=Tensor[(32, 16, 3, 3), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int8", axis=0) /* ty=Tensor[(32, 16, 3, 3), int8] */;
%549 = squeeze(%547) /* ty=Tensor[(32), float32] */;
%550 = power(2f /* ty=float32 */, 27f /* ty=float32 */) /* ty=float32 */;
%551 = qnn.quantize(meta[relay.Constant][164] /* ty=Tensor[(32), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int32") /* ty=Tensor[(32), int32] */;
%552 = divide(1f /* ty=float32 */, %550) /* ty=float32 */;
%553 = qnn.conv2d(%530, %548, 0 /* ty=int32 */, 0 /* ty=int32 */, %524, %549, padding=[1, 1, 1, 1], channels=32, kernel_size=[3, 3], out_dtype="int32") /* ty=Tensor[(1, 32, 17, 30), int32] */;
%554 = qnn.requantize(%551, %552, 0 /* ty=int32 */, meta[relay.Constant][165] /* ty=Tensor[(32), float32] */, meta[relay.Constant][166] /* ty=Tensor[(32), int32] */, axis=0, out_dtype="int32") /* ty=Tensor[(32), int32] */;
%555 = nn.bias_add(%553, %554) /* ty=Tensor[(1, 32, 17, 30), int32] */;
%556 = power(2f /* ty=float32 */, 4f /* ty=float32 */) /* ty=float32 */;
%557 = qnn.dequantize(%555, meta[relay.Constant][165] /* ty=Tensor[(32), float32] */, meta[relay.Constant][166] /* ty=Tensor[(32), int32] */, axis=1) /* ty=Tensor[(1, 32, 17, 30), float32] */;
%558 = divide(1f /* ty=float32 */, %556) /* ty=float32 */;
%559 = qnn.quantize(%557, %558, 0 /* ty=int32 */, out_dtype="int8") /* ty=Tensor[(1, 32, 17, 30), int8] */;
%560 = clip(%559, a_min=-127f, a_max=127f) /* ty=Tensor[(1, 32, 17, 30), int8] */;
%561 = maximum(%560, meta[relay.Constant][167] /* ty=int8 */) /* ty=Tensor[(1, 32, 17, 30), int8] */;
%562 = qnn.dequantize(%544, %541, 0 /* ty=int32 */) /* ty=Tensor[(1, 32, 17, 30), float32] */;
%563 = qnn.dequantize(%561, %558, 0 /* ty=int32 */) /* ty=Tensor[(1, 32, 17, 30), float32] */;
%564 = (%562, %563) /* ty=(Tensor[(1, 32, 17, 30), float32], Tensor[(1, 32, 17, 30), float32]) */;
%565 = power(2f /* ty=float32 */, 4f /* ty=float32 */) /* ty=float32 */;
%566 = concatenate(%564, axis=1) /* ty=Tensor[(1, 64, 17, 30), float32] */;
%567 = divide(1f /* ty=float32 */, %565) /* ty=float32 */;
%568 = qnn.quantize(%566, %567, 0 /* ty=int32 */, out_dtype="int8") /* ty=Tensor[(1, 64, 17, 30), int8] */;
%569 = power(2f /* ty=float32 */, 23f /* ty=float32 */) /* ty=float32 */;
%570 = divide(1f /* ty=float32 */, %569) /* ty=float32 */;
%571 = multiply(%570, meta[relay.Constant][169] /* ty=Tensor[(16, 1, 1, 1), float32] */) /* ty=Tensor[(16, 1, 1, 1), float32] */;
%572 = clip(%568, a_min=-127f, a_max=127f) /* ty=Tensor[(1, 64, 17, 30), int8] */;
%573 = qnn.quantize(meta[relay.Constant][168] /* ty=Tensor[(16, 64, 1, 1), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int8", axis=0) /* ty=Tensor[(16, 64, 1, 1), int8] */;
%574 = squeeze(%571) /* ty=Tensor[(16), float32] */;
%575 = power(2f /* ty=float32 */, 27f /* ty=float32 */) /* ty=float32 */;
%576 = qnn.quantize(meta[relay.Constant][170] /* ty=Tensor[(16), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int32") /* ty=Tensor[(16), int32] */;
%577 = divide(1f /* ty=float32 */, %575) /* ty=float32 */;
%578 = qnn.conv2d(%572, %573, 0 /* ty=int32 */, 0 /* ty=int32 */, %567, %574, padding=[0, 0, 0, 0], channels=16, kernel_size=[1, 1], out_dtype="int32") /* ty=Tensor[(1, 16, 17, 30), int32] */;
%579 = qnn.requantize(%576, %577, 0 /* ty=int32 */, meta[relay.Constant][171] /* ty=Tensor[(16), float32] */, meta[relay.Constant][172] /* ty=Tensor[(16), int32] */, axis=0, out_dtype="int32") /* ty=Tensor[(16), int32] */;
%580 = nn.bias_add(%578, %579) /* ty=Tensor[(1, 16, 17, 30), int32] */;
%581 = power(2f /* ty=float32 */, 4f /* ty=float32 */) /* ty=float32 */;
%582 = qnn.dequantize(%580, meta[relay.Constant][171] /* ty=Tensor[(16), float32] */, meta[relay.Constant][172] /* ty=Tensor[(16), int32] */, axis=1) /* ty=Tensor[(1, 16, 17, 30), float32] */;
%583 = divide(1f /* ty=float32 */, %581) /* ty=float32 */;
%584 = qnn.quantize(%582, %583, 0 /* ty=int32 */, out_dtype="int8") /* ty=Tensor[(1, 16, 17, 30), int8] */;
%585 = clip(%584, a_min=-127f, a_max=127f) /* ty=Tensor[(1, 16, 17, 30), int8] */;
%586 = power(2f /* ty=float32 */, 22f /* ty=float32 */) /* ty=float32 */;
%587 = divide(1f /* ty=float32 */, %586) /* ty=float32 */;
%588 = multiply(%587, meta[relay.Constant][175] /* ty=Tensor[(32, 1, 1, 1), float32] */) /* ty=Tensor[(32, 1, 1, 1), float32] */;
%589 = maximum(%585, meta[relay.Constant][173] /* ty=int8 */) /* ty=Tensor[(1, 16, 17, 30), int8] */;
%590 = qnn.quantize(meta[relay.Constant][174] /* ty=Tensor[(32, 16, 1, 1), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int8", axis=0) /* ty=Tensor[(32, 16, 1, 1), int8] */;
%591 = squeeze(%588) /* ty=Tensor[(32), float32] */;
%592 = power(2f /* ty=float32 */, 26f /* ty=float32 */) /* ty=float32 */;
%593 = qnn.quantize(meta[relay.Constant][176] /* ty=Tensor[(32), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int32") /* ty=Tensor[(32), int32] */;
%594 = divide(1f /* ty=float32 */, %592) /* ty=float32 */;
%595 = qnn.conv2d(%589, %590, 0 /* ty=int32 */, 0 /* ty=int32 */, %583, %591, padding=[0, 0, 0, 0], channels=32, kernel_size=[1, 1], out_dtype="int32") /* ty=Tensor[(1, 32, 17, 30), int32] */;
%596 = qnn.requantize(%593, %594, 0 /* ty=int32 */, meta[relay.Constant][177] /* ty=Tensor[(32), float32] */, meta[relay.Constant][178] /* ty=Tensor[(32), int32] */, axis=0, out_dtype="int32") /* ty=Tensor[(32), int32] */;
%597 = nn.bias_add(%595, %596) /* ty=Tensor[(1, 32, 17, 30), int32] */;
%598 = power(2f /* ty=float32 */, 6f /* ty=float32 */) /* ty=float32 */;
%599 = qnn.dequantize(%597, meta[relay.Constant][177] /* ty=Tensor[(32), float32] */, meta[relay.Constant][178] /* ty=Tensor[(32), int32] */, axis=1) /* ty=Tensor[(1, 32, 17, 30), float32] */;
%600 = divide(1f /* ty=float32 */, %598) /* ty=float32 */;
%601 = qnn.quantize(%599, %600, 0 /* ty=int32 */, out_dtype="int8") /* ty=Tensor[(1, 32, 17, 30), int8] */;
%602 = clip(%601, a_min=-127f, a_max=127f) /* ty=Tensor[(1, 32, 17, 30), int8] */;
%603 = maximum(%602, meta[relay.Constant][179] /* ty=int8 */) /* ty=Tensor[(1, 32, 17, 30), int8] */;
%604 = power(2f /* ty=float32 */, 23f /* ty=float32 */) /* ty=float32 */;
%605 = divide(1f /* ty=float32 */, %604) /* ty=float32 */;
%606 = multiply(%605, meta[relay.Constant][181] /* ty=Tensor[(32, 1, 1, 1), float32] */) /* ty=Tensor[(32, 1, 1, 1), float32] */;
%607 = qnn.quantize(meta[relay.Constant][180] /* ty=Tensor[(32, 16, 3, 3), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int8", axis=0) /* ty=Tensor[(32, 16, 3, 3), int8] */;
%608 = squeeze(%606) /* ty=Tensor[(32), float32] */;
%609 = power(2f /* ty=float32 */, 27f /* ty=float32 */) /* ty=float32 */;
%610 = qnn.quantize(meta[relay.Constant][182] /* ty=Tensor[(32), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int32") /* ty=Tensor[(32), int32] */;
%611 = divide(1f /* ty=float32 */, %609) /* ty=float32 */;
%612 = qnn.conv2d(%589, %607, 0 /* ty=int32 */, 0 /* ty=int32 */, %583, %608, padding=[1, 1, 1, 1], channels=32, kernel_size=[3, 3], out_dtype="int32") /* ty=Tensor[(1, 32, 17, 30), int32] */;
%613 = qnn.requantize(%610, %611, 0 /* ty=int32 */, meta[relay.Constant][183] /* ty=Tensor[(32), float32] */, meta[relay.Constant][184] /* ty=Tensor[(32), int32] */, axis=0, out_dtype="int32") /* ty=Tensor[(32), int32] */;
%614 = nn.bias_add(%612, %613) /* ty=Tensor[(1, 32, 17, 30), int32] */;
%615 = power(2f /* ty=float32 */, 5f /* ty=float32 */) /* ty=float32 */;
%616 = qnn.dequantize(%614, meta[relay.Constant][183] /* ty=Tensor[(32), float32] */, meta[relay.Constant][184] /* ty=Tensor[(32), int32] */, axis=1) /* ty=Tensor[(1, 32, 17, 30), float32] */;
%617 = divide(1f /* ty=float32 */, %615) /* ty=float32 */;
%618 = qnn.quantize(%616, %617, 0 /* ty=int32 */, out_dtype="int8") /* ty=Tensor[(1, 32, 17, 30), int8] */;
%619 = clip(%618, a_min=-127f, a_max=127f) /* ty=Tensor[(1, 32, 17, 30), int8] */;
%620 = maximum(%619, meta[relay.Constant][185] /* ty=int8 */) /* ty=Tensor[(1, 32, 17, 30), int8] */;
%621 = qnn.dequantize(%603, %600, 0 /* ty=int32 */) /* ty=Tensor[(1, 32, 17, 30), float32] */;
%622 = qnn.dequantize(%620, %617, 0 /* ty=int32 */) /* ty=Tensor[(1, 32, 17, 30), float32] */;
%623 = (%621, %622) /* ty=(Tensor[(1, 32, 17, 30), float32], Tensor[(1, 32, 17, 30), float32]) */;
%624 = power(2f /* ty=float32 */, 6f /* ty=float32 */) /* ty=float32 */;
%625 = concatenate(%623, axis=1) /* ty=Tensor[(1, 64, 17, 30), float32] */;
%626 = divide(1f /* ty=float32 */, %624) /* ty=float32 */;
%627 = qnn.quantize(%625, %626, 0 /* ty=int32 */, out_dtype="int8") /* ty=Tensor[(1, 64, 17, 30), int8] */;
%628 = power(2f /* ty=float32 */, 21f /* ty=float32 */) /* ty=float32 */;
%629 = divide(1f /* ty=float32 */, %628) /* ty=float32 */;
%630 = multiply(%629, meta[relay.Constant][187] /* ty=Tensor[(64, 1, 1, 1), float32] */) /* ty=Tensor[(64, 1, 1, 1), float32] */;
%631 = clip(%627, a_min=-127f, a_max=127f) /* ty=Tensor[(1, 64, 17, 30), int8] */;
%632 = qnn.quantize(meta[relay.Constant][186] /* ty=Tensor[(64, 64, 4, 4), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int8", axis=0) /* ty=Tensor[(64, 64, 4, 4), int8] */;
%633 = squeeze(%630) /* ty=Tensor[(64), float32] */;
%634 = power(2f /* ty=float32 */, 27f /* ty=float32 */) /* ty=float32 */;
%635 = qnn.quantize(meta[relay.Constant][188] /* ty=Tensor[(64), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int32") /* ty=Tensor[(64), int32] */;
%636 = divide(1f /* ty=float32 */, %634) /* ty=float32 */;
%637 = qnn.conv2d_transpose(%631, %632, 0 /* ty=int32 */, 0 /* ty=int32 */, %626, %633, channels=64, kernel_size=[4, 4], strides=[2, 2], padding=[1, 1, 1, 1], kernel_layout="IOHW", out_dtype="int32") /* ty=Tensor[(1, 64, 34, 60), int32] */;
%638 = qnn.requantize(%635, %636, 0 /* ty=int32 */, meta[relay.Constant][189] /* ty=Tensor[(64), float32] */, meta[relay.Constant][190] /* ty=Tensor[(64), int32] */, axis=0, out_dtype="int32") /* ty=Tensor[(64), int32] */;
%639 = nn.bias_add(%637, %638) /* ty=Tensor[(1, 64, 34, 60), int32] */;
%640 = power(2f /* ty=float32 */, 3f /* ty=float32 */) /* ty=float32 */;
%641 = qnn.dequantize(%639, meta[relay.Constant][189] /* ty=Tensor[(64), float32] */, meta[relay.Constant][190] /* ty=Tensor[(64), int32] */, axis=1) /* ty=Tensor[(1, 64, 34, 60), float32] */;
%642 = divide(1f /* ty=float32 */, %640) /* ty=float32 */;
%643 = qnn.quantize(%641, %642, 0 /* ty=int32 */, out_dtype="int8") /* ty=Tensor[(1, 64, 34, 60), int8] */;
%644 = clip(%643, a_min=-127f, a_max=127f) /* ty=Tensor[(1, 64, 34, 60), int8] */;
%645 = qnn.dequantize(%644, %642, 0 /* ty=int32 */) /* ty=Tensor[(1, 64, 34, 60), float32] */;
%646 = (%645, %388) /* ty=(Tensor[(1, 64, 34, 60), float32], Tensor[(1, 64, 34, 60), float32]) */;
%647 = power(2f /* ty=float32 */, 3f /* ty=float32 */) /* ty=float32 */;
%648 = concatenate(%646, axis=1) /* ty=Tensor[(1, 128, 34, 60), float32] */;
%649 = divide(1f /* ty=float32 */, %647) /* ty=float32 */;
%650 = qnn.quantize(%648, %649, 0 /* ty=int32 */, out_dtype="int8") /* ty=Tensor[(1, 128, 34, 60), int8] */;
%651 = power(2f /* ty=float32 */, 24f /* ty=float32 */) /* ty=float32 */;
%652 = divide(1f /* ty=float32 */, %651) /* ty=float32 */;
%653 = multiply(%652, meta[relay.Constant][192] /* ty=Tensor[(32, 1, 1, 1), float32] */) /* ty=Tensor[(32, 1, 1, 1), float32] */;
%654 = clip(%650, a_min=-127f, a_max=127f) /* ty=Tensor[(1, 128, 34, 60), int8] */;
%655 = qnn.quantize(meta[relay.Constant][191] /* ty=Tensor[(32, 128, 1, 1), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int8", axis=0) /* ty=Tensor[(32, 128, 1, 1), int8] */;
%656 = squeeze(%653) /* ty=Tensor[(32), float32] */;
%657 = power(2f /* ty=float32 */, 27f /* ty=float32 */) /* ty=float32 */;
%658 = qnn.quantize(meta[relay.Constant][193] /* ty=Tensor[(32), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int32") /* ty=Tensor[(32), int32] */;
%659 = divide(1f /* ty=float32 */, %657) /* ty=float32 */;
%660 = qnn.conv2d(%654, %655, 0 /* ty=int32 */, 0 /* ty=int32 */, %649, %656, padding=[0, 0, 0, 0], channels=32, kernel_size=[1, 1], out_dtype="int32") /* ty=Tensor[(1, 32, 34, 60), int32] */;
%661 = qnn.requantize(%658, %659, 0 /* ty=int32 */, meta[relay.Constant][194] /* ty=Tensor[(32), float32] */, meta[relay.Constant][195] /* ty=Tensor[(32), int32] */, axis=0, out_dtype="int32") /* ty=Tensor[(32), int32] */;
%662 = nn.bias_add(%660, %661) /* ty=Tensor[(1, 32, 34, 60), int32] */;
%663 = power(2f /* ty=float32 */, 5f /* ty=float32 */) /* ty=float32 */;
%664 = qnn.dequantize(%662, meta[relay.Constant][194] /* ty=Tensor[(32), float32] */, meta[relay.Constant][195] /* ty=Tensor[(32), int32] */, axis=1) /* ty=Tensor[(1, 32, 34, 60), float32] */;
%665 = divide(1f /* ty=float32 */, %663) /* ty=float32 */;
%666 = qnn.quantize(%664, %665, 0 /* ty=int32 */, out_dtype="int8") /* ty=Tensor[(1, 32, 34, 60), int8] */;
%667 = clip(%666, a_min=-127f, a_max=127f) /* ty=Tensor[(1, 32, 34, 60), int8] */;
%668 = power(2f /* ty=float32 */, 23f /* ty=float32 */) /* ty=float32 */;
%669 = divide(1f /* ty=float32 */, %668) /* ty=float32 */;
%670 = multiply(%669, meta[relay.Constant][198] /* ty=Tensor[(32, 1, 1, 1), float32] */) /* ty=Tensor[(32, 1, 1, 1), float32] */;
%671 = maximum(%667, meta[relay.Constant][196] /* ty=int8 */) /* ty=Tensor[(1, 32, 34, 60), int8] */;
%672 = qnn.quantize(meta[relay.Constant][197] /* ty=Tensor[(32, 32, 3, 3), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int8", axis=0) /* ty=Tensor[(32, 32, 3, 3), int8] */;
%673 = squeeze(%670) /* ty=Tensor[(32), float32] */;
%674 = power(2f /* ty=float32 */, 28f /* ty=float32 */) /* ty=float32 */;
%675 = qnn.quantize(meta[relay.Constant][199] /* ty=Tensor[(32), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int32") /* ty=Tensor[(32), int32] */;
%676 = divide(1f /* ty=float32 */, %674) /* ty=float32 */;
%677 = qnn.conv2d(%671, %672, 0 /* ty=int32 */, 0 /* ty=int32 */, %665, %673, padding=[1, 1, 1, 1], channels=32, kernel_size=[3, 3], out_dtype="int32") /* ty=Tensor[(1, 32, 34, 60), int32] */;
%678 = qnn.requantize(%675, %676, 0 /* ty=int32 */, meta[relay.Constant][200] /* ty=Tensor[(32), float32] */, meta[relay.Constant][201] /* ty=Tensor[(32), int32] */, axis=0, out_dtype="int32") /* ty=Tensor[(32), int32] */;
%679 = nn.bias_add(%677, %678) /* ty=Tensor[(1, 32, 34, 60), int32] */;
%680 = power(2f /* ty=float32 */, 4f /* ty=float32 */) /* ty=float32 */;
%681 = qnn.dequantize(%679, meta[relay.Constant][200] /* ty=Tensor[(32), float32] */, meta[relay.Constant][201] /* ty=Tensor[(32), int32] */, axis=1) /* ty=Tensor[(1, 32, 34, 60), float32] */;
%682 = divide(1f /* ty=float32 */, %680) /* ty=float32 */;
%683 = qnn.quantize(%681, %682, 0 /* ty=int32 */, out_dtype="int8") /* ty=Tensor[(1, 32, 34, 60), int8] */;
%684 = clip(%683, a_min=-127f, a_max=127f) /* ty=Tensor[(1, 32, 34, 60), int8] */;
%685 = power(2f /* ty=float32 */, 21f /* ty=float32 */) /* ty=float32 */;
%686 = divide(1f /* ty=float32 */, %685) /* ty=float32 */;
%687 = multiply(%686, meta[relay.Constant][204] /* ty=Tensor[(32, 1, 1, 1), float32] */) /* ty=Tensor[(32, 1, 1, 1), float32] */;
%688 = maximum(%684, meta[relay.Constant][202] /* ty=int8 */) /* ty=Tensor[(1, 32, 34, 60), int8] */;
%689 = qnn.quantize(meta[relay.Constant][203] /* ty=Tensor[(32, 32, 4, 4), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int8", axis=0) /* ty=Tensor[(32, 32, 4, 4), int8] */;
%690 = squeeze(%687) /* ty=Tensor[(32), float32] */;
%691 = power(2f /* ty=float32 */, 25f /* ty=float32 */) /* ty=float32 */;
%692 = qnn.quantize(meta[relay.Constant][205] /* ty=Tensor[(32), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int32") /* ty=Tensor[(32), int32] */;
%693 = divide(1f /* ty=float32 */, %691) /* ty=float32 */;
%694 = qnn.conv2d_transpose(%688, %689, 0 /* ty=int32 */, 0 /* ty=int32 */, %682, %690, channels=32, kernel_size=[4, 4], strides=[2, 2], padding=[1, 1, 1, 1], kernel_layout="IOHW", out_dtype="int32") /* ty=Tensor[(1, 32, 68, 120), int32] */;
%695 = qnn.requantize(%692, %693, 0 /* ty=int32 */, meta[relay.Constant][206] /* ty=Tensor[(32), float32] */, meta[relay.Constant][207] /* ty=Tensor[(32), int32] */, axis=0, out_dtype="int32") /* ty=Tensor[(32), int32] */;
%696 = nn.bias_add(%694, %695) /* ty=Tensor[(1, 32, 68, 120), int32] */;
%697 = power(2f /* ty=float32 */, 1f /* ty=float32 */) /* ty=float32 */;
%698 = qnn.dequantize(%696, meta[relay.Constant][206] /* ty=Tensor[(32), float32] */, meta[relay.Constant][207] /* ty=Tensor[(32), int32] */, axis=1) /* ty=Tensor[(1, 32, 68, 120), float32] */;
%699 = divide(1f /* ty=float32 */, %697) /* ty=float32 */;
%700 = qnn.quantize(%698, %699, 0 /* ty=int32 */, out_dtype="int8") /* ty=Tensor[(1, 32, 68, 120), int8] */;
%701 = clip(%700, a_min=-127f, a_max=127f) /* ty=Tensor[(1, 32, 68, 120), int8] */;
%702 = qnn.dequantize(%701, %699, 0 /* ty=int32 */) /* ty=Tensor[(1, 32, 68, 120), float32] */;
%703 = (%702, %264) /* ty=(Tensor[(1, 32, 68, 120), float32], Tensor[(1, 32, 68, 120), float32]) */;
%704 = power(2f /* ty=float32 */, 1f /* ty=float32 */) /* ty=float32 */;
%705 = concatenate(%703, axis=1) /* ty=Tensor[(1, 64, 68, 120), float32] */;
%706 = divide(1f /* ty=float32 */, %704) /* ty=float32 */;
%707 = qnn.quantize(%705, %706, 0 /* ty=int32 */, out_dtype="int8") /* ty=Tensor[(1, 64, 68, 120), int8] */;
%708 = power(2f /* ty=float32 */, 24f /* ty=float32 */) /* ty=float32 */;
%709 = divide(1f /* ty=float32 */, %708) /* ty=float32 */;
%710 = multiply(%709, meta[relay.Constant][209] /* ty=Tensor[(16, 1, 1, 1), float32] */) /* ty=Tensor[(16, 1, 1, 1), float32] */;
%711 = clip(%707, a_min=-127f, a_max=127f) /* ty=Tensor[(1, 64, 68, 120), int8] */;
%712 = qnn.quantize(meta[relay.Constant][208] /* ty=Tensor[(16, 64, 1, 1), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int8", axis=0) /* ty=Tensor[(16, 64, 1, 1), int8] */;
%713 = squeeze(%710) /* ty=Tensor[(16), float32] */;
%714 = power(2f /* ty=float32 */, 25f /* ty=float32 */) /* ty=float32 */;
%715 = qnn.quantize(meta[relay.Constant][210] /* ty=Tensor[(16), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int32") /* ty=Tensor[(16), int32] */;
%716 = divide(1f /* ty=float32 */, %714) /* ty=float32 */;
%717 = qnn.conv2d(%711, %712, 0 /* ty=int32 */, 0 /* ty=int32 */, %706, %713, padding=[0, 0, 0, 0], channels=16, kernel_size=[1, 1], out_dtype="int32") /* ty=Tensor[(1, 16, 68, 120), int32] */;
%718 = qnn.requantize(%715, %716, 0 /* ty=int32 */, meta[relay.Constant][211] /* ty=Tensor[(16), float32] */, meta[relay.Constant][212] /* ty=Tensor[(16), int32] */, axis=0, out_dtype="int32") /* ty=Tensor[(16), int32] */;
%719 = nn.bias_add(%717, %718) /* ty=Tensor[(1, 16, 68, 120), int32] */;
%720 = power(2f /* ty=float32 */, 4f /* ty=float32 */) /* ty=float32 */;
%721 = qnn.dequantize(%719, meta[relay.Constant][211] /* ty=Tensor[(16), float32] */, meta[relay.Constant][212] /* ty=Tensor[(16), int32] */, axis=1) /* ty=Tensor[(1, 16, 68, 120), float32] */;
%722 = divide(1f /* ty=float32 */, %720) /* ty=float32 */;
%723 = qnn.quantize(%721, %722, 0 /* ty=int32 */, out_dtype="int8") /* ty=Tensor[(1, 16, 68, 120), int8] */;
%724 = clip(%723, a_min=-127f, a_max=127f) /* ty=Tensor[(1, 16, 68, 120), int8] */;
%725 = power(2f /* ty=float32 */, 23f /* ty=float32 */) /* ty=float32 */;
%726 = divide(1f /* ty=float32 */, %725) /* ty=float32 */;
%727 = multiply(%726, meta[relay.Constant][215] /* ty=Tensor[(16, 1, 1, 1), float32] */) /* ty=Tensor[(16, 1, 1, 1), float32] */;
%728 = maximum(%724, meta[relay.Constant][213] /* ty=int8 */) /* ty=Tensor[(1, 16, 68, 120), int8] */;
%729 = qnn.quantize(meta[relay.Constant][214] /* ty=Tensor[(16, 16, 3, 3), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int8", axis=0) /* ty=Tensor[(16, 16, 3, 3), int8] */;
%730 = squeeze(%727) /* ty=Tensor[(16), float32] */;
%731 = power(2f /* ty=float32 */, 27f /* ty=float32 */) /* ty=float32 */;
%732 = qnn.quantize(meta[relay.Constant][216] /* ty=Tensor[(16), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int32") /* ty=Tensor[(16), int32] */;
%733 = divide(1f /* ty=float32 */, %731) /* ty=float32 */;
%734 = qnn.conv2d(%728, %729, 0 /* ty=int32 */, 0 /* ty=int32 */, %722, %730, padding=[1, 1, 1, 1], channels=16, kernel_size=[3, 3], out_dtype="int32") /* ty=Tensor[(1, 16, 68, 120), int32] */;
%735 = qnn.requantize(%732, %733, 0 /* ty=int32 */, meta[relay.Constant][217] /* ty=Tensor[(16), float32] */, meta[relay.Constant][218] /* ty=Tensor[(16), int32] */, axis=0, out_dtype="int32") /* ty=Tensor[(16), int32] */;
%736 = nn.bias_add(%734, %735) /* ty=Tensor[(1, 16, 68, 120), int32] */;
%737 = power(2f /* ty=float32 */, 4f /* ty=float32 */) /* ty=float32 */;
%738 = qnn.dequantize(%736, meta[relay.Constant][217] /* ty=Tensor[(16), float32] */, meta[relay.Constant][218] /* ty=Tensor[(16), int32] */, axis=1) /* ty=Tensor[(1, 16, 68, 120), float32] */;
%739 = divide(1f /* ty=float32 */, %737) /* ty=float32 */;
%740 = qnn.quantize(%738, %739, 0 /* ty=int32 */, out_dtype="int8") /* ty=Tensor[(1, 16, 68, 120), int8] */;
%741 = clip(%740, a_min=-127f, a_max=127f) /* ty=Tensor[(1, 16, 68, 120), int8] */;
%742 = power(2f /* ty=float32 */, 21f /* ty=float32 */) /* ty=float32 */;
%743 = divide(1f /* ty=float32 */, %742) /* ty=float32 */;
%744 = multiply(%743, meta[relay.Constant][221] /* ty=Tensor[(16, 1, 1, 1), float32] */) /* ty=Tensor[(16, 1, 1, 1), float32] */;
%745 = maximum(%741, meta[relay.Constant][219] /* ty=int8 */) /* ty=Tensor[(1, 16, 68, 120), int8] */;
%746 = qnn.quantize(meta[relay.Constant][220] /* ty=Tensor[(16, 16, 4, 4), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int8", axis=0) /* ty=Tensor[(16, 16, 4, 4), int8] */;
%747 = squeeze(%744) /* ty=Tensor[(16), float32] */;
%748 = power(2f /* ty=float32 */, 25f /* ty=float32 */) /* ty=float32 */;
%749 = qnn.quantize(meta[relay.Constant][222] /* ty=Tensor[(16), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int32") /* ty=Tensor[(16), int32] */;
%750 = divide(1f /* ty=float32 */, %748) /* ty=float32 */;
%751 = qnn.conv2d_transpose(%745, %746, 0 /* ty=int32 */, 0 /* ty=int32 */, %739, %747, channels=16, kernel_size=[4, 4], strides=[2, 2], padding=[1, 1, 1, 1], kernel_layout="IOHW", out_dtype="int32") /* ty=Tensor[(1, 16, 136, 240), int32] */;
%752 = qnn.requantize(%749, %750, 0 /* ty=int32 */, meta[relay.Constant][223] /* ty=Tensor[(16), float32] */, meta[relay.Constant][224] /* ty=Tensor[(16), int32] */, axis=0, out_dtype="int32") /* ty=Tensor[(16), int32] */;
%753 = nn.bias_add(%751, %752) /* ty=Tensor[(1, 16, 136, 240), int32] */;
%754 = power(2f /* ty=float32 */, 1f /* ty=float32 */) /* ty=float32 */;
%755 = qnn.dequantize(%753, meta[relay.Constant][223] /* ty=Tensor[(16), float32] */, meta[relay.Constant][224] /* ty=Tensor[(16), int32] */, axis=1) /* ty=Tensor[(1, 16, 136, 240), float32] */;
%756 = divide(1f /* ty=float32 */, %754) /* ty=float32 */;
%757 = qnn.quantize(%755, %756, 0 /* ty=int32 */, out_dtype="int8") /* ty=Tensor[(1, 16, 136, 240), int8] */;
%758 = clip(%757, a_min=-127f, a_max=127f) /* ty=Tensor[(1, 16, 136, 240), int8] */;
%759 = qnn.dequantize(%758, %756, 0 /* ty=int32 */) /* ty=Tensor[(1, 16, 136, 240), float32] */;
%760 = (%759, %140) /* ty=(Tensor[(1, 16, 136, 240), float32], Tensor[(1, 64, 136, 240), float32]) */;
%761 = power(2f /* ty=float32 */, 1f /* ty=float32 */) /* ty=float32 */;
%762 = concatenate(%760, axis=1) /* ty=Tensor[(1, 80, 136, 240), float32] */;
%763 = divide(1f /* ty=float32 */, %761) /* ty=float32 */;
%764 = qnn.quantize(%762, %763, 0 /* ty=int32 */, out_dtype="int8") /* ty=Tensor[(1, 80, 136, 240), int8] */;
%765 = power(2f /* ty=float32 */, 24f /* ty=float32 */) /* ty=float32 */;
%766 = divide(1f /* ty=float32 */, %765) /* ty=float32 */;
%767 = multiply(%766, meta[relay.Constant][226] /* ty=Tensor[(32, 1, 1, 1), float32] */) /* ty=Tensor[(32, 1, 1, 1), float32] */;
%768 = clip(%764, a_min=-127f, a_max=127f) /* ty=Tensor[(1, 80, 136, 240), int8] */;
%769 = qnn.quantize(meta[relay.Constant][225] /* ty=Tensor[(32, 80, 1, 1), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int8", axis=0) /* ty=Tensor[(32, 80, 1, 1), int8] */;
%770 = squeeze(%767) /* ty=Tensor[(32), float32] */;
%771 = power(2f /* ty=float32 */, 25f /* ty=float32 */) /* ty=float32 */;
%772 = qnn.quantize(meta[relay.Constant][227] /* ty=Tensor[(32), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int32") /* ty=Tensor[(32), int32] */;
%773 = divide(1f /* ty=float32 */, %771) /* ty=float32 */;
%774 = qnn.conv2d(%768, %769, 0 /* ty=int32 */, 0 /* ty=int32 */, %763, %770, padding=[0, 0, 0, 0], channels=32, kernel_size=[1, 1], out_dtype="int32") /* ty=Tensor[(1, 32, 136, 240), int32] */;
%775 = qnn.requantize(%772, %773, 0 /* ty=int32 */, meta[relay.Constant][228] /* ty=Tensor[(32), float32] */, meta[relay.Constant][229] /* ty=Tensor[(32), int32] */, axis=0, out_dtype="int32") /* ty=Tensor[(32), int32] */;
%776 = nn.bias_add(%774, %775) /* ty=Tensor[(1, 32, 136, 240), int32] */;
%777 = power(2f /* ty=float32 */, 4f /* ty=float32 */) /* ty=float32 */;
%778 = qnn.dequantize(%776, meta[relay.Constant][228] /* ty=Tensor[(32), float32] */, meta[relay.Constant][229] /* ty=Tensor[(32), int32] */, axis=1) /* ty=Tensor[(1, 32, 136, 240), float32] */;
%779 = divide(1f /* ty=float32 */, %777) /* ty=float32 */;
%780 = qnn.quantize(%778, %779, 0 /* ty=int32 */, out_dtype="int8") /* ty=Tensor[(1, 32, 136, 240), int8] */;
%781 = clip(%780, a_min=-127f, a_max=127f) /* ty=Tensor[(1, 32, 136, 240), int8] */;
%782 = power(2f /* ty=float32 */, 23f /* ty=float32 */) /* ty=float32 */;
%783 = divide(1f /* ty=float32 */, %782) /* ty=float32 */;
%784 = multiply(%783, meta[relay.Constant][232] /* ty=Tensor[(32, 1, 1, 1), float32] */) /* ty=Tensor[(32, 1, 1, 1), float32] */;
%785 = maximum(%781, meta[relay.Constant][230] /* ty=int8 */) /* ty=Tensor[(1, 32, 136, 240), int8] */;
%786 = qnn.quantize(meta[relay.Constant][231] /* ty=Tensor[(32, 32, 3, 3), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int8", axis=0) /* ty=Tensor[(32, 32, 3, 3), int8] */;
%787 = squeeze(%784) /* ty=Tensor[(32), float32] */;
%788 = power(2f /* ty=float32 */, 27f /* ty=float32 */) /* ty=float32 */;
%789 = qnn.quantize(meta[relay.Constant][233] /* ty=Tensor[(32), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int32") /* ty=Tensor[(32), int32] */;
%790 = divide(1f /* ty=float32 */, %788) /* ty=float32 */;
%791 = qnn.conv2d(%785, %786, 0 /* ty=int32 */, 0 /* ty=int32 */, %779, %787, padding=[1, 1, 1, 1], channels=32, kernel_size=[3, 3], out_dtype="int32") /* ty=Tensor[(1, 32, 136, 240), int32] */;
%792 = qnn.requantize(%789, %790, 0 /* ty=int32 */, meta[relay.Constant][234] /* ty=Tensor[(32), float32] */, meta[relay.Constant][235] /* ty=Tensor[(32), int32] */, axis=0, out_dtype="int32") /* ty=Tensor[(32), int32] */;
%793 = nn.bias_add(%791, %792) /* ty=Tensor[(1, 32, 136, 240), int32] */;
%794 = power(2f /* ty=float32 */, 4f /* ty=float32 */) /* ty=float32 */;
%795 = qnn.dequantize(%793, meta[relay.Constant][234] /* ty=Tensor[(32), float32] */, meta[relay.Constant][235] /* ty=Tensor[(32), int32] */, axis=1) /* ty=Tensor[(1, 32, 136, 240), float32] */;
%796 = divide(1f /* ty=float32 */, %794) /* ty=float32 */;
%797 = qnn.quantize(%795, %796, 0 /* ty=int32 */, out_dtype="int8") /* ty=Tensor[(1, 32, 136, 240), int8] */;
%798 = clip(%797, a_min=-127f, a_max=127f) /* ty=Tensor[(1, 32, 136, 240), int8] */;
%799 = power(2f /* ty=float32 */, 24f /* ty=float32 */) /* ty=float32 */;
%800 = divide(1f /* ty=float32 */, %799) /* ty=float32 */;
%801 = multiply(%800, meta[relay.Constant][238] /* ty=Tensor[(32, 1, 1, 1), float32] */) /* ty=Tensor[(32, 1, 1, 1), float32] */;
%802 = maximum(%798, meta[relay.Constant][236] /* ty=int8 */) /* ty=Tensor[(1, 32, 136, 240), int8] */;
%803 = qnn.quantize(meta[relay.Constant][237] /* ty=Tensor[(32, 32, 3, 3), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int8", axis=0) /* ty=Tensor[(32, 32, 3, 3), int8] */;
%804 = squeeze(%801) /* ty=Tensor[(32), float32] */;
%805 = power(2f /* ty=float32 */, 28f /* ty=float32 */) /* ty=float32 */;
%806 = qnn.quantize(meta[relay.Constant][239] /* ty=Tensor[(32), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int32") /* ty=Tensor[(32), int32] */;
%807 = divide(1f /* ty=float32 */, %805) /* ty=float32 */;
%808 = qnn.conv2d(%802, %803, 0 /* ty=int32 */, 0 /* ty=int32 */, %796, %804, padding=[1, 1, 1, 1], channels=32, kernel_size=[3, 3], out_dtype="int32") /* ty=Tensor[(1, 32, 136, 240), int32] */;
%809 = qnn.requantize(%806, %807, 0 /* ty=int32 */, meta[relay.Constant][240] /* ty=Tensor[(32), float32] */, meta[relay.Constant][241] /* ty=Tensor[(32), int32] */, axis=0, out_dtype="int32") /* ty=Tensor[(32), int32] */;
%810 = nn.bias_add(%808, %809) /* ty=Tensor[(1, 32, 136, 240), int32] */;
%811 = power(2f /* ty=float32 */, 5f /* ty=float32 */) /* ty=float32 */;
%812 = qnn.dequantize(%810, meta[relay.Constant][240] /* ty=Tensor[(32), float32] */, meta[relay.Constant][241] /* ty=Tensor[(32), int32] */, axis=1) /* ty=Tensor[(1, 32, 136, 240), float32] */;
%813 = divide(1f /* ty=float32 */, %811) /* ty=float32 */;
%814 = qnn.quantize(%812, %813, 0 /* ty=int32 */, out_dtype="int8") /* ty=Tensor[(1, 32, 136, 240), int8] */;
%815 = clip(%814, a_min=-127f, a_max=127f) /* ty=Tensor[(1, 32, 136, 240), int8] */;
%816 = power(2f /* ty=float32 */, 21f /* ty=float32 */) /* ty=float32 */;
%817 = divide(1f /* ty=float32 */, %816) /* ty=float32 */;
%818 = multiply(%817, 64616f /* ty=float32 */) /* ty=float32 */;
%819 = maximum(%815, meta[relay.Constant][242] /* ty=int8 */) /* ty=Tensor[(1, 32, 136, 240), int8] */;
%820 = qnn.quantize(meta[relay.Constant][243] /* ty=Tensor[(1, 32, 1, 1), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int8", axis=0) /* ty=Tensor[(1, 32, 1, 1), int8] */;
%821 = squeeze(%818) /* ty=float32 */;
%822 = power(2f /* ty=float32 */, 26f /* ty=float32 */) /* ty=float32 */;
%823 = qnn.quantize(meta[relay.Constant][244] /* ty=Tensor[(1), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int32") /* ty=Tensor[(1), int32] */;
%824 = divide(1f /* ty=float32 */, %822) /* ty=float32 */;
%825 = qnn.conv2d(%819, %820, 0 /* ty=int32 */, 0 /* ty=int32 */, %813, %821, padding=[0, 0, 0, 0], channels=1, kernel_size=[1, 1], out_dtype="int32") /* ty=Tensor[(1, 1, 136, 240), int32] */;
%826 = qnn.requantize(%823, %824, 0 /* ty=int32 */, 0.000962853f /* ty=float32 */, 0 /* ty=int32 */, axis=0, out_dtype="int32") /* ty=Tensor[(1), int32] */;
%827 = nn.bias_add(%825, %826) /* ty=Tensor[(1, 1, 136, 240), int32] */;
%828 = power(2f /* ty=float32 */, 2f /* ty=float32 */) /* ty=float32 */;
%829 = qnn.dequantize(%827, 0.000962853f /* ty=float32 */, 0 /* ty=int32 */, axis=1) /* ty=Tensor[(1, 1, 136, 240), float32] */;
%830 = divide(1f /* ty=float32 */, %828) /* ty=float32 */;
%831 = qnn.quantize(%829, %830, 0 /* ty=int32 */, out_dtype="int8") /* ty=Tensor[(1, 1, 136, 240), int8] */;
%832 = clip(%831, a_min=-127f, a_max=127f) /* ty=Tensor[(1, 1, 136, 240), int8] */;
%833 = power(2f /* ty=float32 */, 21f /* ty=float32 */) /* ty=float32 */;
%834 = divide(1f /* ty=float32 */, %833) /* ty=float32 */;
%835 = multiply(%834, meta[relay.Constant][246] /* ty=Tensor[(4, 1, 1, 1), float32] */) /* ty=Tensor[(4, 1, 1, 1), float32] */;
%836 = qnn.quantize(meta[relay.Constant][245] /* ty=Tensor[(4, 32, 1, 1), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int8", axis=0) /* ty=Tensor[(4, 32, 1, 1), int8] */;
%837 = squeeze(%835) /* ty=Tensor[(4), float32] */;
%838 = power(2f /* ty=float32 */, 26f /* ty=float32 */) /* ty=float32 */;
%839 = qnn.quantize(meta[relay.Constant][247] /* ty=Tensor[(4), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int32") /* ty=Tensor[(4), int32] */;
%840 = divide(1f /* ty=float32 */, %838) /* ty=float32 */;
%841 = qnn.conv2d(%819, %836, 0 /* ty=int32 */, 0 /* ty=int32 */, %813, %837, padding=[0, 0, 0, 0], channels=4, kernel_size=[1, 1], out_dtype="int32") /* ty=Tensor[(1, 4, 136, 240), int32] */;
%842 = qnn.requantize(%839, %840, 0 /* ty=int32 */, meta[relay.Constant][248] /* ty=Tensor[(4), float32] */, meta[relay.Constant][249] /* ty=Tensor[(4), int32] */, axis=0, out_dtype="int32") /* ty=Tensor[(4), int32] */;
%843 = nn.bias_add(%841, %842) /* ty=Tensor[(1, 4, 136, 240), int32] */;
%844 = power(2f /* ty=float32 */, 4f /* ty=float32 */) /* ty=float32 */;
%845 = qnn.dequantize(%843, meta[relay.Constant][248] /* ty=Tensor[(4), float32] */, meta[relay.Constant][249] /* ty=Tensor[(4), int32] */, axis=1) /* ty=Tensor[(1, 4, 136, 240), float32] */;
%846 = divide(1f /* ty=float32 */, %844) /* ty=float32 */;
%847 = qnn.quantize(%845, %846, 0 /* ty=int32 */, out_dtype="int8") /* ty=Tensor[(1, 4, 136, 240), int8] */;
%848 = clip(%847, a_min=-127f, a_max=127f) /* ty=Tensor[(1, 4, 136, 240), int8] */;
%849 = qnn.dequantize(%848, %846, 0 /* ty=int32 */) /* ty=Tensor[(1, 4, 136, 240), float32] */;
%850 = power(2f /* ty=float32 */, 7f /* ty=float32 */) /* ty=float32 */;
%851 = sigmoid(%849) /* ty=Tensor[(1, 4, 136, 240), float32] */;
%852 = divide(1f /* ty=float32 */, %850) /* ty=float32 */;
%853 = qnn.quantize(%851, %852, 0 /* ty=int32 */, out_dtype="int8") /* ty=Tensor[(1, 4, 136, 240), int8] */;
%854 = clip(%853, a_min=-127f, a_max=127f) /* ty=Tensor[(1, 4, 136, 240), int8] */;
%855 = qnn.dequantize(%854, %852, 0 /* ty=int32 */) /* ty=Tensor[(1, 4, 136, 240), float32] */;
%856 = multiply(512f /* ty=float32 */, %855) /* ty=Tensor[(1, 4, 136, 240), float32] */;
%857 = add(0f /* ty=float32 */, %856) /* ty=Tensor[(1, 4, 136, 240), float32] */;
%858 = power(2f /* ty=float32 */, 23f /* ty=float32 */) /* ty=float32 */;
%859 = divide(1f /* ty=float32 */, %858) /* ty=float32 */;
%860 = multiply(%859, 51089f /* ty=float32 */) /* ty=float32 */;
%861 = qnn.quantize(meta[relay.Constant][250] /* ty=Tensor[(1, 32, 1, 1), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int8", axis=0) /* ty=Tensor[(1, 32, 1, 1), int8] */;
%862 = squeeze(%860) /* ty=float32 */;
%863 = power(2f /* ty=float32 */, 28f /* ty=float32 */) /* ty=float32 */;
%864 = qnn.quantize(meta[relay.Constant][251] /* ty=Tensor[(1), float32] */, 1f /* ty=float32 */, 0 /* ty=int32 */, out_dtype="int32") /* ty=Tensor[(1), int32] */;
%865 = divide(1f /* ty=float32 */, %863) /* ty=float32 */;
%866 = qnn.conv2d(%819, %861, 0 /* ty=int32 */, 0 /* ty=int32 */, %813, %862, padding=[0, 0, 0, 0], channels=1, kernel_size=[1, 1], out_dtype="int32") /* ty=Tensor[(1, 1, 136, 240), int32] */;
%867 = qnn.requantize(%864, %865, 0 /* ty=int32 */, 0.000190321f /* ty=float32 */, 0 /* ty=int32 */, axis=0, out_dtype="int32") /* ty=Tensor[(1), int32] */;
%868 = nn.bias_add(%866, %867) /* ty=Tensor[(1, 1, 136, 240), int32] */;
%869 = power(2f /* ty=float32 */, 6f /* ty=float32 */) /* ty=float32 */;
%870 = qnn.dequantize(%868, 0.000190321f /* ty=float32 */, 0 /* ty=int32 */, axis=1) /* ty=Tensor[(1, 1, 136, 240), float32] */;
%871 = divide(1f /* ty=float32 */, %869) /* ty=float32 */;
%872 = qnn.quantize(%870, %871, 0 /* ty=int32 */, out_dtype="int8") /* ty=Tensor[(1, 1, 136, 240), int8] */;
%873 = clip(%872, a_min=-127f, a_max=127f) /* ty=Tensor[(1, 1, 136, 240), int8] */;
%874 = qnn.dequantize(%873, %871, 0 /* ty=int32 */) /* ty=Tensor[(1, 1, 136, 240), float32] */;
%875 = power(2f /* ty=float32 */, 7f /* ty=float32 */) /* ty=float32 */;
%876 = sigmoid(%874) /* ty=Tensor[(1, 1, 136, 240), float32] */;
%877 = divide(1f /* ty=float32 */, %875) /* ty=float32 */;
%878 = qnn.quantize(%876, %877, 0 /* ty=int32 */, out_dtype="int8") /* ty=Tensor[(1, 1, 136, 240), int8] */;
%879 = clip(%878, a_min=-127f, a_max=127f) /* ty=Tensor[(1, 1, 136, 240), int8] */;
%880 = qnn.dequantize(%879, %877, 0 /* ty=int32 */) /* ty=Tensor[(1, 1, 136, 240), float32] */;
%881 = multiply(1.5708f /* ty=float32 */, %880) /* ty=Tensor[(1, 1, 136, 240), float32] */;
%882 = add(-0.785398f /* ty=float32 */, %881) /* ty=Tensor[(1, 1, 136, 240), float32] */;
%883 = power(%857, 1f /* ty=float32 */) /* ty=Tensor[(1, 4, 136, 240), float32] */;
%884 = power(%882, 1f /* ty=float32 */) /* ty=Tensor[(1, 1, 136, 240), float32] */;
%885 = (%883, %884) /* ty=(Tensor[(1, 4, 136, 240), float32], Tensor[(1, 1, 136, 240), float32]) */;
%886 = qnn.dequantize(%832, %830, 0 /* ty=int32 */) /* ty=Tensor[(1, 1, 136, 240), float32] */;
%887 = concatenate(%885, axis=1) /* ty=Tensor[(1, 5, 136, 240), float32] */;
%888 = (%886, %887, %im_info) /* ty=(Tensor[(1, 1, 136, 240), float32], Tensor[(1, 5, 136, 240), float32], Tensor[(1, 3), float32]) */;
%889 = vision.east_proposal(%888, score_thre=0.8f, nms_thre=0.2f) /* ty=(Tensor[(32640, 11), float32], Tensor[(1), int32]) */;
%889.0 /* ty=Tensor[(32640, 11), float32] */
}
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@tvm.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [tvm] mbrookhart commented on issue #12707: [Bug] a bug about fake quantize to intege and split op.
Posted by GitBox <gi...@apache.org>.
mbrookhart commented on issue #12707:
URL: https://github.com/apache/tvm/issues/12707#issuecomment-1238326469
@honghuichao Would it be possible to get instructions to reproduce the error? I'm not sure I can do that from the relay graph.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@tvm.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [tvm] honghuichao commented on issue #12707: [Bug] a bug about fake quantize to intege and split op.
Posted by GitBox <gi...@apache.org>.
honghuichao commented on issue #12707:
URL: https://github.com/apache/tvm/issues/12707#issuecomment-1320778719
@mbrookhart Sorry to trouble you,I've got a question to consult you. why the output type of qnn.add must be int8 when the input type of qnn.add is int8. I thik the output type of qnn.add / qnn.mul/.. can set by user via api.
because I met such case:
quantize+dequantize+add+add+quantize:
I run FQ2i Pass. it will transform to quantize+qnn.add(out_type="int8")+qnn.add.
but I think the right expr is quantize+qnn.add(output_type="int32")+qnn.add
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@tvm.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [tvm] honghuichao commented on issue #12707: [Bug] a bug about fake quantize to intege and split op.
Posted by GitBox <gi...@apache.org>.
honghuichao commented on issue #12707:
URL: https://github.com/apache/tvm/issues/12707#issuecomment-1238182918
I setting use_qat to true
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@tvm.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [tvm] honghuichao commented on issue #12707: [Bug] a bug about fake quantize to intege and split op.
Posted by GitBox <gi...@apache.org>.
honghuichao commented on issue #12707:
URL: https://github.com/apache/tvm/issues/12707#issuecomment-1239634333
I add the code at tvm/src/relay/transforms/fake_quantization_to_integer.cc 469
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@tvm.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [tvm] honghuichao commented on issue #12707: [Bug] a bug about fake quantize to intege and split op.
Posted by GitBox <gi...@apache.org>.
honghuichao commented on issue #12707:
URL: https://github.com/apache/tvm/issues/12707#issuecomment-1240169764
@mbrookhart It is true, but the reason why I do this instead of constant folding is to maintain some quantitative semantics to facilitate adaptation to the underlying hardware，such as power 2
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@tvm.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [tvm] honghuichao commented on issue #12707: [Bug] a bug about fake quantize to intege and split op.
Posted by GitBox <gi...@apache.org>.
honghuichao commented on issue #12707:
URL: https://github.com/apache/tvm/issues/12707#issuecomment-1241451747
@mbrookhart
Do you have a plan to modify this pass? If not, I may change another plan to support my schedule. Thanks
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@tvm.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org