Skip to content

Instantly share code, notes, and snippets.

@zhiics

zhiics/memory_plan

Created May 12, 2020 20:18
Show Gist options
  • Save zhiics/ad04a2b8ea9496c131876dd0ba09eca3 to your computer and use it in GitHub Desktop.
Save zhiics/ad04a2b8ea9496c131876dd0ba09eca3 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
memory_plan
type Storage {
}
def @main(%data: Tensor[(1, 3, 224, 224), float32]) -> Tensor[(1, 1000), float32] {
%0 = add(602112 /* ty=int64 */, 64 /* ty=int64 */) /* ty=int64 */;
%1 = subtract(%0, 1 /* ty=int64 */) /* ty=int64 */;
%2 = divide(%1, 64 /* ty=int64 */) /* ty=int64 */;
%3 = multiply(%2, 64 /* ty=int64 */) /* ty=int64 */;
%4 = add(0 /* ty=int64 */, %3) /* ty=int64 */;
%5 = add(3211264 /* ty=int64 */, 64 /* ty=int64 */) /* ty=int64 */;
%6 = subtract(%5, 1 /* ty=int64 */) /* ty=int64 */;
%7 = divide(%6, 64 /* ty=int64 */) /* ty=int64 */;
%8 = multiply(%7, 64 /* ty=int64 */) /* ty=int64 */;
%9 = add(%4, %8) /* ty=int64 */;
%10 = add(802816 /* ty=int64 */, 64 /* ty=int64 */) /* ty=int64 */;
%11 = subtract(%10, 1 /* ty=int64 */) /* ty=int64 */;
%12 = divide(%11, 64 /* ty=int64 */) /* ty=int64 */;
%13 = multiply(%12, 64 /* ty=int64 */) /* ty=int64 */;
%14 = add(%9, %13) /* ty=int64 */;
%15 = add(802816 /* ty=int64 */, 64 /* ty=int64 */) /* ty=int64 */;
%16 = subtract(%15, 1 /* ty=int64 */) /* ty=int64 */;
%17 = divide(%16, 64 /* ty=int64 */) /* ty=int64 */;
%18 = multiply(%17, 64 /* ty=int64 */) /* ty=int64 */;
%19 = add(%14, %18) /* ty=int64 */;
%20 = add(802816 /* ty=int64 */, 64 /* ty=int64 */) /* ty=int64 */;
%21 = subtract(%20, 1 /* ty=int64 */) /* ty=int64 */;
%22 = divide(%21, 64 /* ty=int64 */) /* ty=int64 */;
%23 = multiply(%22, 64 /* ty=int64 */) /* ty=int64 */;
%24 = add(%19, %23) /* ty=int64 */;
%25 = add(802816 /* ty=int64 */, 64 /* ty=int64 */) /* ty=int64 */;
%26 = subtract(%25, 1 /* ty=int64 */) /* ty=int64 */;
%27 = divide(%26, 64 /* ty=int64 */) /* ty=int64 */;
%28 = multiply(%27, 64 /* ty=int64 */) /* ty=int64 */;
%29 = add(%24, %28) /* ty=int64 */;
%30 = add(802816 /* ty=int64 */, 64 /* ty=int64 */) /* ty=int64 */;
%31 = subtract(%30, 1 /* ty=int64 */) /* ty=int64 */;
%32 = divide(%31, 64 /* ty=int64 */) /* ty=int64 */;
%33 = multiply(%32, 64 /* ty=int64 */) /* ty=int64 */;
%34 = add(%29, %33) /* ty=int64 */;
%35 = add(802816 /* ty=int64 */, 64 /* ty=int64 */) /* ty=int64 */;
%36 = subtract(%35, 1 /* ty=int64 */) /* ty=int64 */;
%37 = divide(%36, 64 /* ty=int64 */) /* ty=int64 */;
%38 = multiply(%37, 64 /* ty=int64 */) /* ty=int64 */;
%39 = add(%34, %38) /* ty=int64 */;
%40 = add(802816 /* ty=int64 */, 64 /* ty=int64 */) /* ty=int64 */;
%41 = subtract(%40, 1 /* ty=int64 */) /* ty=int64 */;
%42 = divide(%41, 64 /* ty=int64 */) /* ty=int64 */;
%43 = multiply(%42, 64 /* ty=int64 */) /* ty=int64 */;
%44 = add(%39, %43) /* ty=int64 */;
%45 = add(401408 /* ty=int64 */, 64 /* ty=int64 */) /* ty=int64 */;
%46 = subtract(%45, 1 /* ty=int64 */) /* ty=int64 */;
%47 = divide(%46, 64 /* ty=int64 */) /* ty=int64 */;
%48 = multiply(%47, 64 /* ty=int64 */) /* ty=int64 */;
%49 = add(%44, %48) /* ty=int64 */;
%50 = add(401408 /* ty=int64 */, 64 /* ty=int64 */) /* ty=int64 */;
%51 = subtract(%50, 1 /* ty=int64 */) /* ty=int64 */;
%52 = divide(%51, 64 /* ty=int64 */) /* ty=int64 */;
%53 = multiply(%52, 64 /* ty=int64 */) /* ty=int64 */;
%54 = add(%49, %53) /* ty=int64 */;
%55 = add(401408 /* ty=int64 */, 64 /* ty=int64 */) /* ty=int64 */;
%56 = subtract(%55, 1 /* ty=int64 */) /* ty=int64 */;
%57 = divide(%56, 64 /* ty=int64 */) /* ty=int64 */;
%58 = multiply(%57, 64 /* ty=int64 */) /* ty=int64 */;
%59 = add(%54, %58) /* ty=int64 */;
%60 = add(401408 /* ty=int64 */, 64 /* ty=int64 */) /* ty=int64 */;
%61 = subtract(%60, 1 /* ty=int64 */) /* ty=int64 */;
%62 = divide(%61, 64 /* ty=int64 */) /* ty=int64 */;
%63 = multiply(%62, 64 /* ty=int64 */) /* ty=int64 */;
%64 = add(%59, %63) /* ty=int64 */;
%65 = add(401408 /* ty=int64 */, 64 /* ty=int64 */) /* ty=int64 */;
%66 = subtract(%65, 1 /* ty=int64 */) /* ty=int64 */;
%67 = divide(%66, 64 /* ty=int64 */) /* ty=int64 */;
%68 = multiply(%67, 64 /* ty=int64 */) /* ty=int64 */;
%69 = add(%64, %68) /* ty=int64 */;
%70 = add(401408 /* ty=int64 */, 64 /* ty=int64 */) /* ty=int64 */;
%71 = subtract(%70, 1 /* ty=int64 */) /* ty=int64 */;
%72 = divide(%71, 64 /* ty=int64 */) /* ty=int64 */;
%73 = multiply(%72, 64 /* ty=int64 */) /* ty=int64 */;
%74 = add(%69, %73) /* ty=int64 */;
%75 = add(200704 /* ty=int64 */, 64 /* ty=int64 */) /* ty=int64 */;
%76 = subtract(%75, 1 /* ty=int64 */) /* ty=int64 */;
%77 = divide(%76, 64 /* ty=int64 */) /* ty=int64 */;
%78 = multiply(%77, 64 /* ty=int64 */) /* ty=int64 */;
%79 = add(%74, %78) /* ty=int64 */;
%80 = add(200704 /* ty=int64 */, 64 /* ty=int64 */) /* ty=int64 */;
%81 = subtract(%80, 1 /* ty=int64 */) /* ty=int64 */;
%82 = divide(%81, 64 /* ty=int64 */) /* ty=int64 */;
%83 = multiply(%82, 64 /* ty=int64 */) /* ty=int64 */;
%84 = add(%79, %83) /* ty=int64 */;
%85 = add(200704 /* ty=int64 */, 64 /* ty=int64 */) /* ty=int64 */;
%86 = subtract(%85, 1 /* ty=int64 */) /* ty=int64 */;
%87 = divide(%86, 64 /* ty=int64 */) /* ty=int64 */;
%88 = multiply(%87, 64 /* ty=int64 */) /* ty=int64 */;
%89 = add(%84, %88) /* ty=int64 */;
%90 = add(200704 /* ty=int64 */, 64 /* ty=int64 */) /* ty=int64 */;
%91 = subtract(%90, 1 /* ty=int64 */) /* ty=int64 */;
%92 = divide(%91, 64 /* ty=int64 */) /* ty=int64 */;
%93 = multiply(%92, 64 /* ty=int64 */) /* ty=int64 */;
%94 = add(%89, %93) /* ty=int64 */;
%95 = add(200704 /* ty=int64 */, 64 /* ty=int64 */) /* ty=int64 */;
%96 = subtract(%95, 1 /* ty=int64 */) /* ty=int64 */;
%97 = divide(%96, 64 /* ty=int64 */) /* ty=int64 */;
%98 = multiply(%97, 64 /* ty=int64 */) /* ty=int64 */;
%99 = add(%94, %98) /* ty=int64 */;
%100 = add(200704 /* ty=int64 */, 64 /* ty=int64 */) /* ty=int64 */;
%101 = subtract(%100, 1 /* ty=int64 */) /* ty=int64 */;
%102 = divide(%101, 64 /* ty=int64 */) /* ty=int64 */;
%103 = multiply(%102, 64 /* ty=int64 */) /* ty=int64 */;
%104 = add(%99, %103) /* ty=int64 */;
%105 = add(100352 /* ty=int64 */, 64 /* ty=int64 */) /* ty=int64 */;
%106 = subtract(%105, 1 /* ty=int64 */) /* ty=int64 */;
%107 = divide(%106, 64 /* ty=int64 */) /* ty=int64 */;
%108 = multiply(%107, 64 /* ty=int64 */) /* ty=int64 */;
%109 = add(%104, %108) /* ty=int64 */;
%110 = add(100352 /* ty=int64 */, 64 /* ty=int64 */) /* ty=int64 */;
%111 = subtract(%110, 1 /* ty=int64 */) /* ty=int64 */;
%112 = divide(%111, 64 /* ty=int64 */) /* ty=int64 */;
%113 = multiply(%112, 64 /* ty=int64 */) /* ty=int64 */;
%114 = add(%109, %113) /* ty=int64 */;
%115 = add(100352 /* ty=int64 */, 64 /* ty=int64 */) /* ty=int64 */;
%116 = subtract(%115, 1 /* ty=int64 */) /* ty=int64 */;
%117 = divide(%116, 64 /* ty=int64 */) /* ty=int64 */;
%118 = multiply(%117, 64 /* ty=int64 */) /* ty=int64 */;
%119 = add(%114, %118) /* ty=int64 */;
%120 = add(100352 /* ty=int64 */, 64 /* ty=int64 */) /* ty=int64 */;
%121 = subtract(%120, 1 /* ty=int64 */) /* ty=int64 */;
%122 = divide(%121, 64 /* ty=int64 */) /* ty=int64 */;
%123 = multiply(%122, 64 /* ty=int64 */) /* ty=int64 */;
%124 = add(%119, %123) /* ty=int64 */;
%125 = add(100352 /* ty=int64 */, 64 /* ty=int64 */) /* ty=int64 */;
%126 = subtract(%125, 1 /* ty=int64 */) /* ty=int64 */;
%127 = divide(%126, 64 /* ty=int64 */) /* ty=int64 */;
%128 = multiply(%127, 64 /* ty=int64 */) /* ty=int64 */;
%129 = add(%124, %128) /* ty=int64 */;
%130 = add(100352 /* ty=int64 */, 64 /* ty=int64 */) /* ty=int64 */;
%131 = subtract(%130, 1 /* ty=int64 */) /* ty=int64 */;
%132 = divide(%131, 64 /* ty=int64 */) /* ty=int64 */;
%133 = multiply(%132, 64 /* ty=int64 */) /* ty=int64 */;
%134 = add(%129, %133) /* ty=int64 */;
%135 = add(2048 /* ty=int64 */, 64 /* ty=int64 */) /* ty=int64 */;
%136 = subtract(%135, 1 /* ty=int64 */) /* ty=int64 */;
%137 = divide(%136, 64 /* ty=int64 */) /* ty=int64 */;
%138 = multiply(%137, 64 /* ty=int64 */) /* ty=int64 */;
%139 = add(%134, %138) /* ty=int64 */;
%140 = add(2048 /* ty=int64 */, 64 /* ty=int64 */) /* ty=int64 */;
%141 = subtract(%140, 1 /* ty=int64 */) /* ty=int64 */;
%142 = divide(%141, 64 /* ty=int64 */) /* ty=int64 */;
%143 = multiply(%142, 64 /* ty=int64 */) /* ty=int64 */;
%144 = add(%139, %143) /* ty=int64 */;
%145 = add(4000 /* ty=int64 */, 64 /* ty=int64 */) /* ty=int64 */;
%146 = subtract(%145, 1 /* ty=int64 */) /* ty=int64 */;
%147 = divide(%146, 64 /* ty=int64 */) /* ty=int64 */;
%148 = multiply(%147, 64 /* ty=int64 */) /* ty=int64 */;
%149 = add(%144, %148) /* ty=int64 */;
%150 = add(4000 /* ty=int64 */, 64 /* ty=int64 */) /* ty=int64 */;
%151 = subtract(%150, 1 /* ty=int64 */) /* ty=int64 */;
%152 = divide(%151, 64 /* ty=int64 */) /* ty=int64 */;
%153 = multiply(%152, 64 /* ty=int64 */) /* ty=int64 */;
let %total_size93840100422240: int64 = add(%149, %153) /* ty=int64 */;
let %region0: Storage[] = memory.alloc_storage(%total_size93840100422240, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][0]) /* ty=Storage[] */;
let %offset0: int64 = 0 /* ty=int64 */;
let %offset1: int64 = %4;
let %offset2: int64 = %9;
let %offset3: int64 = %14;
let %offset4: int64 = %19;
let %offset5: int64 = %24;
let %offset6: int64 = %29;
let %offset7: int64 = %34;
let %offset8: int64 = %39;
let %offset9: int64 = %44;
let %offset10: int64 = %49;
let %offset11: int64 = %54;
let %offset12: int64 = %59;
let %offset13: int64 = %64;
let %offset14: int64 = %69;
let %offset15: int64 = %74;
let %offset16: int64 = %79;
let %offset17: int64 = %84;
let %offset18: int64 = %89;
let %offset19: int64 = %94;
let %offset20: int64 = %99;
let %offset21: int64 = %104;
let %offset22: int64 = %109;
let %offset23: int64 = %114;
let %offset24: int64 = %119;
let %offset25: int64 = %124;
let %offset26: int64 = %129;
let %offset27: int64 = %134;
let %offset28: int64 = %139;
let %offset29: int64 = %144;
let %offset30: int64 = %149;
let %storage_0: Storage[] = %region0;
let %tensor_0: Tensor[(1, 3, 224, 224), float32] = memory.alloc_tensor(%region0, %offset0, meta[relay.Constant][0] /* ty=Tensor[(4), int64] */ /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][0]) /* ty=Tensor[(1, 3, 224, 224), float32] */;
let %const: Tensor[(3, 1, 1), float32] = meta[relay.Constant][1] /* ty=Tensor[(3, 1, 1), float32] */ /* ty=Tensor[(3, 1, 1), float32] */;
let %const1: Tensor[(3, 1, 1), float32] = meta[relay.Constant][2] /* ty=Tensor[(3, 1, 1), float32] */ /* ty=Tensor[(3, 1, 1), float32] */;
%155 = fn (%p0: Tensor[(1, 3, 224, 224), float32], %p1: Tensor[(3, 1, 1), float32], %p2: Tensor[(3, 1, 1), float32], Primitive=1) -> Tensor[(1, 3, 224, 224), float32] {
%154 = multiply(%p0, %p1) /* ty=Tensor[(1, 3, 224, 224), float32] */;
add(%154, %p2) /* ty=Tensor[(1, 3, 224, 224), float32] */
};
%156 = (%data, %const, %const1);
%157 = (%tensor_0,);
let %v: () = memory.invoke_tvm_op(%155, %156, %157) /* ty=() */;
let %x: Tensor[(1, 3, 224, 224), float32] = %tensor_0;
let %storage_01: Storage[] = %region0;
let %tensor_01: Tensor[(1, 64, 112, 112), float32] = memory.alloc_tensor(%region0, %offset1, meta[relay.Constant][3] /* ty=Tensor[(4), int64] */ /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][1]) /* ty=Tensor[(1, 64, 112, 112), float32] */;
let %const2: Tensor[(64, 3, 7, 7), float32] = meta[relay.Constant][4] /* ty=Tensor[(64, 3, 7, 7), float32] */ /* ty=Tensor[(64, 3, 7, 7), float32] */;
let %const3: Tensor[(64, 1, 1), float32] = meta[relay.Constant][5] /* ty=Tensor[(64, 1, 1), float32] */ /* ty=Tensor[(64, 1, 1), float32] */;
let %const4: Tensor[(64, 1, 1), float32] = meta[relay.Constant][6] /* ty=Tensor[(64, 1, 1), float32] */ /* ty=Tensor[(64, 1, 1), float32] */;
%161 = fn (%p01: Tensor[(1, 3, 224, 224), float32], %p11: Tensor[(64, 3, 7, 7), float32], %p21: Tensor[(64, 1, 1), float32], %p3: Tensor[(64, 1, 1), float32], Primitive=1) -> Tensor[(1, 64, 112, 112), float32] {
%158 = nn.conv2d(%p01, %p11, strides=[2, 2], padding=[3, 3, 3, 3], channels=64, kernel_size=[7, 7]) /* ty=Tensor[(1, 64, 112, 112), float32] */;
%159 = multiply(%158, %p21) /* ty=Tensor[(1, 64, 112, 112), float32] */;
%160 = add(%159, %p3) /* ty=Tensor[(1, 64, 112, 112), float32] */;
nn.relu(%160) /* ty=Tensor[(1, 64, 112, 112), float32] */
};
%162 = (%x, %const2, %const3, %const4);
%163 = (%tensor_01,);
let %v1: () = memory.invoke_tvm_op(%161, %162, %163) /* ty=() */;
let %x1: Tensor[(1, 64, 112, 112), float32] = %tensor_01;
let %storage_02: Storage[] = %region0;
let %tensor_02: Tensor[(1, 64, 56, 56), float32] = memory.alloc_tensor(%region0, %offset2, meta[relay.Constant][7] /* ty=Tensor[(4), int64] */ /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][2]) /* ty=Tensor[(1, 64, 56, 56), float32] */;
let %const5: Tensor[(64, 1, 1), float32] = meta[relay.Constant][8] /* ty=Tensor[(64, 1, 1), float32] */ /* ty=Tensor[(64, 1, 1), float32] */;
let %const6: Tensor[(64, 1, 1), float32] = meta[relay.Constant][9] /* ty=Tensor[(64, 1, 1), float32] */ /* ty=Tensor[(64, 1, 1), float32] */;
%167 = fn (%p02: Tensor[(1, 64, 112, 112), float32], %p12: Tensor[(64, 1, 1), float32], %p22: Tensor[(64, 1, 1), float32], Primitive=1) -> Tensor[(1, 64, 56, 56), float32] {
%164 = nn.max_pool2d(%p02, pool_size=[3, 3], strides=[2, 2], padding=[1, 1]) /* ty=Tensor[(1, 64, 56, 56), float32] */;
%165 = multiply(%164, %p12) /* ty=Tensor[(1, 64, 56, 56), float32] */;
%166 = add(%165, %p22) /* ty=Tensor[(1, 64, 56, 56), float32] */;
nn.relu(%166) /* ty=Tensor[(1, 64, 56, 56), float32] */
};
%168 = (%x1, %const5, %const6);
%169 = (%tensor_02,);
let %v2: () = memory.invoke_tvm_op(%167, %168, %169) /* ty=() */;
let %x2: Tensor[(1, 64, 56, 56), float32] = %tensor_02;
let %storage_03: Storage[] = %region0;
let %tensor_03: Tensor[(1, 64, 56, 56), float32] = memory.alloc_tensor(%region0, %offset3, meta[relay.Constant][10] /* ty=Tensor[(4), int64] */ /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][3]) /* ty=Tensor[(1, 64, 56, 56), float32] */;
let %const7: Tensor[(64, 64, 3, 3), float32] = meta[relay.Constant][11] /* ty=Tensor[(64, 64, 3, 3), float32] */ /* ty=Tensor[(64, 64, 3, 3), float32] */;
let %const8: Tensor[(64, 1, 1), float32] = meta[relay.Constant][12] /* ty=Tensor[(64, 1, 1), float32] */ /* ty=Tensor[(64, 1, 1), float32] */;
let %const9: Tensor[(64, 1, 1), float32] = meta[relay.Constant][13] /* ty=Tensor[(64, 1, 1), float32] */ /* ty=Tensor[(64, 1, 1), float32] */;
%173 = fn (%p03: Tensor[(1, 64, 56, 56), float32], %p13: Tensor[(64, 64, 3, 3), float32], %p23: Tensor[(64, 1, 1), float32], %p31: Tensor[(64, 1, 1), float32], Primitive=1) -> Tensor[(1, 64, 56, 56), float32] {
%170 = nn.conv2d(%p03, %p13, padding=[1, 1, 1, 1], channels=64, kernel_size=[3, 3]) /* ty=Tensor[(1, 64, 56, 56), float32] */;
%171 = multiply(%170, %p23) /* ty=Tensor[(1, 64, 56, 56), float32] */;
%172 = add(%171, %p31) /* ty=Tensor[(1, 64, 56, 56), float32] */;
nn.relu(%172) /* ty=Tensor[(1, 64, 56, 56), float32] */
};
%174 = (%x2, %const7, %const8, %const9);
%175 = (%tensor_03,);
let %v3: () = memory.invoke_tvm_op(%173, %174, %175) /* ty=() */;
let %x3: Tensor[(1, 64, 56, 56), float32] = %tensor_03;
let %storage_04: Storage[] = %region0;
let %tensor_04: Tensor[(1, 64, 56, 56), float32] = memory.alloc_tensor(%region0, %offset4, meta[relay.Constant][14] /* ty=Tensor[(4), int64] */ /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][4]) /* ty=Tensor[(1, 64, 56, 56), float32] */;
let %const10: Tensor[(64, 64, 1, 1), float32] = meta[relay.Constant][15] /* ty=Tensor[(64, 64, 1, 1), float32] */ /* ty=Tensor[(64, 64, 1, 1), float32] */;
%176 = fn (%p04: Tensor[(1, 64, 56, 56), float32], %p14: Tensor[(64, 64, 1, 1), float32], Primitive=1) -> Tensor[(1, 64, 56, 56), float32] {
nn.conv2d(%p04, %p14, padding=[0, 0, 0, 0], channels=64, kernel_size=[1, 1]) /* ty=Tensor[(1, 64, 56, 56), float32] */
};
%177 = (%x2, %const10);
%178 = (%tensor_04,);
let %v4: () = memory.invoke_tvm_op(%176, %177, %178) /* ty=() */;
let %x4: Tensor[(1, 64, 56, 56), float32] = %tensor_04;
let %storage_05: Storage[] = %region0;
let %tensor_05: Tensor[(1, 64, 56, 56), float32] = memory.alloc_tensor(%region0, %offset5, meta[relay.Constant][16] /* ty=Tensor[(4), int64] */ /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][5]) /* ty=Tensor[(1, 64, 56, 56), float32] */;
let %const11: Tensor[(64, 64, 3, 3), float32] = meta[relay.Constant][17] /* ty=Tensor[(64, 64, 3, 3), float32] */ /* ty=Tensor[(64, 64, 3, 3), float32] */;
%180 = fn (%p05: Tensor[(1, 64, 56, 56), float32], %p15: Tensor[(64, 64, 3, 3), float32], %p24: Tensor[(1, 64, 56, 56), float32], Primitive=1) -> Tensor[(1, 64, 56, 56), float32] {
%179 = nn.conv2d(%p05, %p15, padding=[1, 1, 1, 1], channels=64, kernel_size=[3, 3]) /* ty=Tensor[(1, 64, 56, 56), float32] */;
add(%179, %p24) /* ty=Tensor[(1, 64, 56, 56), float32] */
};
%181 = (%x3, %const11, %x4);
%182 = (%tensor_05,);
let %v5: () = memory.invoke_tvm_op(%180, %181, %182) /* ty=() */;
let %x5: Tensor[(1, 64, 56, 56), float32] = %tensor_05;
let %storage_06: Storage[] = %region0;
let %tensor_06: Tensor[(1, 64, 56, 56), float32] = memory.alloc_tensor(%region0, %offset6, meta[relay.Constant][18] /* ty=Tensor[(4), int64] */ /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][6]) /* ty=Tensor[(1, 64, 56, 56), float32] */;
let %const12: Tensor[(64, 1, 1), float32] = meta[relay.Constant][19] /* ty=Tensor[(64, 1, 1), float32] */ /* ty=Tensor[(64, 1, 1), float32] */;
let %const13: Tensor[(64, 1, 1), float32] = meta[relay.Constant][20] /* ty=Tensor[(64, 1, 1), float32] */ /* ty=Tensor[(64, 1, 1), float32] */;
%185 = fn (%p06: Tensor[(1, 64, 56, 56), float32], %p16: Tensor[(64, 1, 1), float32], %p25: Tensor[(64, 1, 1), float32], Primitive=1) -> Tensor[(1, 64, 56, 56), float32] {
%183 = multiply(%p06, %p16) /* ty=Tensor[(1, 64, 56, 56), float32] */;
%184 = add(%183, %p25) /* ty=Tensor[(1, 64, 56, 56), float32] */;
nn.relu(%184) /* ty=Tensor[(1, 64, 56, 56), float32] */
};
%186 = (%x5, %const12, %const13);
%187 = (%tensor_06,);
let %v6: () = memory.invoke_tvm_op(%185, %186, %187) /* ty=() */;
let %x6: Tensor[(1, 64, 56, 56), float32] = %tensor_06;
let %storage_07: Storage[] = %region0;
let %tensor_07: Tensor[(1, 64, 56, 56), float32] = memory.alloc_tensor(%region0, %offset7, meta[relay.Constant][21] /* ty=Tensor[(4), int64] */ /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][7]) /* ty=Tensor[(1, 64, 56, 56), float32] */;
let %const14: Tensor[(64, 64, 3, 3), float32] = meta[relay.Constant][22] /* ty=Tensor[(64, 64, 3, 3), float32] */ /* ty=Tensor[(64, 64, 3, 3), float32] */;
let %const15: Tensor[(64, 1, 1), float32] = meta[relay.Constant][23] /* ty=Tensor[(64, 1, 1), float32] */ /* ty=Tensor[(64, 1, 1), float32] */;
let %const16: Tensor[(64, 1, 1), float32] = meta[relay.Constant][24] /* ty=Tensor[(64, 1, 1), float32] */ /* ty=Tensor[(64, 1, 1), float32] */;
%191 = fn (%p07: Tensor[(1, 64, 56, 56), float32], %p17: Tensor[(64, 64, 3, 3), float32], %p26: Tensor[(64, 1, 1), float32], %p32: Tensor[(64, 1, 1), float32], Primitive=1) -> Tensor[(1, 64, 56, 56), float32] {
%188 = nn.conv2d(%p07, %p17, padding=[1, 1, 1, 1], channels=64, kernel_size=[3, 3]) /* ty=Tensor[(1, 64, 56, 56), float32] */;
%189 = multiply(%188, %p26) /* ty=Tensor[(1, 64, 56, 56), float32] */;
%190 = add(%189, %p32) /* ty=Tensor[(1, 64, 56, 56), float32] */;
nn.relu(%190) /* ty=Tensor[(1, 64, 56, 56), float32] */
};
%192 = (%x6, %const14, %const15, %const16);
%193 = (%tensor_07,);
let %v7: () = memory.invoke_tvm_op(%191, %192, %193) /* ty=() */;
let %x7: Tensor[(1, 64, 56, 56), float32] = %tensor_07;
let %storage_08: Storage[] = %region0;
let %tensor_08: Tensor[(1, 64, 56, 56), float32] = memory.alloc_tensor(%region0, %offset8, meta[relay.Constant][25] /* ty=Tensor[(4), int64] */ /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][8]) /* ty=Tensor[(1, 64, 56, 56), float32] */;
let %const17: Tensor[(64, 64, 3, 3), float32] = meta[relay.Constant][26] /* ty=Tensor[(64, 64, 3, 3), float32] */ /* ty=Tensor[(64, 64, 3, 3), float32] */;
let %const18: Tensor[(64, 1, 1), float32] = meta[relay.Constant][27] /* ty=Tensor[(64, 1, 1), float32] */ /* ty=Tensor[(64, 1, 1), float32] */;
let %const19: Tensor[(64, 1, 1), float32] = meta[relay.Constant][28] /* ty=Tensor[(64, 1, 1), float32] */ /* ty=Tensor[(64, 1, 1), float32] */;
%198 = fn (%p08: Tensor[(1, 64, 56, 56), float32], %p18: Tensor[(64, 64, 3, 3), float32], %p27: Tensor[(1, 64, 56, 56), float32], %p33: Tensor[(64, 1, 1), float32], %p4: Tensor[(64, 1, 1), float32], Primitive=1) -> Tensor[(1, 64, 56, 56), float32] {
%194 = nn.conv2d(%p08, %p18, padding=[1, 1, 1, 1], channels=64, kernel_size=[3, 3]) /* ty=Tensor[(1, 64, 56, 56), float32] */;
%195 = add(%194, %p27) /* ty=Tensor[(1, 64, 56, 56), float32] */;
%196 = multiply(%195, %p33) /* ty=Tensor[(1, 64, 56, 56), float32] */;
%197 = add(%196, %p4) /* ty=Tensor[(1, 64, 56, 56), float32] */;
nn.relu(%197) /* ty=Tensor[(1, 64, 56, 56), float32] */
};
%199 = (%x7, %const17, %x5, %const18, %const19);
%200 = (%tensor_08,);
let %v8: () = memory.invoke_tvm_op(%198, %199, %200) /* ty=() */;
let %x8: Tensor[(1, 64, 56, 56), float32] = %tensor_08;
let %storage_09: Storage[] = %region0;
let %tensor_09: Tensor[(1, 128, 28, 28), float32] = memory.alloc_tensor(%region0, %offset9, meta[relay.Constant][29] /* ty=Tensor[(4), int64] */ /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][9]) /* ty=Tensor[(1, 128, 28, 28), float32] */;
let %const20: Tensor[(128, 64, 3, 3), float32] = meta[relay.Constant][30] /* ty=Tensor[(128, 64, 3, 3), float32] */ /* ty=Tensor[(128, 64, 3, 3), float32] */;
let %const21: Tensor[(128, 1, 1), float32] = meta[relay.Constant][31] /* ty=Tensor[(128, 1, 1), float32] */ /* ty=Tensor[(128, 1, 1), float32] */;
let %const22: Tensor[(128, 1, 1), float32] = meta[relay.Constant][32] /* ty=Tensor[(128, 1, 1), float32] */ /* ty=Tensor[(128, 1, 1), float32] */;
%204 = fn (%p09: Tensor[(1, 64, 56, 56), float32], %p19: Tensor[(128, 64, 3, 3), float32], %p28: Tensor[(128, 1, 1), float32], %p34: Tensor[(128, 1, 1), float32], Primitive=1) -> Tensor[(1, 128, 28, 28), float32] {
%201 = nn.conv2d(%p09, %p19, strides=[2, 2], padding=[1, 1, 1, 1], channels=128, kernel_size=[3, 3]) /* ty=Tensor[(1, 128, 28, 28), float32] */;
%202 = multiply(%201, %p28) /* ty=Tensor[(1, 128, 28, 28), float32] */;
%203 = add(%202, %p34) /* ty=Tensor[(1, 128, 28, 28), float32] */;
nn.relu(%203) /* ty=Tensor[(1, 128, 28, 28), float32] */
};
%205 = (%x8, %const20, %const21, %const22);
%206 = (%tensor_09,);
let %v9: () = memory.invoke_tvm_op(%204, %205, %206) /* ty=() */;
let %x9: Tensor[(1, 128, 28, 28), float32] = %tensor_09;
let %storage_010: Storage[] = %region0;
let %tensor_010: Tensor[(1, 128, 28, 28), float32] = memory.alloc_tensor(%region0, %offset10, meta[relay.Constant][33] /* ty=Tensor[(4), int64] */ /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][10]) /* ty=Tensor[(1, 128, 28, 28), float32] */;
let %const23: Tensor[(128, 64, 1, 1), float32] = meta[relay.Constant][34] /* ty=Tensor[(128, 64, 1, 1), float32] */ /* ty=Tensor[(128, 64, 1, 1), float32] */;
%207 = fn (%p010: Tensor[(1, 64, 56, 56), float32], %p110: Tensor[(128, 64, 1, 1), float32], Primitive=1) -> Tensor[(1, 128, 28, 28), float32] {
nn.conv2d(%p010, %p110, strides=[2, 2], padding=[0, 0, 0, 0], channels=128, kernel_size=[1, 1]) /* ty=Tensor[(1, 128, 28, 28), float32] */
};
%208 = (%x8, %const23);
%209 = (%tensor_010,);
let %v10: () = memory.invoke_tvm_op(%207, %208, %209) /* ty=() */;
let %x10: Tensor[(1, 128, 28, 28), float32] = %tensor_010;
let %storage_011: Storage[] = %region0;
let %tensor_011: Tensor[(1, 128, 28, 28), float32] = memory.alloc_tensor(%region0, %offset11, meta[relay.Constant][35] /* ty=Tensor[(4), int64] */ /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][11]) /* ty=Tensor[(1, 128, 28, 28), float32] */;
let %const24: Tensor[(128, 128, 3, 3), float32] = meta[relay.Constant][36] /* ty=Tensor[(128, 128, 3, 3), float32] */ /* ty=Tensor[(128, 128, 3, 3), float32] */;
%211 = fn (%p011: Tensor[(1, 128, 28, 28), float32], %p111: Tensor[(128, 128, 3, 3), float32], %p29: Tensor[(1, 128, 28, 28), float32], Primitive=1) -> Tensor[(1, 128, 28, 28), float32] {
%210 = nn.conv2d(%p011, %p111, padding=[1, 1, 1, 1], channels=128, kernel_size=[3, 3]) /* ty=Tensor[(1, 128, 28, 28), float32] */;
add(%210, %p29) /* ty=Tensor[(1, 128, 28, 28), float32] */
};
%212 = (%x9, %const24, %x10);
%213 = (%tensor_011,);
let %v11: () = memory.invoke_tvm_op(%211, %212, %213) /* ty=() */;
let %x11: Tensor[(1, 128, 28, 28), float32] = %tensor_011;
let %storage_012: Storage[] = %region0;
let %tensor_012: Tensor[(1, 128, 28, 28), float32] = memory.alloc_tensor(%region0, %offset12, meta[relay.Constant][37] /* ty=Tensor[(4), int64] */ /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][12]) /* ty=Tensor[(1, 128, 28, 28), float32] */;
let %const25: Tensor[(128, 1, 1), float32] = meta[relay.Constant][38] /* ty=Tensor[(128, 1, 1), float32] */ /* ty=Tensor[(128, 1, 1), float32] */;
let %const26: Tensor[(128, 1, 1), float32] = meta[relay.Constant][39] /* ty=Tensor[(128, 1, 1), float32] */ /* ty=Tensor[(128, 1, 1), float32] */;
%216 = fn (%p012: Tensor[(1, 128, 28, 28), float32], %p112: Tensor[(128, 1, 1), float32], %p210: Tensor[(128, 1, 1), float32], Primitive=1) -> Tensor[(1, 128, 28, 28), float32] {
%214 = multiply(%p012, %p112) /* ty=Tensor[(1, 128, 28, 28), float32] */;
%215 = add(%214, %p210) /* ty=Tensor[(1, 128, 28, 28), float32] */;
nn.relu(%215) /* ty=Tensor[(1, 128, 28, 28), float32] */
};
%217 = (%x11, %const25, %const26);
%218 = (%tensor_012,);
let %v12: () = memory.invoke_tvm_op(%216, %217, %218) /* ty=() */;
let %x12: Tensor[(1, 128, 28, 28), float32] = %tensor_012;
let %storage_013: Storage[] = %region0;
let %tensor_013: Tensor[(1, 128, 28, 28), float32] = memory.alloc_tensor(%region0, %offset13, meta[relay.Constant][40] /* ty=Tensor[(4), int64] */ /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][13]) /* ty=Tensor[(1, 128, 28, 28), float32] */;
let %const27: Tensor[(128, 128, 3, 3), float32] = meta[relay.Constant][41] /* ty=Tensor[(128, 128, 3, 3), float32] */ /* ty=Tensor[(128, 128, 3, 3), float32] */;
let %const28: Tensor[(128, 1, 1), float32] = meta[relay.Constant][42] /* ty=Tensor[(128, 1, 1), float32] */ /* ty=Tensor[(128, 1, 1), float32] */;
let %const29: Tensor[(128, 1, 1), float32] = meta[relay.Constant][43] /* ty=Tensor[(128, 1, 1), float32] */ /* ty=Tensor[(128, 1, 1), float32] */;
%222 = fn (%p013: Tensor[(1, 128, 28, 28), float32], %p113: Tensor[(128, 128, 3, 3), float32], %p211: Tensor[(128, 1, 1), float32], %p35: Tensor[(128, 1, 1), float32], Primitive=1) -> Tensor[(1, 128, 28, 28), float32] {
%219 = nn.conv2d(%p013, %p113, padding=[1, 1, 1, 1], channels=128, kernel_size=[3, 3]) /* ty=Tensor[(1, 128, 28, 28), float32] */;
%220 = multiply(%219, %p211) /* ty=Tensor[(1, 128, 28, 28), float32] */;
%221 = add(%220, %p35) /* ty=Tensor[(1, 128, 28, 28), float32] */;
nn.relu(%221) /* ty=Tensor[(1, 128, 28, 28), float32] */
};
%223 = (%x12, %const27, %const28, %const29);
%224 = (%tensor_013,);
let %v13: () = memory.invoke_tvm_op(%222, %223, %224) /* ty=() */;
let %x13: Tensor[(1, 128, 28, 28), float32] = %tensor_013;
let %storage_014: Storage[] = %region0;
let %tensor_014: Tensor[(1, 128, 28, 28), float32] = memory.alloc_tensor(%region0, %offset14, meta[relay.Constant][44] /* ty=Tensor[(4), int64] */ /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][14]) /* ty=Tensor[(1, 128, 28, 28), float32] */;
let %const30: Tensor[(128, 128, 3, 3), float32] = meta[relay.Constant][45] /* ty=Tensor[(128, 128, 3, 3), float32] */ /* ty=Tensor[(128, 128, 3, 3), float32] */;
let %const31: Tensor[(128, 1, 1), float32] = meta[relay.Constant][46] /* ty=Tensor[(128, 1, 1), float32] */ /* ty=Tensor[(128, 1, 1), float32] */;
let %const32: Tensor[(128, 1, 1), float32] = meta[relay.Constant][47] /* ty=Tensor[(128, 1, 1), float32] */ /* ty=Tensor[(128, 1, 1), float32] */;
%229 = fn (%p014: Tensor[(1, 128, 28, 28), float32], %p114: Tensor[(128, 128, 3, 3), float32], %p212: Tensor[(1, 128, 28, 28), float32], %p36: Tensor[(128, 1, 1), float32], %p41: Tensor[(128, 1, 1), float32], Primitive=1) -> Tensor[(1, 128, 28, 28), float32] {
%225 = nn.conv2d(%p014, %p114, padding=[1, 1, 1, 1], channels=128, kernel_size=[3, 3]) /* ty=Tensor[(1, 128, 28, 28), float32] */;
%226 = add(%225, %p212) /* ty=Tensor[(1, 128, 28, 28), float32] */;
%227 = multiply(%226, %p36) /* ty=Tensor[(1, 128, 28, 28), float32] */;
%228 = add(%227, %p41) /* ty=Tensor[(1, 128, 28, 28), float32] */;
nn.relu(%228) /* ty=Tensor[(1, 128, 28, 28), float32] */
};
%230 = (%x13, %const30, %x11, %const31, %const32);
%231 = (%tensor_014,);
let %v14: () = memory.invoke_tvm_op(%229, %230, %231) /* ty=() */;
let %x14: Tensor[(1, 128, 28, 28), float32] = %tensor_014;
let %storage_015: Storage[] = %region0;
let %tensor_015: Tensor[(1, 256, 14, 14), float32] = memory.alloc_tensor(%region0, %offset15, meta[relay.Constant][48] /* ty=Tensor[(4), int64] */ /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][15]) /* ty=Tensor[(1, 256, 14, 14), float32] */;
let %const33: Tensor[(256, 128, 3, 3), float32] = meta[relay.Constant][49] /* ty=Tensor[(256, 128, 3, 3), float32] */ /* ty=Tensor[(256, 128, 3, 3), float32] */;
let %const34: Tensor[(256, 1, 1), float32] = meta[relay.Constant][50] /* ty=Tensor[(256, 1, 1), float32] */ /* ty=Tensor[(256, 1, 1), float32] */;
let %const35: Tensor[(256, 1, 1), float32] = meta[relay.Constant][51] /* ty=Tensor[(256, 1, 1), float32] */ /* ty=Tensor[(256, 1, 1), float32] */;
%235 = fn (%p015: Tensor[(1, 128, 28, 28), float32], %p115: Tensor[(256, 128, 3, 3), float32], %p213: Tensor[(256, 1, 1), float32], %p37: Tensor[(256, 1, 1), float32], Primitive=1) -> Tensor[(1, 256, 14, 14), float32] {
%232 = nn.conv2d(%p015, %p115, strides=[2, 2], padding=[1, 1, 1, 1], channels=256, kernel_size=[3, 3]) /* ty=Tensor[(1, 256, 14, 14), float32] */;
%233 = multiply(%232, %p213) /* ty=Tensor[(1, 256, 14, 14), float32] */;
%234 = add(%233, %p37) /* ty=Tensor[(1, 256, 14, 14), float32] */;
nn.relu(%234) /* ty=Tensor[(1, 256, 14, 14), float32] */
};
%236 = (%x14, %const33, %const34, %const35);
%237 = (%tensor_015,);
let %v15: () = memory.invoke_tvm_op(%235, %236, %237) /* ty=() */;
let %x15: Tensor[(1, 256, 14, 14), float32] = %tensor_015;
let %storage_016: Storage[] = %region0;
let %tensor_016: Tensor[(1, 256, 14, 14), float32] = memory.alloc_tensor(%region0, %offset16, meta[relay.Constant][52] /* ty=Tensor[(4), int64] */ /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][16]) /* ty=Tensor[(1, 256, 14, 14), float32] */;
let %const36: Tensor[(256, 128, 1, 1), float32] = meta[relay.Constant][53] /* ty=Tensor[(256, 128, 1, 1), float32] */ /* ty=Tensor[(256, 128, 1, 1), float32] */;
%238 = fn (%p016: Tensor[(1, 128, 28, 28), float32], %p116: Tensor[(256, 128, 1, 1), float32], Primitive=1) -> Tensor[(1, 256, 14, 14), float32] {
nn.conv2d(%p016, %p116, strides=[2, 2], padding=[0, 0, 0, 0], channels=256, kernel_size=[1, 1]) /* ty=Tensor[(1, 256, 14, 14), float32] */
};
%239 = (%x14, %const36);
%240 = (%tensor_016,);
let %v16: () = memory.invoke_tvm_op(%238, %239, %240) /* ty=() */;
let %x16: Tensor[(1, 256, 14, 14), float32] = %tensor_016;
let %storage_017: Storage[] = %region0;
let %tensor_017: Tensor[(1, 256, 14, 14), float32] = memory.alloc_tensor(%region0, %offset17, meta[relay.Constant][54] /* ty=Tensor[(4), int64] */ /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][17]) /* ty=Tensor[(1, 256, 14, 14), float32] */;
let %const37: Tensor[(256, 256, 3, 3), float32] = meta[relay.Constant][55] /* ty=Tensor[(256, 256, 3, 3), float32] */ /* ty=Tensor[(256, 256, 3, 3), float32] */;
%242 = fn (%p017: Tensor[(1, 256, 14, 14), float32], %p117: Tensor[(256, 256, 3, 3), float32], %p214: Tensor[(1, 256, 14, 14), float32], Primitive=1) -> Tensor[(1, 256, 14, 14), float32] {
%241 = nn.conv2d(%p017, %p117, padding=[1, 1, 1, 1], channels=256, kernel_size=[3, 3]) /* ty=Tensor[(1, 256, 14, 14), float32] */;
add(%241, %p214) /* ty=Tensor[(1, 256, 14, 14), float32] */
};
%243 = (%x15, %const37, %x16);
%244 = (%tensor_017,);
let %v17: () = memory.invoke_tvm_op(%242, %243, %244) /* ty=() */;
let %x17: Tensor[(1, 256, 14, 14), float32] = %tensor_017;
let %storage_018: Storage[] = %region0;
let %tensor_018: Tensor[(1, 256, 14, 14), float32] = memory.alloc_tensor(%region0, %offset18, meta[relay.Constant][56] /* ty=Tensor[(4), int64] */ /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][18]) /* ty=Tensor[(1, 256, 14, 14), float32] */;
let %const38: Tensor[(256, 1, 1), float32] = meta[relay.Constant][57] /* ty=Tensor[(256, 1, 1), float32] */ /* ty=Tensor[(256, 1, 1), float32] */;
let %const39: Tensor[(256, 1, 1), float32] = meta[relay.Constant][58] /* ty=Tensor[(256, 1, 1), float32] */ /* ty=Tensor[(256, 1, 1), float32] */;
%247 = fn (%p018: Tensor[(1, 256, 14, 14), float32], %p118: Tensor[(256, 1, 1), float32], %p215: Tensor[(256, 1, 1), float32], Primitive=1) -> Tensor[(1, 256, 14, 14), float32] {
%245 = multiply(%p018, %p118) /* ty=Tensor[(1, 256, 14, 14), float32] */;
%246 = add(%245, %p215) /* ty=Tensor[(1, 256, 14, 14), float32] */;
nn.relu(%246) /* ty=Tensor[(1, 256, 14, 14), float32] */
};
%248 = (%x17, %const38, %const39);
%249 = (%tensor_018,);
let %v18: () = memory.invoke_tvm_op(%247, %248, %249) /* ty=() */;
let %x18: Tensor[(1, 256, 14, 14), float32] = %tensor_018;
let %storage_019: Storage[] = %region0;
let %tensor_019: Tensor[(1, 256, 14, 14), float32] = memory.alloc_tensor(%region0, %offset19, meta[relay.Constant][59] /* ty=Tensor[(4), int64] */ /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][19]) /* ty=Tensor[(1, 256, 14, 14), float32] */;
let %const40: Tensor[(256, 256, 3, 3), float32] = meta[relay.Constant][60] /* ty=Tensor[(256, 256, 3, 3), float32] */ /* ty=Tensor[(256, 256, 3, 3), float32] */;
let %const41: Tensor[(256, 1, 1), float32] = meta[relay.Constant][61] /* ty=Tensor[(256, 1, 1), float32] */ /* ty=Tensor[(256, 1, 1), float32] */;
let %const42: Tensor[(256, 1, 1), float32] = meta[relay.Constant][62] /* ty=Tensor[(256, 1, 1), float32] */ /* ty=Tensor[(256, 1, 1), float32] */;
%253 = fn (%p019: Tensor[(1, 256, 14, 14), float32], %p119: Tensor[(256, 256, 3, 3), float32], %p216: Tensor[(256, 1, 1), float32], %p38: Tensor[(256, 1, 1), float32], Primitive=1) -> Tensor[(1, 256, 14, 14), float32] {
%250 = nn.conv2d(%p019, %p119, padding=[1, 1, 1, 1], channels=256, kernel_size=[3, 3]) /* ty=Tensor[(1, 256, 14, 14), float32] */;
%251 = multiply(%250, %p216) /* ty=Tensor[(1, 256, 14, 14), float32] */;
%252 = add(%251, %p38) /* ty=Tensor[(1, 256, 14, 14), float32] */;
nn.relu(%252) /* ty=Tensor[(1, 256, 14, 14), float32] */
};
%254 = (%x18, %const40, %const41, %const42);
%255 = (%tensor_019,);
let %v19: () = memory.invoke_tvm_op(%253, %254, %255) /* ty=() */;
let %x19: Tensor[(1, 256, 14, 14), float32] = %tensor_019;
let %storage_020: Storage[] = %region0;
let %tensor_020: Tensor[(1, 256, 14, 14), float32] = memory.alloc_tensor(%region0, %offset20, meta[relay.Constant][63] /* ty=Tensor[(4), int64] */ /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][20]) /* ty=Tensor[(1, 256, 14, 14), float32] */;
let %const43: Tensor[(256, 256, 3, 3), float32] = meta[relay.Constant][64] /* ty=Tensor[(256, 256, 3, 3), float32] */ /* ty=Tensor[(256, 256, 3, 3), float32] */;
let %const44: Tensor[(256, 1, 1), float32] = meta[relay.Constant][65] /* ty=Tensor[(256, 1, 1), float32] */ /* ty=Tensor[(256, 1, 1), float32] */;
let %const45: Tensor[(256, 1, 1), float32] = meta[relay.Constant][66] /* ty=Tensor[(256, 1, 1), float32] */ /* ty=Tensor[(256, 1, 1), float32] */;
%260 = fn (%p020: Tensor[(1, 256, 14, 14), float32], %p120: Tensor[(256, 256, 3, 3), float32], %p217: Tensor[(1, 256, 14, 14), float32], %p39: Tensor[(256, 1, 1), float32], %p42: Tensor[(256, 1, 1), float32], Primitive=1) -> Tensor[(1, 256, 14, 14), float32] {
%256 = nn.conv2d(%p020, %p120, padding=[1, 1, 1, 1], channels=256, kernel_size=[3, 3]) /* ty=Tensor[(1, 256, 14, 14), float32] */;
%257 = add(%256, %p217) /* ty=Tensor[(1, 256, 14, 14), float32] */;
%258 = multiply(%257, %p39) /* ty=Tensor[(1, 256, 14, 14), float32] */;
%259 = add(%258, %p42) /* ty=Tensor[(1, 256, 14, 14), float32] */;
nn.relu(%259) /* ty=Tensor[(1, 256, 14, 14), float32] */
};
%261 = (%x19, %const43, %x17, %const44, %const45);
%262 = (%tensor_020,);
let %v20: () = memory.invoke_tvm_op(%260, %261, %262) /* ty=() */;
let %x20: Tensor[(1, 256, 14, 14), float32] = %tensor_020;
let %storage_021: Storage[] = %region0;
let %tensor_021: Tensor[(1, 512, 7, 7), float32] = memory.alloc_tensor(%region0, %offset21, meta[relay.Constant][67] /* ty=Tensor[(4), int64] */ /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][21]) /* ty=Tensor[(1, 512, 7, 7), float32] */;
let %const46: Tensor[(512, 256, 3, 3), float32] = meta[relay.Constant][68] /* ty=Tensor[(512, 256, 3, 3), float32] */ /* ty=Tensor[(512, 256, 3, 3), float32] */;
let %const47: Tensor[(512, 1, 1), float32] = meta[relay.Constant][69] /* ty=Tensor[(512, 1, 1), float32] */ /* ty=Tensor[(512, 1, 1), float32] */;
let %const48: Tensor[(512, 1, 1), float32] = meta[relay.Constant][70] /* ty=Tensor[(512, 1, 1), float32] */ /* ty=Tensor[(512, 1, 1), float32] */;
%266 = fn (%p021: Tensor[(1, 256, 14, 14), float32], %p121: Tensor[(512, 256, 3, 3), float32], %p218: Tensor[(512, 1, 1), float32], %p310: Tensor[(512, 1, 1), float32], Primitive=1) -> Tensor[(1, 512, 7, 7), float32] {
%263 = nn.conv2d(%p021, %p121, strides=[2, 2], padding=[1, 1, 1, 1], channels=512, kernel_size=[3, 3]) /* ty=Tensor[(1, 512, 7, 7), float32] */;
%264 = multiply(%263, %p218) /* ty=Tensor[(1, 512, 7, 7), float32] */;
%265 = add(%264, %p310) /* ty=Tensor[(1, 512, 7, 7), float32] */;
nn.relu(%265) /* ty=Tensor[(1, 512, 7, 7), float32] */
};
%267 = (%x20, %const46, %const47, %const48);
%268 = (%tensor_021,);
let %v21: () = memory.invoke_tvm_op(%266, %267, %268) /* ty=() */;
let %x21: Tensor[(1, 512, 7, 7), float32] = %tensor_021;
let %storage_022: Storage[] = %region0;
let %tensor_022: Tensor[(1, 512, 7, 7), float32] = memory.alloc_tensor(%region0, %offset22, meta[relay.Constant][71] /* ty=Tensor[(4), int64] */ /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][22]) /* ty=Tensor[(1, 512, 7, 7), float32] */;
let %const49: Tensor[(512, 256, 1, 1), float32] = meta[relay.Constant][72] /* ty=Tensor[(512, 256, 1, 1), float32] */ /* ty=Tensor[(512, 256, 1, 1), float32] */;
%269 = fn (%p022: Tensor[(1, 256, 14, 14), float32], %p122: Tensor[(512, 256, 1, 1), float32], Primitive=1) -> Tensor[(1, 512, 7, 7), float32] {
nn.conv2d(%p022, %p122, strides=[2, 2], padding=[0, 0, 0, 0], channels=512, kernel_size=[1, 1]) /* ty=Tensor[(1, 512, 7, 7), float32] */
};
%270 = (%x20, %const49);
%271 = (%tensor_022,);
let %v22: () = memory.invoke_tvm_op(%269, %270, %271) /* ty=() */;
let %x22: Tensor[(1, 512, 7, 7), float32] = %tensor_022;
let %storage_023: Storage[] = %region0;
let %tensor_023: Tensor[(1, 512, 7, 7), float32] = memory.alloc_tensor(%region0, %offset23, meta[relay.Constant][73] /* ty=Tensor[(4), int64] */ /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][23]) /* ty=Tensor[(1, 512, 7, 7), float32] */;
let %const50: Tensor[(512, 512, 3, 3), float32] = meta[relay.Constant][74] /* ty=Tensor[(512, 512, 3, 3), float32] */ /* ty=Tensor[(512, 512, 3, 3), float32] */;
%273 = fn (%p023: Tensor[(1, 512, 7, 7), float32], %p123: Tensor[(512, 512, 3, 3), float32], %p219: Tensor[(1, 512, 7, 7), float32], Primitive=1) -> Tensor[(1, 512, 7, 7), float32] {
%272 = nn.conv2d(%p023, %p123, padding=[1, 1, 1, 1], channels=512, kernel_size=[3, 3]) /* ty=Tensor[(1, 512, 7, 7), float32] */;
add(%272, %p219) /* ty=Tensor[(1, 512, 7, 7), float32] */
};
%274 = (%x21, %const50, %x22);
%275 = (%tensor_023,);
let %v23: () = memory.invoke_tvm_op(%273, %274, %275) /* ty=() */;
let %x23: Tensor[(1, 512, 7, 7), float32] = %tensor_023;
let %storage_024: Storage[] = %region0;
let %tensor_024: Tensor[(1, 512, 7, 7), float32] = memory.alloc_tensor(%region0, %offset24, meta[relay.Constant][75] /* ty=Tensor[(4), int64] */ /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][24]) /* ty=Tensor[(1, 512, 7, 7), float32] */;
let %const51: Tensor[(512, 1, 1), float32] = meta[relay.Constant][76] /* ty=Tensor[(512, 1, 1), float32] */ /* ty=Tensor[(512, 1, 1), float32] */;
let %const52: Tensor[(512, 1, 1), float32] = meta[relay.Constant][77] /* ty=Tensor[(512, 1, 1), float32] */ /* ty=Tensor[(512, 1, 1), float32] */;
%278 = fn (%p024: Tensor[(1, 512, 7, 7), float32], %p124: Tensor[(512, 1, 1), float32], %p220: Tensor[(512, 1, 1), float32], Primitive=1) -> Tensor[(1, 512, 7, 7), float32] {
%276 = multiply(%p024, %p124) /* ty=Tensor[(1, 512, 7, 7), float32] */;
%277 = add(%276, %p220) /* ty=Tensor[(1, 512, 7, 7), float32] */;
nn.relu(%277) /* ty=Tensor[(1, 512, 7, 7), float32] */
};
%279 = (%x23, %const51, %const52);
%280 = (%tensor_024,);
let %v24: () = memory.invoke_tvm_op(%278, %279, %280) /* ty=() */;
let %x24: Tensor[(1, 512, 7, 7), float32] = %tensor_024;
let %storage_025: Storage[] = %region0;
let %tensor_025: Tensor[(1, 512, 7, 7), float32] = memory.alloc_tensor(%region0, %offset25, meta[relay.Constant][78] /* ty=Tensor[(4), int64] */ /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][25]) /* ty=Tensor[(1, 512, 7, 7), float32] */;
let %const53: Tensor[(512, 512, 3, 3), float32] = meta[relay.Constant][79] /* ty=Tensor[(512, 512, 3, 3), float32] */ /* ty=Tensor[(512, 512, 3, 3), float32] */;
let %const54: Tensor[(512, 1, 1), float32] = meta[relay.Constant][80] /* ty=Tensor[(512, 1, 1), float32] */ /* ty=Tensor[(512, 1, 1), float32] */;
let %const55: Tensor[(512, 1, 1), float32] = meta[relay.Constant][81] /* ty=Tensor[(512, 1, 1), float32] */ /* ty=Tensor[(512, 1, 1), float32] */;
%284 = fn (%p025: Tensor[(1, 512, 7, 7), float32], %p125: Tensor[(512, 512, 3, 3), float32], %p221: Tensor[(512, 1, 1), float32], %p311: Tensor[(512, 1, 1), float32], Primitive=1) -> Tensor[(1, 512, 7, 7), float32] {
%281 = nn.conv2d(%p025, %p125, padding=[1, 1, 1, 1], channels=512, kernel_size=[3, 3]) /* ty=Tensor[(1, 512, 7, 7), float32] */;
%282 = multiply(%281, %p221) /* ty=Tensor[(1, 512, 7, 7), float32] */;
%283 = add(%282, %p311) /* ty=Tensor[(1, 512, 7, 7), float32] */;
nn.relu(%283) /* ty=Tensor[(1, 512, 7, 7), float32] */
};
%285 = (%x24, %const53, %const54, %const55);
%286 = (%tensor_025,);
let %v25: () = memory.invoke_tvm_op(%284, %285, %286) /* ty=() */;
let %x25: Tensor[(1, 512, 7, 7), float32] = %tensor_025;
let %storage_026: Storage[] = %region0;
let %tensor_026: Tensor[(1, 512, 7, 7), float32] = memory.alloc_tensor(%region0, %offset26, meta[relay.Constant][82] /* ty=Tensor[(4), int64] */ /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][26]) /* ty=Tensor[(1, 512, 7, 7), float32] */;
let %const56: Tensor[(512, 512, 3, 3), float32] = meta[relay.Constant][83] /* ty=Tensor[(512, 512, 3, 3), float32] */ /* ty=Tensor[(512, 512, 3, 3), float32] */;
let %const57: Tensor[(512, 1, 1), float32] = meta[relay.Constant][84] /* ty=Tensor[(512, 1, 1), float32] */ /* ty=Tensor[(512, 1, 1), float32] */;
let %const58: Tensor[(512, 1, 1), float32] = meta[relay.Constant][85] /* ty=Tensor[(512, 1, 1), float32] */ /* ty=Tensor[(512, 1, 1), float32] */;
%291 = fn (%p026: Tensor[(1, 512, 7, 7), float32], %p126: Tensor[(512, 512, 3, 3), float32], %p222: Tensor[(1, 512, 7, 7), float32], %p312: Tensor[(512, 1, 1), float32], %p43: Tensor[(512, 1, 1), float32], Primitive=1) -> Tensor[(1, 512, 7, 7), float32] {
%287 = nn.conv2d(%p026, %p126, padding=[1, 1, 1, 1], channels=512, kernel_size=[3, 3]) /* ty=Tensor[(1, 512, 7, 7), float32] */;
%288 = add(%287, %p222) /* ty=Tensor[(1, 512, 7, 7), float32] */;
%289 = multiply(%288, %p312) /* ty=Tensor[(1, 512, 7, 7), float32] */;
%290 = add(%289, %p43) /* ty=Tensor[(1, 512, 7, 7), float32] */;
nn.relu(%290) /* ty=Tensor[(1, 512, 7, 7), float32] */
};
%292 = (%x25, %const56, %x23, %const57, %const58);
%293 = (%tensor_026,);
let %v26: () = memory.invoke_tvm_op(%291, %292, %293) /* ty=() */;
let %x26: Tensor[(1, 512, 7, 7), float32] = %tensor_026;
let %storage_027: Storage[] = %region0;
let %tensor_027: Tensor[(1, 512, 1, 1), float32] = memory.alloc_tensor(%region0, %offset27, meta[relay.Constant][86] /* ty=Tensor[(4), int64] */ /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][27]) /* ty=Tensor[(1, 512, 1, 1), float32] */;
%294 = fn (%p027: Tensor[(1, 512, 7, 7), float32], Primitive=1) -> Tensor[(1, 512, 1, 1), float32] {
nn.global_avg_pool2d(%p027) /* ty=Tensor[(1, 512, 1, 1), float32] */
};
%295 = (%x26,);
%296 = (%tensor_027,);
let %v27: () = memory.invoke_tvm_op(%294, %295, %296) /* ty=() */;
let %x27: Tensor[(1, 512, 1, 1), float32] = %tensor_027;
let %storage_028: Storage[] = %region0;
let %tensor_028: Tensor[(1, 512), float32] = memory.alloc_tensor(%region0, %offset28, meta[relay.Constant][87] /* ty=Tensor[(2), int64] */ /* ty=Tensor[(2), int64] */, meta[relay.attrs.AllocTensorAttrs][28]) /* ty=Tensor[(1, 512), float32] */;
%297 = fn (%p028: Tensor[(1, 512, 1, 1), float32], Primitive=1) -> Tensor[(1, 512), float32] {
nn.batch_flatten(%p028) /* ty=Tensor[(1, 512), float32] */
};
%298 = (%x27,);
%299 = (%tensor_028,);
let %v28: () = memory.invoke_tvm_op(%297, %298, %299) /* ty=() */;
let %x28: Tensor[(1, 512), float32] = %tensor_028;
let %storage_029: Storage[] = %region0;
let %tensor_029: Tensor[(1, 1000), float32] = memory.alloc_tensor(%region0, %offset29, meta[relay.Constant][88] /* ty=Tensor[(2), int64] */ /* ty=Tensor[(2), int64] */, meta[relay.attrs.AllocTensorAttrs][29]) /* ty=Tensor[(1, 1000), float32] */;
let %const59: Tensor[(1000, 512), float32] = meta[relay.Constant][89] /* ty=Tensor[(1000, 512), float32] */ /* ty=Tensor[(1000, 512), float32] */;
let %const60: Tensor[(1000), float32] = meta[relay.Constant][90] /* ty=Tensor[(1000), float32] */ /* ty=Tensor[(1000), float32] */;
%301 = fn (%p029: Tensor[(1, 512), float32], %p127: Tensor[(1000, 512), float32], %p223: Tensor[(1000), float32], Primitive=1) -> Tensor[(1, 1000), float32] {
%300 = nn.dense(%p029, %p127, units=1000) /* ty=Tensor[(1, 1000), float32] */;
nn.bias_add(%300, %p223, axis=-1) /* ty=Tensor[(1, 1000), float32] */
};
%302 = (%x28, %const59, %const60);
%303 = (%tensor_029,);
let %v29: () = memory.invoke_tvm_op(%301, %302, %303) /* ty=() */;
let %x29: Tensor[(1, 1000), float32] = %tensor_029;
let %storage_030: Storage[] = %region0;
let %tensor_030: Tensor[(1, 1000), float32] = memory.alloc_tensor(%region0, %offset30, meta[relay.Constant][91] /* ty=Tensor[(2), int64] */ /* ty=Tensor[(2), int64] */, meta[relay.attrs.AllocTensorAttrs][30]) /* ty=Tensor[(1, 1000), float32] */;
%304 = fn (%p030: Tensor[(1, 1000), float32], Primitive=1) -> Tensor[(1, 1000), float32] {
nn.softmax(%p030) /* ty=Tensor[(1, 1000), float32] */
};
%305 = (%x29,);
%306 = (%tensor_030,);
let %v30: () = memory.invoke_tvm_op(%304, %305, %306) /* ty=() */;
let %x30: Tensor[(1, 1000), float32] = %tensor_030;
%x30
}
// meta data omitted. you can use show_meta_data=True to include meta data
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment