tvm
tvm copied to clipboard
apache
[Bug] a bug about fake quantize to intege and split op.
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.
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 score_thre=0.8f, nms_thre=0.2f) / ty=(Tensor[(32640, 11), float32], Tensor[(1), int32]) /; %889.0 / ty=Tensor[(32640, 11), float32] */ }
@honghuichao Would it be possible to get instructions to reproduce the error? I'm not sure I can do that from the relay graph.
@mbrookhart
-
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=
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
I add the code at tvm/src/relay/transforms/fake_quantization_to_integer.cc 469
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.
@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 some hardware，such as power 2
@mbrookhart Do you have a plan to modify this pass? If not, I may change another plan to support my schedule. Thanks
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, but it seems that I forgot to handle the special case of quantize in the mutator, 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!
@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
@mbrookhart The sum of two int8 data is greater than the data range represented by int8
@mbrookhart The sum of two int8 data is greater than the data range represented by int8
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