API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Mar 22nd, 2019
187
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 65.81 KB | None | 0 0
raw download clone embed print report
  1. v0.0.1
  2. %660 = fn (%data: Tensor[(1, 3, 299, 299), float32]) -> Tensor[(1, 1000), float32] {
  3. %1 = fn (%p0: Tensor[(1, 1000), float32], __dict__=meta[StrMap][0]) -> Tensor[(1, 1000), float32] {
  4. %0 = nn.softmax(%p0)
  5. %0
  6. }
  7. %4 = fn (%p01: Tensor[(1, 2048), float32], %p1: Tensor[(1000, 2048), float32], %p2: Tensor[(1000,), float32], __dict__=meta[StrMap][1]) -> Tensor[(1, 1000), float32] {
  8. %2 = nn.dense(%p01, %p1, units=1000)
  9. %3 = nn.bias_add(%2, %p2)
  10. %3
  11. }
  12. %6 = fn (%p02: Tensor[(1, 2048, 1, 1), float32], __dict__=meta[StrMap][2]) -> Tensor[(1, 2048), float32] {
  13. %5 = nn.batch_flatten(%p02)
  14. %5
  15. }
  16. %8 = fn (%p03: Tensor[(1, 2048, 8, 8), float32], __dict__=meta[StrMap][3]) -> Tensor[(1, 2048, 1, 1), float32] {
  17. %7 = nn.avg_pool2d(%p03, pool_size=[8, 8], count_include_pad=True)
  18. %7
  19. }
  20. %11 = fn (%p04: Tensor[(1, 320, 8, 8), float32], %p11: Tensor[(1, 384, 8, 8), float32], %p21: Tensor[(1, 384, 8, 8), float32], %p3: Tensor[(1, 384, 8, 8), float32], %p4: Tensor[(1, 384, 8, 8), float32], %p5: Tensor[(1, 192, 8, 8), float32], __dict__=meta[StrMap][4]) -> Tensor[(1, 2048, 8, 8), float32] {
  21. %9 = (%p04, %p11, %p21, %p3, %p4, %p5)
  22. %10 = concatenate(%9, axis=1)
  23. %10
  24. }
  25. %16 = fn (%p05: Tensor[(1, 2048, 8, 8), float32], %p12: Tensor[(320, 2048, 1, 1), float32], %p22: Tensor[(320, 1, 1), float32], %p31: Tensor[(320, 1, 1), float32], __dict__=meta[StrMap][5]) -> Tensor[(1, 320, 8, 8), float32] {
  26. %12 = nn.conv2d(%p05, %p12, channels=320, kernel_size=[1, 1])
  27. %13 = multiply(%12, %p22)
  28. %14 = add(%13, %p31)
  29. %15 = nn.relu(%14)
  30. %15
  31. }
  32. %19 = fn (%p06: Tensor[(1, 320, 8, 8), float32], %p13: Tensor[(1, 384, 8, 8), float32], %p23: Tensor[(1, 384, 8, 8), float32], %p32: Tensor[(1, 384, 8, 8), float32], %p41: Tensor[(1, 384, 8, 8), float32], %p51: Tensor[(1, 192, 8, 8), float32], __dict__=meta[StrMap][6]) -> Tensor[(1, 2048, 8, 8), float32] {
  33. %17 = (%p06, %p13, %p23, %p32, %p41, %p51)
  34. %18 = concatenate(%17, axis=1)
  35. %18
  36. }
  37. %24 = fn (%p07: Tensor[(1, 1280, 8, 8), float32], %p14: Tensor[(320, 1280, 1, 1), float32], %p24: Tensor[(320, 1, 1), float32], %p33: Tensor[(320, 1, 1), float32], __dict__=meta[StrMap][7]) -> Tensor[(1, 320, 8, 8), float32] {
  38. %20 = nn.conv2d(%p07, %p14, channels=320, kernel_size=[1, 1])
  39. %21 = multiply(%20, %p24)
  40. %22 = add(%21, %p33)
  41. %23 = nn.relu(%22)
  42. %23
  43. }
  44. %27 = fn (%p08: Tensor[(1, 320, 8, 8), float32], %p15: Tensor[(1, 192, 8, 8), float32], %p25: Tensor[(1, 768, 8, 8), float32], __dict__=meta[StrMap][8]) -> Tensor[(1, 1280, 8, 8), float32] {
  45. %25 = (%p08, %p15, %p25)
  46. %26 = concatenate(%25, axis=1)
  47. %26
  48. }
  49. %32 = fn (%p09: Tensor[(1, 192, 17, 17), float32], %p16: Tensor[(320, 192, 3, 3), float32], %p26: Tensor[(320, 1, 1), float32], %p34: Tensor[(320, 1, 1), float32], __dict__=meta[StrMap][9]) -> Tensor[(1, 320, 8, 8), float32] {
  50. %28 = nn.conv2d(%p09, %p16, strides=[2, 2], channels=320, kernel_size=[3, 3])
  51. %29 = multiply(%28, %p26)
  52. %30 = add(%29, %p34)
  53. %31 = nn.relu(%30)
  54. %31
  55. }
  56. %37 = fn (%p010: Tensor[(1, 768, 17, 17), float32], %p17: Tensor[(192, 768, 1, 1), float32], %p27: Tensor[(192, 1, 1), float32], %p35: Tensor[(192, 1, 1), float32], __dict__=meta[StrMap][10]) -> Tensor[(1, 192, 17, 17), float32] {
  57. %33 = nn.conv2d(%p010, %p17, channels=192, kernel_size=[1, 1])
  58. %34 = multiply(%33, %p27)
  59. %35 = add(%34, %p35)
  60. %36 = nn.relu(%35)
  61. %36
  62. }
  63. %40 = fn (%p011: Tensor[(1, 192, 17, 17), float32], %p18: Tensor[(1, 192, 17, 17), float32], %p28: Tensor[(1, 192, 17, 17), float32], %p36: Tensor[(1, 192, 17, 17), float32], __dict__=meta[StrMap][11]) -> Tensor[(1, 768, 17, 17), float32] {
  64. %38 = (%p011, %p18, %p28, %p36)
  65. %39 = concatenate(%38, axis=1)
  66. %39
  67. }
  68. %45 = fn (%p012: Tensor[(1, 768, 17, 17), float32], %p19: Tensor[(192, 768, 1, 1), float32], %p29: Tensor[(192, 1, 1), float32], %p37: Tensor[(192, 1, 1), float32], __dict__=meta[StrMap][12]) -> Tensor[(1, 192, 17, 17), float32] {
  69. %41 = nn.conv2d(%p012, %p19, channels=192, kernel_size=[1, 1])
  70. %42 = multiply(%41, %p29)
  71. %43 = add(%42, %p37)
  72. %44 = nn.relu(%43)
  73. %44
  74. }
  75. %48 = fn (%p013: Tensor[(1, 192, 17, 17), float32], %p110: Tensor[(1, 192, 17, 17), float32], %p210: Tensor[(1, 192, 17, 17), float32], %p38: Tensor[(1, 192, 17, 17), float32], __dict__=meta[StrMap][13]) -> Tensor[(1, 768, 17, 17), float32] {
  76. %46 = (%p013, %p110, %p210, %p38)
  77. %47 = concatenate(%46, axis=1)
  78. %47
  79. }
  80. %53 = fn (%p014: Tensor[(1, 768, 17, 17), float32], %p111: Tensor[(192, 768, 1, 1), float32], %p211: Tensor[(192, 1, 1), float32], %p39: Tensor[(192, 1, 1), float32], __dict__=meta[StrMap][14]) -> Tensor[(1, 192, 17, 17), float32] {
  81. %49 = nn.conv2d(%p014, %p111, channels=192, kernel_size=[1, 1])
  82. %50 = multiply(%49, %p211)
  83. %51 = add(%50, %p39)
  84. %52 = nn.relu(%51)
  85. %52
  86. }
  87. %56 = fn (%p015: Tensor[(1, 192, 17, 17), float32], %p112: Tensor[(1, 192, 17, 17), float32], %p212: Tensor[(1, 192, 17, 17), float32], %p310: Tensor[(1, 192, 17, 17), float32], __dict__=meta[StrMap][15]) -> Tensor[(1, 768, 17, 17), float32] {
  88. %54 = (%p015, %p112, %p212, %p310)
  89. %55 = concatenate(%54, axis=1)
  90. %55
  91. }
  92. %61 = fn (%p016: Tensor[(1, 768, 17, 17), float32], %p113: Tensor[(192, 768, 1, 1), float32], %p213: Tensor[(192, 1, 1), float32], %p311: Tensor[(192, 1, 1), float32], __dict__=meta[StrMap][16]) -> Tensor[(1, 192, 17, 17), float32] {
  93. %57 = nn.conv2d(%p016, %p113, channels=192, kernel_size=[1, 1])
  94. %58 = multiply(%57, %p213)
  95. %59 = add(%58, %p311)
  96. %60 = nn.relu(%59)
  97. %60
  98. }
  99. %64 = fn (%p017: Tensor[(1, 192, 17, 17), float32], %p114: Tensor[(1, 192, 17, 17), float32], %p214: Tensor[(1, 192, 17, 17), float32], %p312: Tensor[(1, 192, 17, 17), float32], __dict__=meta[StrMap][17]) -> Tensor[(1, 768, 17, 17), float32] {
  100. %62 = (%p017, %p114, %p214, %p312)
  101. %63 = concatenate(%62, axis=1)
  102. %63
  103. }
  104. %69 = fn (%p018: Tensor[(1, 768, 17, 17), float32], %p115: Tensor[(192, 768, 1, 1), float32], %p215: Tensor[(192, 1, 1), float32], %p313: Tensor[(192, 1, 1), float32], __dict__=meta[StrMap][18]) -> Tensor[(1, 192, 17, 17), float32] {
  105. %65 = nn.conv2d(%p018, %p115, channels=192, kernel_size=[1, 1])
  106. %66 = multiply(%65, %p215)
  107. %67 = add(%66, %p313)
  108. %68 = nn.relu(%67)
  109. %68
  110. }
  111. %72 = fn (%p019: Tensor[(1, 384, 17, 17), float32], %p116: Tensor[(1, 96, 17, 17), float32], %p216: Tensor[(1, 288, 17, 17), float32], __dict__=meta[StrMap][19]) -> Tensor[(1, 768, 17, 17), float32] {
  112. %70 = (%p019, %p116, %p216)
  113. %71 = concatenate(%70, axis=1)
  114. %71
  115. }
  116. %77 = fn (%p020: Tensor[(1, 288, 35, 35), float32], %p117: Tensor[(384, 288, 3, 3), float32], %p217: Tensor[(384, 1, 1), float32], %p314: Tensor[(384, 1, 1), float32], __dict__=meta[StrMap][20]) -> Tensor[(1, 384, 17, 17), float32] {
  117. %73 = nn.conv2d(%p020, %p117, strides=[2, 2], channels=384, kernel_size=[3, 3])
  118. %74 = multiply(%73, %p217)
  119. %75 = add(%74, %p314)
  120. %76 = nn.relu(%75)
  121. %76
  122. }
  123. %80 = fn (%p021: Tensor[(1, 64, 35, 35), float32], %p118: Tensor[(1, 64, 35, 35), float32], %p218: Tensor[(1, 96, 35, 35), float32], %p315: Tensor[(1, 64, 35, 35), float32], __dict__=meta[StrMap][21]) -> Tensor[(1, 288, 35, 35), float32] {
  124. %78 = (%p021, %p118, %p218, %p315)
  125. %79 = concatenate(%78, axis=1)
  126. %79
  127. }
  128. %85 = fn (%p022: Tensor[(1, 288, 35, 35), float32], %p119: Tensor[(64, 288, 1, 1), float32], %p219: Tensor[(64, 1, 1), float32], %p316: Tensor[(64, 1, 1), float32], __dict__=meta[StrMap][22]) -> Tensor[(1, 64, 35, 35), float32] {
  129. %81 = nn.conv2d(%p022, %p119, channels=64, kernel_size=[1, 1])
  130. %82 = multiply(%81, %p219)
  131. %83 = add(%82, %p316)
  132. %84 = nn.relu(%83)
  133. %84
  134. }
  135. %88 = fn (%p023: Tensor[(1, 64, 35, 35), float32], %p120: Tensor[(1, 64, 35, 35), float32], %p220: Tensor[(1, 96, 35, 35), float32], %p317: Tensor[(1, 64, 35, 35), float32], __dict__=meta[StrMap][23]) -> Tensor[(1, 288, 35, 35), float32] {
  136. %86 = (%p023, %p120, %p220, %p317)
  137. %87 = concatenate(%86, axis=1)
  138. %87
  139. }
  140. %93 = fn (%p024: Tensor[(1, 256, 35, 35), float32], %p121: Tensor[(64, 256, 1, 1), float32], %p221: Tensor[(64, 1, 1), float32], %p318: Tensor[(64, 1, 1), float32], __dict__=meta[StrMap][24]) -> Tensor[(1, 64, 35, 35), float32] {
  141. %89 = nn.conv2d(%p024, %p121, channels=64, kernel_size=[1, 1])
  142. %90 = multiply(%89, %p221)
  143. %91 = add(%90, %p318)
  144. %92 = nn.relu(%91)
  145. %92
  146. }
  147. %96 = fn (%p025: Tensor[(1, 64, 35, 35), float32], %p122: Tensor[(1, 64, 35, 35), float32], %p222: Tensor[(1, 96, 35, 35), float32], %p319: Tensor[(1, 32, 35, 35), float32], __dict__=meta[StrMap][25]) -> Tensor[(1, 256, 35, 35), float32] {
  148. %94 = (%p025, %p122, %p222, %p319)
  149. %95 = concatenate(%94, axis=1)
  150. %95
  151. }
  152. %101 = fn (%p026: Tensor[(1, 192, 35, 35), float32], %p123: Tensor[(64, 192, 1, 1), float32], %p223: Tensor[(64, 1, 1), float32], %p320: Tensor[(64, 1, 1), float32], __dict__=meta[StrMap][26]) -> Tensor[(1, 64, 35, 35), float32] {
  153. %97 = nn.conv2d(%p026, %p123, channels=64, kernel_size=[1, 1])
  154. %98 = multiply(%97, %p223)
  155. %99 = add(%98, %p320)
  156. %100 = nn.relu(%99)
  157. %100
  158. }
  159. %103 = fn (%p027: Tensor[(1, 192, 71, 71), float32], __dict__=meta[StrMap][27]) -> Tensor[(1, 192, 35, 35), float32] {
  160. %102 = nn.max_pool2d(%p027, pool_size=[3, 3], strides=[2, 2])
  161. %102
  162. }
  163. %108 = fn (%p028: Tensor[(1, 80, 73, 73), float32], %p124: Tensor[(192, 80, 3, 3), float32], %p224: Tensor[(192, 1, 1), float32], %p321: Tensor[(192, 1, 1), float32], __dict__=meta[StrMap][28]) -> Tensor[(1, 192, 71, 71), float32] {
  164. %104 = nn.conv2d(%p028, %p124, channels=192, kernel_size=[3, 3])
  165. %105 = multiply(%104, %p224)
  166. %106 = add(%105, %p321)
  167. %107 = nn.relu(%106)
  168. %107
  169. }
  170. %113 = fn (%p029: Tensor[(1, 64, 73, 73), float32], %p125: Tensor[(80, 64, 1, 1), float32], %p225: Tensor[(80, 1, 1), float32], %p322: Tensor[(80, 1, 1), float32], __dict__=meta[StrMap][29]) -> Tensor[(1, 80, 73, 73), float32] {
  171. %109 = nn.conv2d(%p029, %p125, channels=80, kernel_size=[1, 1])
  172. %110 = multiply(%109, %p225)
  173. %111 = add(%110, %p322)
  174. %112 = nn.relu(%111)
  175. %112
  176. }
  177. %115 = fn (%p030: Tensor[(1, 64, 147, 147), float32], __dict__=meta[StrMap][30]) -> Tensor[(1, 64, 73, 73), float32] {
  178. %114 = nn.max_pool2d(%p030, pool_size=[3, 3], strides=[2, 2])
  179. %114
  180. }
  181. %120 = fn (%p031: Tensor[(1, 32, 147, 147), float32], %p126: Tensor[(64, 32, 3, 3), float32], %p226: Tensor[(64, 1, 1), float32], %p323: Tensor[(64, 1, 1), float32], __dict__=meta[StrMap][31]) -> Tensor[(1, 64, 147, 147), float32] {
  182. %116 = nn.conv2d(%p031, %p126, padding=[1, 1], channels=64, kernel_size=[3, 3])
  183. %117 = multiply(%116, %p226)
  184. %118 = add(%117, %p323)
  185. %119 = nn.relu(%118)
  186. %119
  187. }
  188. %125 = fn (%p032: Tensor[(1, 32, 149, 149), float32], %p127: Tensor[(32, 32, 3, 3), float32], %p227: Tensor[(32, 1, 1), float32], %p324: Tensor[(32, 1, 1), float32], __dict__=meta[StrMap][32]) -> Tensor[(1, 32, 147, 147), float32] {
  189. %121 = nn.conv2d(%p032, %p127, channels=32, kernel_size=[3, 3])
  190. %122 = multiply(%121, %p227)
  191. %123 = add(%122, %p324)
  192. %124 = nn.relu(%123)
  193. %124
  194. }
  195. %130 = fn (%p033: Tensor[(1, 3, 299, 299), float32], %p128: Tensor[(32, 3, 3, 3), float32], %p228: Tensor[(32, 1, 1), float32], %p325: Tensor[(32, 1, 1), float32], __dict__=meta[StrMap][33]) -> Tensor[(1, 32, 149, 149), float32] {
  196. %126 = nn.conv2d(%p033, %p128, strides=[2, 2], channels=32, kernel_size=[3, 3])
  197. %127 = multiply(%126, %p228)
  198. %128 = add(%127, %p325)
  199. %129 = nn.relu(%128)
  200. %129
  201. }
  202. %131 = %130(%data, meta[relay.Constant][0] // ty=Tensor[(32, 3, 3, 3), float32], meta[relay.Constant][1] // ty=Tensor[(32, 1, 1), float32], meta[relay.Constant][2] // ty=Tensor[(32, 1, 1), float32])
  203. %132 = %125(%131, meta[relay.Constant][3] // ty=Tensor[(32, 32, 3, 3), float32], meta[relay.Constant][4] // ty=Tensor[(32, 1, 1), float32], meta[relay.Constant][5] // ty=Tensor[(32, 1, 1), float32])
  204. %133 = %120(%132, meta[relay.Constant][6] // ty=Tensor[(64, 32, 3, 3), float32], meta[relay.Constant][7] // ty=Tensor[(64, 1, 1), float32], meta[relay.Constant][8] // ty=Tensor[(64, 1, 1), float32])
  205. %134 = %115(%133)
  206. %135 = %113(%134, meta[relay.Constant][9] // ty=Tensor[(80, 64, 1, 1), float32], meta[relay.Constant][10] // ty=Tensor[(80, 1, 1), float32], meta[relay.Constant][11] // ty=Tensor[(80, 1, 1), float32])
  207. %136 = %108(%135, meta[relay.Constant][12] // ty=Tensor[(192, 80, 3, 3), float32], meta[relay.Constant][13] // ty=Tensor[(192, 1, 1), float32], meta[relay.Constant][14] // ty=Tensor[(192, 1, 1), float32])
  208. %137 = %103(%136)
  209. %138 = %101(%137, meta[relay.Constant][15] // ty=Tensor[(64, 192, 1, 1), float32], meta[relay.Constant][16] // ty=Tensor[(64, 1, 1), float32], meta[relay.Constant][17] // ty=Tensor[(64, 1, 1), float32])
  210. %143 = fn (%p034: Tensor[(1, 48, 35, 35), float32], %p129: Tensor[(64, 48, 5, 5), float32], %p229: Tensor[(64, 1, 1), float32], %p326: Tensor[(64, 1, 1), float32], __dict__=meta[StrMap][34]) -> Tensor[(1, 64, 35, 35), float32] {
  211. %139 = nn.conv2d(%p034, %p129, padding=[2, 2], channels=64, kernel_size=[5, 5])
  212. %140 = multiply(%139, %p229)
  213. %141 = add(%140, %p326)
  214. %142 = nn.relu(%141)
  215. %142
  216. }
  217. %148 = fn (%p035: Tensor[(1, 192, 35, 35), float32], %p130: Tensor[(48, 192, 1, 1), float32], %p230: Tensor[(48, 1, 1), float32], %p327: Tensor[(48, 1, 1), float32], __dict__=meta[StrMap][35]) -> Tensor[(1, 48, 35, 35), float32] {
  218. %144 = nn.conv2d(%p035, %p130, channels=48, kernel_size=[1, 1])
  219. %145 = multiply(%144, %p230)
  220. %146 = add(%145, %p327)
  221. %147 = nn.relu(%146)
  222. %147
  223. }
  224. %149 = %148(%137, meta[relay.Constant][18] // ty=Tensor[(48, 192, 1, 1), float32], meta[relay.Constant][19] // ty=Tensor[(48, 1, 1), float32], meta[relay.Constant][20] // ty=Tensor[(48, 1, 1), float32])
  225. %150 = %143(%149, meta[relay.Constant][21] // ty=Tensor[(64, 48, 5, 5), float32], meta[relay.Constant][22] // ty=Tensor[(64, 1, 1), float32], meta[relay.Constant][23] // ty=Tensor[(64, 1, 1), float32])
  226. %155 = fn (%p036: Tensor[(1, 96, 35, 35), float32], %p131: Tensor[(96, 96, 3, 3), float32], %p231: Tensor[(96, 1, 1), float32], %p328: Tensor[(96, 1, 1), float32], __dict__=meta[StrMap][36]) -> Tensor[(1, 96, 35, 35), float32] {
  227. %151 = nn.conv2d(%p036, %p131, padding=[1, 1], channels=96, kernel_size=[3, 3])
  228. %152 = multiply(%151, %p231)
  229. %153 = add(%152, %p328)
  230. %154 = nn.relu(%153)
  231. %154
  232. }
  233. %160 = fn (%p037: Tensor[(1, 64, 35, 35), float32], %p132: Tensor[(96, 64, 3, 3), float32], %p232: Tensor[(96, 1, 1), float32], %p329: Tensor[(96, 1, 1), float32], __dict__=meta[StrMap][37]) -> Tensor[(1, 96, 35, 35), float32] {
  234. %156 = nn.conv2d(%p037, %p132, padding=[1, 1], channels=96, kernel_size=[3, 3])
  235. %157 = multiply(%156, %p232)
  236. %158 = add(%157, %p329)
  237. %159 = nn.relu(%158)
  238. %159
  239. }
  240. %165 = fn (%p038: Tensor[(1, 192, 35, 35), float32], %p133: Tensor[(64, 192, 1, 1), float32], %p233: Tensor[(64, 1, 1), float32], %p330: Tensor[(64, 1, 1), float32], __dict__=meta[StrMap][38]) -> Tensor[(1, 64, 35, 35), float32] {
  241. %161 = nn.conv2d(%p038, %p133, channels=64, kernel_size=[1, 1])
  242. %162 = multiply(%161, %p233)
  243. %163 = add(%162, %p330)
  244. %164 = nn.relu(%163)
  245. %164
  246. }
  247. %166 = %165(%137, meta[relay.Constant][24] // ty=Tensor[(64, 192, 1, 1), float32], meta[relay.Constant][25] // ty=Tensor[(64, 1, 1), float32], meta[relay.Constant][26] // ty=Tensor[(64, 1, 1), float32])
  248. %167 = %160(%166, meta[relay.Constant][27] // ty=Tensor[(96, 64, 3, 3), float32], meta[relay.Constant][28] // ty=Tensor[(96, 1, 1), float32], meta[relay.Constant][29] // ty=Tensor[(96, 1, 1), float32])
  249. %168 = %155(%167, meta[relay.Constant][30] // ty=Tensor[(96, 96, 3, 3), float32], meta[relay.Constant][31] // ty=Tensor[(96, 1, 1), float32], meta[relay.Constant][32] // ty=Tensor[(96, 1, 1), float32])
  250. %173 = fn (%p039: Tensor[(1, 192, 35, 35), float32], %p134: Tensor[(32, 192, 1, 1), float32], %p234: Tensor[(32, 1, 1), float32], %p331: Tensor[(32, 1, 1), float32], __dict__=meta[StrMap][39]) -> Tensor[(1, 32, 35, 35), float32] {
  251. %169 = nn.conv2d(%p039, %p134, channels=32, kernel_size=[1, 1])
  252. %170 = multiply(%169, %p234)
  253. %171 = add(%170, %p331)
  254. %172 = nn.relu(%171)
  255. %172
  256. }
  257. %175 = fn (%p040: Tensor[(1, 192, 35, 35), float32], __dict__=meta[StrMap][40]) -> Tensor[(1, 192, 35, 35), float32] {
  258. %174 = nn.avg_pool2d(%p040, pool_size=[3, 3], padding=[1, 1], count_include_pad=True)
  259. %174
  260. }
  261. %176 = %175(%137)
  262. %177 = %173(%176, meta[relay.Constant][33] // ty=Tensor[(32, 192, 1, 1), float32], meta[relay.Constant][34] // ty=Tensor[(32, 1, 1), float32], meta[relay.Constant][35] // ty=Tensor[(32, 1, 1), float32])
  263. %178 = %96(%138, %150, %168, %177)
  264. %179 = %93(%178, meta[relay.Constant][36] // ty=Tensor[(64, 256, 1, 1), float32], meta[relay.Constant][37] // ty=Tensor[(64, 1, 1), float32], meta[relay.Constant][38] // ty=Tensor[(64, 1, 1), float32])
  265. %184 = fn (%p041: Tensor[(1, 48, 35, 35), float32], %p135: Tensor[(64, 48, 5, 5), float32], %p235: Tensor[(64, 1, 1), float32], %p332: Tensor[(64, 1, 1), float32], __dict__=meta[StrMap][41]) -> Tensor[(1, 64, 35, 35), float32] {
  266. %180 = nn.conv2d(%p041, %p135, padding=[2, 2], channels=64, kernel_size=[5, 5])
  267. %181 = multiply(%180, %p235)
  268. %182 = add(%181, %p332)
  269. %183 = nn.relu(%182)
  270. %183
  271. }
  272. %189 = fn (%p042: Tensor[(1, 256, 35, 35), float32], %p136: Tensor[(48, 256, 1, 1), float32], %p236: Tensor[(48, 1, 1), float32], %p333: Tensor[(48, 1, 1), float32], __dict__=meta[StrMap][42]) -> Tensor[(1, 48, 35, 35), float32] {
  273. %185 = nn.conv2d(%p042, %p136, channels=48, kernel_size=[1, 1])
  274. %186 = multiply(%185, %p236)
  275. %187 = add(%186, %p333)
  276. %188 = nn.relu(%187)
  277. %188
  278. }
  279. %190 = %189(%178, meta[relay.Constant][39] // ty=Tensor[(48, 256, 1, 1), float32], meta[relay.Constant][40] // ty=Tensor[(48, 1, 1), float32], meta[relay.Constant][41] // ty=Tensor[(48, 1, 1), float32])
  280. %191 = %184(%190, meta[relay.Constant][42] // ty=Tensor[(64, 48, 5, 5), float32], meta[relay.Constant][43] // ty=Tensor[(64, 1, 1), float32], meta[relay.Constant][44] // ty=Tensor[(64, 1, 1), float32])
  281. %196 = fn (%p043: Tensor[(1, 96, 35, 35), float32], %p137: Tensor[(96, 96, 3, 3), float32], %p237: Tensor[(96, 1, 1), float32], %p334: Tensor[(96, 1, 1), float32], __dict__=meta[StrMap][43]) -> Tensor[(1, 96, 35, 35), float32] {
  282. %192 = nn.conv2d(%p043, %p137, padding=[1, 1], channels=96, kernel_size=[3, 3])
  283. %193 = multiply(%192, %p237)
  284. %194 = add(%193, %p334)
  285. %195 = nn.relu(%194)
  286. %195
  287. }
  288. %201 = fn (%p044: Tensor[(1, 64, 35, 35), float32], %p138: Tensor[(96, 64, 3, 3), float32], %p238: Tensor[(96, 1, 1), float32], %p335: Tensor[(96, 1, 1), float32], __dict__=meta[StrMap][44]) -> Tensor[(1, 96, 35, 35), float32] {
  289. %197 = nn.conv2d(%p044, %p138, padding=[1, 1], channels=96, kernel_size=[3, 3])
  290. %198 = multiply(%197, %p238)
  291. %199 = add(%198, %p335)
  292. %200 = nn.relu(%199)
  293. %200
  294. }
  295. %206 = fn (%p045: Tensor[(1, 256, 35, 35), float32], %p139: Tensor[(64, 256, 1, 1), float32], %p239: Tensor[(64, 1, 1), float32], %p336: Tensor[(64, 1, 1), float32], __dict__=meta[StrMap][45]) -> Tensor[(1, 64, 35, 35), float32] {
  296. %202 = nn.conv2d(%p045, %p139, channels=64, kernel_size=[1, 1])
  297. %203 = multiply(%202, %p239)
  298. %204 = add(%203, %p336)
  299. %205 = nn.relu(%204)
  300. %205
  301. }
  302. %207 = %206(%178, meta[relay.Constant][45] // ty=Tensor[(64, 256, 1, 1), float32], meta[relay.Constant][46] // ty=Tensor[(64, 1, 1), float32], meta[relay.Constant][47] // ty=Tensor[(64, 1, 1), float32])
  303. %208 = %201(%207, meta[relay.Constant][48] // ty=Tensor[(96, 64, 3, 3), float32], meta[relay.Constant][49] // ty=Tensor[(96, 1, 1), float32], meta[relay.Constant][50] // ty=Tensor[(96, 1, 1), float32])
  304. %209 = %196(%208, meta[relay.Constant][51] // ty=Tensor[(96, 96, 3, 3), float32], meta[relay.Constant][52] // ty=Tensor[(96, 1, 1), float32], meta[relay.Constant][53] // ty=Tensor[(96, 1, 1), float32])
  305. %214 = fn (%p046: Tensor[(1, 256, 35, 35), float32], %p140: Tensor[(64, 256, 1, 1), float32], %p240: Tensor[(64, 1, 1), float32], %p337: Tensor[(64, 1, 1), float32], __dict__=meta[StrMap][46]) -> Tensor[(1, 64, 35, 35), float32] {
  306. %210 = nn.conv2d(%p046, %p140, channels=64, kernel_size=[1, 1])
  307. %211 = multiply(%210, %p240)
  308. %212 = add(%211, %p337)
  309. %213 = nn.relu(%212)
  310. %213
  311. }
  312. %216 = fn (%p047: Tensor[(1, 256, 35, 35), float32], __dict__=meta[StrMap][47]) -> Tensor[(1, 256, 35, 35), float32] {
  313. %215 = nn.avg_pool2d(%p047, pool_size=[3, 3], padding=[1, 1], count_include_pad=True)
  314. %215
  315. }
  316. %217 = %216(%178)
  317. %218 = %214(%217, meta[relay.Constant][54] // ty=Tensor[(64, 256, 1, 1), float32], meta[relay.Constant][55] // ty=Tensor[(64, 1, 1), float32], meta[relay.Constant][56] // ty=Tensor[(64, 1, 1), float32])
  318. %219 = %88(%179, %191, %209, %218)
  319. %220 = %85(%219, meta[relay.Constant][57] // ty=Tensor[(64, 288, 1, 1), float32], meta[relay.Constant][58] // ty=Tensor[(64, 1, 1), float32], meta[relay.Constant][59] // ty=Tensor[(64, 1, 1), float32])
  320. %225 = fn (%p048: Tensor[(1, 48, 35, 35), float32], %p141: Tensor[(64, 48, 5, 5), float32], %p241: Tensor[(64, 1, 1), float32], %p338: Tensor[(64, 1, 1), float32], __dict__=meta[StrMap][48]) -> Tensor[(1, 64, 35, 35), float32] {
  321. %221 = nn.conv2d(%p048, %p141, padding=[2, 2], channels=64, kernel_size=[5, 5])
  322. %222 = multiply(%221, %p241)
  323. %223 = add(%222, %p338)
  324. %224 = nn.relu(%223)
  325. %224
  326. }
  327. %230 = fn (%p049: Tensor[(1, 288, 35, 35), float32], %p142: Tensor[(48, 288, 1, 1), float32], %p242: Tensor[(48, 1, 1), float32], %p339: Tensor[(48, 1, 1), float32], __dict__=meta[StrMap][49]) -> Tensor[(1, 48, 35, 35), float32] {
  328. %226 = nn.conv2d(%p049, %p142, channels=48, kernel_size=[1, 1])
  329. %227 = multiply(%226, %p242)
  330. %228 = add(%227, %p339)
  331. %229 = nn.relu(%228)
  332. %229
  333. }
  334. %231 = %230(%219, meta[relay.Constant][60] // ty=Tensor[(48, 288, 1, 1), float32], meta[relay.Constant][61] // ty=Tensor[(48, 1, 1), float32], meta[relay.Constant][62] // ty=Tensor[(48, 1, 1), float32])
  335. %232 = %225(%231, meta[relay.Constant][63] // ty=Tensor[(64, 48, 5, 5), float32], meta[relay.Constant][64] // ty=Tensor[(64, 1, 1), float32], meta[relay.Constant][65] // ty=Tensor[(64, 1, 1), float32])
  336. %237 = fn (%p050: Tensor[(1, 96, 35, 35), float32], %p143: Tensor[(96, 96, 3, 3), float32], %p243: Tensor[(96, 1, 1), float32], %p340: Tensor[(96, 1, 1), float32], __dict__=meta[StrMap][50]) -> Tensor[(1, 96, 35, 35), float32] {
  337. %233 = nn.conv2d(%p050, %p143, padding=[1, 1], channels=96, kernel_size=[3, 3])
  338. %234 = multiply(%233, %p243)
  339. %235 = add(%234, %p340)
  340. %236 = nn.relu(%235)
  341. %236
  342. }
  343. %242 = fn (%p051: Tensor[(1, 64, 35, 35), float32], %p144: Tensor[(96, 64, 3, 3), float32], %p244: Tensor[(96, 1, 1), float32], %p341: Tensor[(96, 1, 1), float32], __dict__=meta[StrMap][51]) -> Tensor[(1, 96, 35, 35), float32] {
  344. %238 = nn.conv2d(%p051, %p144, padding=[1, 1], channels=96, kernel_size=[3, 3])
  345. %239 = multiply(%238, %p244)
  346. %240 = add(%239, %p341)
  347. %241 = nn.relu(%240)
  348. %241
  349. }
  350. %247 = fn (%p052: Tensor[(1, 288, 35, 35), float32], %p145: Tensor[(64, 288, 1, 1), float32], %p245: Tensor[(64, 1, 1), float32], %p342: Tensor[(64, 1, 1), float32], __dict__=meta[StrMap][52]) -> Tensor[(1, 64, 35, 35), float32] {
  351. %243 = nn.conv2d(%p052, %p145, channels=64, kernel_size=[1, 1])
  352. %244 = multiply(%243, %p245)
  353. %245 = add(%244, %p342)
  354. %246 = nn.relu(%245)
  355. %246
  356. }
  357. %248 = %247(%219, meta[relay.Constant][66] // ty=Tensor[(64, 288, 1, 1), float32], meta[relay.Constant][67] // ty=Tensor[(64, 1, 1), float32], meta[relay.Constant][68] // ty=Tensor[(64, 1, 1), float32])
  358. %249 = %242(%248, meta[relay.Constant][69] // ty=Tensor[(96, 64, 3, 3), float32], meta[relay.Constant][70] // ty=Tensor[(96, 1, 1), float32], meta[relay.Constant][71] // ty=Tensor[(96, 1, 1), float32])
  359. %250 = %237(%249, meta[relay.Constant][72] // ty=Tensor[(96, 96, 3, 3), float32], meta[relay.Constant][73] // ty=Tensor[(96, 1, 1), float32], meta[relay.Constant][74] // ty=Tensor[(96, 1, 1), float32])
  360. %255 = fn (%p053: Tensor[(1, 288, 35, 35), float32], %p146: Tensor[(64, 288, 1, 1), float32], %p246: Tensor[(64, 1, 1), float32], %p343: Tensor[(64, 1, 1), float32], __dict__=meta[StrMap][53]) -> Tensor[(1, 64, 35, 35), float32] {
  361. %251 = nn.conv2d(%p053, %p146, channels=64, kernel_size=[1, 1])
  362. %252 = multiply(%251, %p246)
  363. %253 = add(%252, %p343)
  364. %254 = nn.relu(%253)
  365. %254
  366. }
  367. %257 = fn (%p054: Tensor[(1, 288, 35, 35), float32], __dict__=meta[StrMap][54]) -> Tensor[(1, 288, 35, 35), float32] {
  368. %256 = nn.avg_pool2d(%p054, pool_size=[3, 3], padding=[1, 1], count_include_pad=True)
  369. %256
  370. }
  371. %258 = %257(%219)
  372. %259 = %255(%258, meta[relay.Constant][75] // ty=Tensor[(64, 288, 1, 1), float32], meta[relay.Constant][76] // ty=Tensor[(64, 1, 1), float32], meta[relay.Constant][77] // ty=Tensor[(64, 1, 1), float32])
  373. %260 = %80(%220, %232, %250, %259)
  374. %261 = %77(%260, meta[relay.Constant][78] // ty=Tensor[(384, 288, 3, 3), float32], meta[relay.Constant][79] // ty=Tensor[(384, 1, 1), float32], meta[relay.Constant][80] // ty=Tensor[(384, 1, 1), float32])
  375. %266 = fn (%p055: Tensor[(1, 96, 35, 35), float32], %p147: Tensor[(96, 96, 3, 3), float32], %p247: Tensor[(96, 1, 1), float32], %p344: Tensor[(96, 1, 1), float32], __dict__=meta[StrMap][55]) -> Tensor[(1, 96, 17, 17), float32] {
  376. %262 = nn.conv2d(%p055, %p147, strides=[2, 2], channels=96, kernel_size=[3, 3])
  377. %263 = multiply(%262, %p247)
  378. %264 = add(%263, %p344)
  379. %265 = nn.relu(%264)
  380. %265
  381. }
  382. %271 = fn (%p056: Tensor[(1, 64, 35, 35), float32], %p148: Tensor[(96, 64, 3, 3), float32], %p248: Tensor[(96, 1, 1), float32], %p345: Tensor[(96, 1, 1), float32], __dict__=meta[StrMap][56]) -> Tensor[(1, 96, 35, 35), float32] {
  383. %267 = nn.conv2d(%p056, %p148, padding=[1, 1], channels=96, kernel_size=[3, 3])
  384. %268 = multiply(%267, %p248)
  385. %269 = add(%268, %p345)
  386. %270 = nn.relu(%269)
  387. %270
  388. }
  389. %276 = fn (%p057: Tensor[(1, 288, 35, 35), float32], %p149: Tensor[(64, 288, 1, 1), float32], %p249: Tensor[(64, 1, 1), float32], %p346: Tensor[(64, 1, 1), float32], __dict__=meta[StrMap][57]) -> Tensor[(1, 64, 35, 35), float32] {
  390. %272 = nn.conv2d(%p057, %p149, channels=64, kernel_size=[1, 1])
  391. %273 = multiply(%272, %p249)
  392. %274 = add(%273, %p346)
  393. %275 = nn.relu(%274)
  394. %275
  395. }
  396. %277 = %276(%260, meta[relay.Constant][81] // ty=Tensor[(64, 288, 1, 1), float32], meta[relay.Constant][82] // ty=Tensor[(64, 1, 1), float32], meta[relay.Constant][83] // ty=Tensor[(64, 1, 1), float32])
  397. %278 = %271(%277, meta[relay.Constant][84] // ty=Tensor[(96, 64, 3, 3), float32], meta[relay.Constant][85] // ty=Tensor[(96, 1, 1), float32], meta[relay.Constant][86] // ty=Tensor[(96, 1, 1), float32])
  398. %279 = %266(%278, meta[relay.Constant][87] // ty=Tensor[(96, 96, 3, 3), float32], meta[relay.Constant][88] // ty=Tensor[(96, 1, 1), float32], meta[relay.Constant][89] // ty=Tensor[(96, 1, 1), float32])
  399. %281 = fn (%p058: Tensor[(1, 288, 35, 35), float32], __dict__=meta[StrMap][58]) -> Tensor[(1, 288, 17, 17), float32] {
  400. %280 = nn.max_pool2d(%p058, pool_size=[3, 3], strides=[2, 2])
  401. %280
  402. }
  403. %282 = %281(%260)
  404. %283 = %72(%261, %279, %282)
  405. %284 = %69(%283, meta[relay.Constant][90] // ty=Tensor[(192, 768, 1, 1), float32], meta[relay.Constant][91] // ty=Tensor[(192, 1, 1), float32], meta[relay.Constant][92] // ty=Tensor[(192, 1, 1), float32])
  406. %289 = fn (%p059: Tensor[(1, 128, 17, 17), float32], %p150: Tensor[(192, 128, 7, 1), float32], %p250: Tensor[(192, 1, 1), float32], %p347: Tensor[(192, 1, 1), float32], __dict__=meta[StrMap][59]) -> Tensor[(1, 192, 17, 17), float32] {
  407. %285 = nn.conv2d(%p059, %p150, padding=[3, 0], channels=192, kernel_size=[7, 1])
  408. %286 = multiply(%285, %p250)
  409. %287 = add(%286, %p347)
  410. %288 = nn.relu(%287)
  411. %288
  412. }
  413. %294 = fn (%p060: Tensor[(1, 128, 17, 17), float32], %p151: Tensor[(128, 128, 1, 7), float32], %p251: Tensor[(128, 1, 1), float32], %p348: Tensor[(128, 1, 1), float32], __dict__=meta[StrMap][60]) -> Tensor[(1, 128, 17, 17), float32] {
  414. %290 = nn.conv2d(%p060, %p151, padding=[0, 3], channels=128, kernel_size=[1, 7])
  415. %291 = multiply(%290, %p251)
  416. %292 = add(%291, %p348)
  417. %293 = nn.relu(%292)
  418. %293
  419. }
  420. %299 = fn (%p061: Tensor[(1, 768, 17, 17), float32], %p152: Tensor[(128, 768, 1, 1), float32], %p252: Tensor[(128, 1, 1), float32], %p349: Tensor[(128, 1, 1), float32], __dict__=meta[StrMap][61]) -> Tensor[(1, 128, 17, 17), float32] {
  421. %295 = nn.conv2d(%p061, %p152, channels=128, kernel_size=[1, 1])
  422. %296 = multiply(%295, %p252)
  423. %297 = add(%296, %p349)
  424. %298 = nn.relu(%297)
  425. %298
  426. }
  427. %300 = %299(%283, meta[relay.Constant][93] // ty=Tensor[(128, 768, 1, 1), float32], meta[relay.Constant][94] // ty=Tensor[(128, 1, 1), float32], meta[relay.Constant][95] // ty=Tensor[(128, 1, 1), float32])
  428. %301 = %294(%300, meta[relay.Constant][96] // ty=Tensor[(128, 128, 1, 7), float32], meta[relay.Constant][97] // ty=Tensor[(128, 1, 1), float32], meta[relay.Constant][98] // ty=Tensor[(128, 1, 1), float32])
  429. %302 = %289(%301, meta[relay.Constant][99] // ty=Tensor[(192, 128, 7, 1), float32], meta[relay.Constant][100] // ty=Tensor[(192, 1, 1), float32], meta[relay.Constant][101] // ty=Tensor[(192, 1, 1), float32])
  430. %307 = fn (%p062: Tensor[(1, 128, 17, 17), float32], %p153: Tensor[(192, 128, 1, 7), float32], %p253: Tensor[(192, 1, 1), float32], %p350: Tensor[(192, 1, 1), float32], __dict__=meta[StrMap][62]) -> Tensor[(1, 192, 17, 17), float32] {
  431. %303 = nn.conv2d(%p062, %p153, padding=[0, 3], channels=192, kernel_size=[1, 7])
  432. %304 = multiply(%303, %p253)
  433. %305 = add(%304, %p350)
  434. %306 = nn.relu(%305)
  435. %306
  436. }
  437. %312 = fn (%p063: Tensor[(1, 128, 17, 17), float32], %p154: Tensor[(128, 128, 7, 1), float32], %p254: Tensor[(128, 1, 1), float32], %p351: Tensor[(128, 1, 1), float32], __dict__=meta[StrMap][63]) -> Tensor[(1, 128, 17, 17), float32] {
  438. %308 = nn.conv2d(%p063, %p154, padding=[3, 0], channels=128, kernel_size=[7, 1])
  439. %309 = multiply(%308, %p254)
  440. %310 = add(%309, %p351)
  441. %311 = nn.relu(%310)
  442. %311
  443. }
  444. %317 = fn (%p064: Tensor[(1, 128, 17, 17), float32], %p155: Tensor[(128, 128, 1, 7), float32], %p255: Tensor[(128, 1, 1), float32], %p352: Tensor[(128, 1, 1), float32], __dict__=meta[StrMap][64]) -> Tensor[(1, 128, 17, 17), float32] {
  445. %313 = nn.conv2d(%p064, %p155, padding=[0, 3], channels=128, kernel_size=[1, 7])
  446. %314 = multiply(%313, %p255)
  447. %315 = add(%314, %p352)
  448. %316 = nn.relu(%315)
  449. %316
  450. }
  451. %322 = fn (%p065: Tensor[(1, 128, 17, 17), float32], %p156: Tensor[(128, 128, 7, 1), float32], %p256: Tensor[(128, 1, 1), float32], %p353: Tensor[(128, 1, 1), float32], __dict__=meta[StrMap][65]) -> Tensor[(1, 128, 17, 17), float32] {
  452. %318 = nn.conv2d(%p065, %p156, padding=[3, 0], channels=128, kernel_size=[7, 1])
  453. %319 = multiply(%318, %p256)
  454. %320 = add(%319, %p353)
  455. %321 = nn.relu(%320)
  456. %321
  457. }
  458. %327 = fn (%p066: Tensor[(1, 768, 17, 17), float32], %p157: Tensor[(128, 768, 1, 1), float32], %p257: Tensor[(128, 1, 1), float32], %p354: Tensor[(128, 1, 1), float32], __dict__=meta[StrMap][66]) -> Tensor[(1, 128, 17, 17), float32] {
  459. %323 = nn.conv2d(%p066, %p157, channels=128, kernel_size=[1, 1])
  460. %324 = multiply(%323, %p257)
  461. %325 = add(%324, %p354)
  462. %326 = nn.relu(%325)
  463. %326
  464. }
  465. %328 = %327(%283, meta[relay.Constant][102] // ty=Tensor[(128, 768, 1, 1), float32], meta[relay.Constant][103] // ty=Tensor[(128, 1, 1), float32], meta[relay.Constant][104] // ty=Tensor[(128, 1, 1), float32])
  466. %329 = %322(%328, meta[relay.Constant][105] // ty=Tensor[(128, 128, 7, 1), float32], meta[relay.Constant][106] // ty=Tensor[(128, 1, 1), float32], meta[relay.Constant][107] // ty=Tensor[(128, 1, 1), float32])
  467. %330 = %317(%329, meta[relay.Constant][108] // ty=Tensor[(128, 128, 1, 7), float32], meta[relay.Constant][109] // ty=Tensor[(128, 1, 1), float32], meta[relay.Constant][110] // ty=Tensor[(128, 1, 1), float32])
  468. %331 = %312(%330, meta[relay.Constant][111] // ty=Tensor[(128, 128, 7, 1), float32], meta[relay.Constant][112] // ty=Tensor[(128, 1, 1), float32], meta[relay.Constant][113] // ty=Tensor[(128, 1, 1), float32])
  469. %332 = %307(%331, meta[relay.Constant][114] // ty=Tensor[(192, 128, 1, 7), float32], meta[relay.Constant][115] // ty=Tensor[(192, 1, 1), float32], meta[relay.Constant][116] // ty=Tensor[(192, 1, 1), float32])
  470. %337 = fn (%p067: Tensor[(1, 768, 17, 17), float32], %p158: Tensor[(192, 768, 1, 1), float32], %p258: Tensor[(192, 1, 1), float32], %p355: Tensor[(192, 1, 1), float32], __dict__=meta[StrMap][67]) -> Tensor[(1, 192, 17, 17), float32] {
  471. %333 = nn.conv2d(%p067, %p158, channels=192, kernel_size=[1, 1])
  472. %334 = multiply(%333, %p258)
  473. %335 = add(%334, %p355)
  474. %336 = nn.relu(%335)
  475. %336
  476. }
  477. %339 = fn (%p068: Tensor[(1, 768, 17, 17), float32], __dict__=meta[StrMap][68]) -> Tensor[(1, 768, 17, 17), float32] {
  478. %338 = nn.avg_pool2d(%p068, pool_size=[3, 3], padding=[1, 1], count_include_pad=True)
  479. %338
  480. }
  481. %340 = %339(%283)
  482. %341 = %337(%340, meta[relay.Constant][117] // ty=Tensor[(192, 768, 1, 1), float32], meta[relay.Constant][118] // ty=Tensor[(192, 1, 1), float32], meta[relay.Constant][119] // ty=Tensor[(192, 1, 1), float32])
  483. %342 = %64(%284, %302, %332, %341)
  484. %343 = %61(%342, meta[relay.Constant][120] // ty=Tensor[(192, 768, 1, 1), float32], meta[relay.Constant][121] // ty=Tensor[(192, 1, 1), float32], meta[relay.Constant][122] // ty=Tensor[(192, 1, 1), float32])
  485. %348 = fn (%p069: Tensor[(1, 160, 17, 17), float32], %p159: Tensor[(192, 160, 7, 1), float32], %p259: Tensor[(192, 1, 1), float32], %p356: Tensor[(192, 1, 1), float32], __dict__=meta[StrMap][69]) -> Tensor[(1, 192, 17, 17), float32] {
  486. %344 = nn.conv2d(%p069, %p159, padding=[3, 0], channels=192, kernel_size=[7, 1])
  487. %345 = multiply(%344, %p259)
  488. %346 = add(%345, %p356)
  489. %347 = nn.relu(%346)
  490. %347
  491. }
  492. %353 = fn (%p070: Tensor[(1, 160, 17, 17), float32], %p160: Tensor[(160, 160, 1, 7), float32], %p260: Tensor[(160, 1, 1), float32], %p357: Tensor[(160, 1, 1), float32], __dict__=meta[StrMap][70]) -> Tensor[(1, 160, 17, 17), float32] {
  493. %349 = nn.conv2d(%p070, %p160, padding=[0, 3], channels=160, kernel_size=[1, 7])
  494. %350 = multiply(%349, %p260)
  495. %351 = add(%350, %p357)
  496. %352 = nn.relu(%351)
  497. %352
  498. }
  499. %358 = fn (%p071: Tensor[(1, 768, 17, 17), float32], %p161: Tensor[(160, 768, 1, 1), float32], %p261: Tensor[(160, 1, 1), float32], %p358: Tensor[(160, 1, 1), float32], __dict__=meta[StrMap][71]) -> Tensor[(1, 160, 17, 17), float32] {
  500. %354 = nn.conv2d(%p071, %p161, channels=160, kernel_size=[1, 1])
  501. %355 = multiply(%354, %p261)
  502. %356 = add(%355, %p358)
  503. %357 = nn.relu(%356)
  504. %357
  505. }
  506. %359 = %358(%342, meta[relay.Constant][123] // ty=Tensor[(160, 768, 1, 1), float32], meta[relay.Constant][124] // ty=Tensor[(160, 1, 1), float32], meta[relay.Constant][125] // ty=Tensor[(160, 1, 1), float32])
  507. %360 = %353(%359, meta[relay.Constant][126] // ty=Tensor[(160, 160, 1, 7), float32], meta[relay.Constant][127] // ty=Tensor[(160, 1, 1), float32], meta[relay.Constant][128] // ty=Tensor[(160, 1, 1), float32])
  508. %361 = %348(%360, meta[relay.Constant][129] // ty=Tensor[(192, 160, 7, 1), float32], meta[relay.Constant][130] // ty=Tensor[(192, 1, 1), float32], meta[relay.Constant][131] // ty=Tensor[(192, 1, 1), float32])
  509. %366 = fn (%p072: Tensor[(1, 160, 17, 17), float32], %p162: Tensor[(192, 160, 1, 7), float32], %p262: Tensor[(192, 1, 1), float32], %p359: Tensor[(192, 1, 1), float32], __dict__=meta[StrMap][72]) -> Tensor[(1, 192, 17, 17), float32] {
  510. %362 = nn.conv2d(%p072, %p162, padding=[0, 3], channels=192, kernel_size=[1, 7])
  511. %363 = multiply(%362, %p262)
  512. %364 = add(%363, %p359)
  513. %365 = nn.relu(%364)
  514. %365
  515. }
  516. %371 = fn (%p073: Tensor[(1, 160, 17, 17), float32], %p163: Tensor[(160, 160, 7, 1), float32], %p263: Tensor[(160, 1, 1), float32], %p360: Tensor[(160, 1, 1), float32], __dict__=meta[StrMap][73]) -> Tensor[(1, 160, 17, 17), float32] {
  517. %367 = nn.conv2d(%p073, %p163, padding=[3, 0], channels=160, kernel_size=[7, 1])
  518. %368 = multiply(%367, %p263)
  519. %369 = add(%368, %p360)
  520. %370 = nn.relu(%369)
  521. %370
  522. }
  523. %376 = fn (%p074: Tensor[(1, 160, 17, 17), float32], %p164: Tensor[(160, 160, 1, 7), float32], %p264: Tensor[(160, 1, 1), float32], %p361: Tensor[(160, 1, 1), float32], __dict__=meta[StrMap][74]) -> Tensor[(1, 160, 17, 17), float32] {
  524. %372 = nn.conv2d(%p074, %p164, padding=[0, 3], channels=160, kernel_size=[1, 7])
  525. %373 = multiply(%372, %p264)
  526. %374 = add(%373, %p361)
  527. %375 = nn.relu(%374)
  528. %375
  529. }
  530. %381 = fn (%p075: Tensor[(1, 160, 17, 17), float32], %p165: Tensor[(160, 160, 7, 1), float32], %p265: Tensor[(160, 1, 1), float32], %p362: Tensor[(160, 1, 1), float32], __dict__=meta[StrMap][75]) -> Tensor[(1, 160, 17, 17), float32] {
  531. %377 = nn.conv2d(%p075, %p165, padding=[3, 0], channels=160, kernel_size=[7, 1])
  532. %378 = multiply(%377, %p265)
  533. %379 = add(%378, %p362)
  534. %380 = nn.relu(%379)
  535. %380
  536. }
  537. %386 = fn (%p076: Tensor[(1, 768, 17, 17), float32], %p166: Tensor[(160, 768, 1, 1), float32], %p266: Tensor[(160, 1, 1), float32], %p363: Tensor[(160, 1, 1), float32], __dict__=meta[StrMap][76]) -> Tensor[(1, 160, 17, 17), float32] {
  538. %382 = nn.conv2d(%p076, %p166, channels=160, kernel_size=[1, 1])
  539. %383 = multiply(%382, %p266)
  540. %384 = add(%383, %p363)
  541. %385 = nn.relu(%384)
  542. %385
  543. }
  544. %387 = %386(%342, meta[relay.Constant][132] // ty=Tensor[(160, 768, 1, 1), float32], meta[relay.Constant][133] // ty=Tensor[(160, 1, 1), float32], meta[relay.Constant][134] // ty=Tensor[(160, 1, 1), float32])
  545. %388 = %381(%387, meta[relay.Constant][135] // ty=Tensor[(160, 160, 7, 1), float32], meta[relay.Constant][136] // ty=Tensor[(160, 1, 1), float32], meta[relay.Constant][137] // ty=Tensor[(160, 1, 1), float32])
  546. %389 = %376(%388, meta[relay.Constant][138] // ty=Tensor[(160, 160, 1, 7), float32], meta[relay.Constant][139] // ty=Tensor[(160, 1, 1), float32], meta[relay.Constant][140] // ty=Tensor[(160, 1, 1), float32])
  547. %390 = %371(%389, meta[relay.Constant][141] // ty=Tensor[(160, 160, 7, 1), float32], meta[relay.Constant][142] // ty=Tensor[(160, 1, 1), float32], meta[relay.Constant][143] // ty=Tensor[(160, 1, 1), float32])
  548. %391 = %366(%390, meta[relay.Constant][144] // ty=Tensor[(192, 160, 1, 7), float32], meta[relay.Constant][145] // ty=Tensor[(192, 1, 1), float32], meta[relay.Constant][146] // ty=Tensor[(192, 1, 1), float32])
  549. %396 = fn (%p077: Tensor[(1, 768, 17, 17), float32], %p167: Tensor[(192, 768, 1, 1), float32], %p267: Tensor[(192, 1, 1), float32], %p364: Tensor[(192, 1, 1), float32], __dict__=meta[StrMap][77]) -> Tensor[(1, 192, 17, 17), float32] {
  550. %392 = nn.conv2d(%p077, %p167, channels=192, kernel_size=[1, 1])
  551. %393 = multiply(%392, %p267)
  552. %394 = add(%393, %p364)
  553. %395 = nn.relu(%394)
  554. %395
  555. }
  556. %398 = fn (%p078: Tensor[(1, 768, 17, 17), float32], __dict__=meta[StrMap][78]) -> Tensor[(1, 768, 17, 17), float32] {
  557. %397 = nn.avg_pool2d(%p078, pool_size=[3, 3], padding=[1, 1], count_include_pad=True)
  558. %397
  559. }
  560. %399 = %398(%342)
  561. %400 = %396(%399, meta[relay.Constant][147] // ty=Tensor[(192, 768, 1, 1), float32], meta[relay.Constant][148] // ty=Tensor[(192, 1, 1), float32], meta[relay.Constant][149] // ty=Tensor[(192, 1, 1), float32])
  562. %401 = %56(%343, %361, %391, %400)
  563. %402 = %53(%401, meta[relay.Constant][150] // ty=Tensor[(192, 768, 1, 1), float32], meta[relay.Constant][151] // ty=Tensor[(192, 1, 1), float32], meta[relay.Constant][152] // ty=Tensor[(192, 1, 1), float32])
  564. %407 = fn (%p079: Tensor[(1, 160, 17, 17), float32], %p168: Tensor[(192, 160, 7, 1), float32], %p268: Tensor[(192, 1, 1), float32], %p365: Tensor[(192, 1, 1), float32], __dict__=meta[StrMap][79]) -> Tensor[(1, 192, 17, 17), float32] {
  565. %403 = nn.conv2d(%p079, %p168, padding=[3, 0], channels=192, kernel_size=[7, 1])
  566. %404 = multiply(%403, %p268)
  567. %405 = add(%404, %p365)
  568. %406 = nn.relu(%405)
  569. %406
  570. }
  571. %412 = fn (%p080: Tensor[(1, 160, 17, 17), float32], %p169: Tensor[(160, 160, 1, 7), float32], %p269: Tensor[(160, 1, 1), float32], %p366: Tensor[(160, 1, 1), float32], __dict__=meta[StrMap][80]) -> Tensor[(1, 160, 17, 17), float32] {
  572. %408 = nn.conv2d(%p080, %p169, padding=[0, 3], channels=160, kernel_size=[1, 7])
  573. %409 = multiply(%408, %p269)
  574. %410 = add(%409, %p366)
  575. %411 = nn.relu(%410)
  576. %411
  577. }
  578. %417 = fn (%p081: Tensor[(1, 768, 17, 17), float32], %p170: Tensor[(160, 768, 1, 1), float32], %p270: Tensor[(160, 1, 1), float32], %p367: Tensor[(160, 1, 1), float32], __dict__=meta[StrMap][81]) -> Tensor[(1, 160, 17, 17), float32] {
  579. %413 = nn.conv2d(%p081, %p170, channels=160, kernel_size=[1, 1])
  580. %414 = multiply(%413, %p270)
  581. %415 = add(%414, %p367)
  582. %416 = nn.relu(%415)
  583. %416
  584. }
  585. %418 = %417(%401, meta[relay.Constant][153] // ty=Tensor[(160, 768, 1, 1), float32], meta[relay.Constant][154] // ty=Tensor[(160, 1, 1), float32], meta[relay.Constant][155] // ty=Tensor[(160, 1, 1), float32])
  586. %419 = %412(%418, meta[relay.Constant][156] // ty=Tensor[(160, 160, 1, 7), float32], meta[relay.Constant][157] // ty=Tensor[(160, 1, 1), float32], meta[relay.Constant][158] // ty=Tensor[(160, 1, 1), float32])
  587. %420 = %407(%419, meta[relay.Constant][159] // ty=Tensor[(192, 160, 7, 1), float32], meta[relay.Constant][160] // ty=Tensor[(192, 1, 1), float32], meta[relay.Constant][161] // ty=Tensor[(192, 1, 1), float32])
  588. %425 = fn (%p082: Tensor[(1, 160, 17, 17), float32], %p171: Tensor[(192, 160, 1, 7), float32], %p271: Tensor[(192, 1, 1), float32], %p368: Tensor[(192, 1, 1), float32], __dict__=meta[StrMap][82]) -> Tensor[(1, 192, 17, 17), float32] {
  589. %421 = nn.conv2d(%p082, %p171, padding=[0, 3], channels=192, kernel_size=[1, 7])
  590. %422 = multiply(%421, %p271)
  591. %423 = add(%422, %p368)
  592. %424 = nn.relu(%423)
  593. %424
  594. }
  595. %430 = fn (%p083: Tensor[(1, 160, 17, 17), float32], %p172: Tensor[(160, 160, 7, 1), float32], %p272: Tensor[(160, 1, 1), float32], %p369: Tensor[(160, 1, 1), float32], __dict__=meta[StrMap][83]) -> Tensor[(1, 160, 17, 17), float32] {
  596. %426 = nn.conv2d(%p083, %p172, padding=[3, 0], channels=160, kernel_size=[7, 1])
  597. %427 = multiply(%426, %p272)
  598. %428 = add(%427, %p369)
  599. %429 = nn.relu(%428)
  600. %429
  601. }
  602. %435 = fn (%p084: Tensor[(1, 160, 17, 17), float32], %p173: Tensor[(160, 160, 1, 7), float32], %p273: Tensor[(160, 1, 1), float32], %p370: Tensor[(160, 1, 1), float32], __dict__=meta[StrMap][84]) -> Tensor[(1, 160, 17, 17), float32] {
  603. %431 = nn.conv2d(%p084, %p173, padding=[0, 3], channels=160, kernel_size=[1, 7])
  604. %432 = multiply(%431, %p273)
  605. %433 = add(%432, %p370)
  606. %434 = nn.relu(%433)
  607. %434
  608. }
  609. %440 = fn (%p085: Tensor[(1, 160, 17, 17), float32], %p174: Tensor[(160, 160, 7, 1), float32], %p274: Tensor[(160, 1, 1), float32], %p371: Tensor[(160, 1, 1), float32], __dict__=meta[StrMap][85]) -> Tensor[(1, 160, 17, 17), float32] {
  610. %436 = nn.conv2d(%p085, %p174, padding=[3, 0], channels=160, kernel_size=[7, 1])
  611. %437 = multiply(%436, %p274)
  612. %438 = add(%437, %p371)
  613. %439 = nn.relu(%438)
  614. %439
  615. }
  616. %445 = fn (%p086: Tensor[(1, 768, 17, 17), float32], %p175: Tensor[(160, 768, 1, 1), float32], %p275: Tensor[(160, 1, 1), float32], %p372: Tensor[(160, 1, 1), float32], __dict__=meta[StrMap][86]) -> Tensor[(1, 160, 17, 17), float32] {
  617. %441 = nn.conv2d(%p086, %p175, channels=160, kernel_size=[1, 1])
  618. %442 = multiply(%441, %p275)
  619. %443 = add(%442, %p372)
  620. %444 = nn.relu(%443)
  621. %444
  622. }
  623. %446 = %445(%401, meta[relay.Constant][162] // ty=Tensor[(160, 768, 1, 1), float32], meta[relay.Constant][163] // ty=Tensor[(160, 1, 1), float32], meta[relay.Constant][164] // ty=Tensor[(160, 1, 1), float32])
  624. %447 = %440(%446, meta[relay.Constant][165] // ty=Tensor[(160, 160, 7, 1), float32], meta[relay.Constant][166] // ty=Tensor[(160, 1, 1), float32], meta[relay.Constant][167] // ty=Tensor[(160, 1, 1), float32])
  625. %448 = %435(%447, meta[relay.Constant][168] // ty=Tensor[(160, 160, 1, 7), float32], meta[relay.Constant][169] // ty=Tensor[(160, 1, 1), float32], meta[relay.Constant][170] // ty=Tensor[(160, 1, 1), float32])
  626. %449 = %430(%448, meta[relay.Constant][171] // ty=Tensor[(160, 160, 7, 1), float32], meta[relay.Constant][172] // ty=Tensor[(160, 1, 1), float32], meta[relay.Constant][173] // ty=Tensor[(160, 1, 1), float32])
  627. %450 = %425(%449, meta[relay.Constant][174] // ty=Tensor[(192, 160, 1, 7), float32], meta[relay.Constant][175] // ty=Tensor[(192, 1, 1), float32], meta[relay.Constant][176] // ty=Tensor[(192, 1, 1), float32])
  628. %455 = fn (%p087: Tensor[(1, 768, 17, 17), float32], %p176: Tensor[(192, 768, 1, 1), float32], %p276: Tensor[(192, 1, 1), float32], %p373: Tensor[(192, 1, 1), float32], __dict__=meta[StrMap][87]) -> Tensor[(1, 192, 17, 17), float32] {
  629. %451 = nn.conv2d(%p087, %p176, channels=192, kernel_size=[1, 1])
  630. %452 = multiply(%451, %p276)
  631. %453 = add(%452, %p373)
  632. %454 = nn.relu(%453)
  633. %454
  634. }
  635. %457 = fn (%p088: Tensor[(1, 768, 17, 17), float32], __dict__=meta[StrMap][88]) -> Tensor[(1, 768, 17, 17), float32] {
  636. %456 = nn.avg_pool2d(%p088, pool_size=[3, 3], padding=[1, 1], count_include_pad=True)
  637. %456
  638. }
  639. %458 = %457(%401)
  640. %459 = %455(%458, meta[relay.Constant][177] // ty=Tensor[(192, 768, 1, 1), float32], meta[relay.Constant][178] // ty=Tensor[(192, 1, 1), float32], meta[relay.Constant][179] // ty=Tensor[(192, 1, 1), float32])
  641. %460 = %48(%402, %420, %450, %459)
  642. %461 = %45(%460, meta[relay.Constant][180] // ty=Tensor[(192, 768, 1, 1), float32], meta[relay.Constant][181] // ty=Tensor[(192, 1, 1), float32], meta[relay.Constant][182] // ty=Tensor[(192, 1, 1), float32])
  643. %466 = fn (%p089: Tensor[(1, 192, 17, 17), float32], %p177: Tensor[(192, 192, 7, 1), float32], %p277: Tensor[(192, 1, 1), float32], %p374: Tensor[(192, 1, 1), float32], __dict__=meta[StrMap][89]) -> Tensor[(1, 192, 17, 17), float32] {
  644. %462 = nn.conv2d(%p089, %p177, padding=[3, 0], channels=192, kernel_size=[7, 1])
  645. %463 = multiply(%462, %p277)
  646. %464 = add(%463, %p374)
  647. %465 = nn.relu(%464)
  648. %465
  649. }
  650. %471 = fn (%p090: Tensor[(1, 192, 17, 17), float32], %p178: Tensor[(192, 192, 1, 7), float32], %p278: Tensor[(192, 1, 1), float32], %p375: Tensor[(192, 1, 1), float32], __dict__=meta[StrMap][90]) -> Tensor[(1, 192, 17, 17), float32] {
  651. %467 = nn.conv2d(%p090, %p178, padding=[0, 3], channels=192, kernel_size=[1, 7])
  652. %468 = multiply(%467, %p278)
  653. %469 = add(%468, %p375)
  654. %470 = nn.relu(%469)
  655. %470
  656. }
  657. %476 = fn (%p091: Tensor[(1, 768, 17, 17), float32], %p179: Tensor[(192, 768, 1, 1), float32], %p279: Tensor[(192, 1, 1), float32], %p376: Tensor[(192, 1, 1), float32], __dict__=meta[StrMap][91]) -> Tensor[(1, 192, 17, 17), float32] {
  658. %472 = nn.conv2d(%p091, %p179, channels=192, kernel_size=[1, 1])
  659. %473 = multiply(%472, %p279)
  660. %474 = add(%473, %p376)
  661. %475 = nn.relu(%474)
  662. %475
  663. }
  664. %477 = %476(%460, meta[relay.Constant][183] // ty=Tensor[(192, 768, 1, 1), float32], meta[relay.Constant][184] // ty=Tensor[(192, 1, 1), float32], meta[relay.Constant][185] // ty=Tensor[(192, 1, 1), float32])
  665. %478 = %471(%477, meta[relay.Constant][186] // ty=Tensor[(192, 192, 1, 7), float32], meta[relay.Constant][187] // ty=Tensor[(192, 1, 1), float32], meta[relay.Constant][188] // ty=Tensor[(192, 1, 1), float32])
  666. %479 = %466(%478, meta[relay.Constant][189] // ty=Tensor[(192, 192, 7, 1), float32], meta[relay.Constant][190] // ty=Tensor[(192, 1, 1), float32], meta[relay.Constant][191] // ty=Tensor[(192, 1, 1), float32])
  667. %484 = fn (%p092: Tensor[(1, 192, 17, 17), float32], %p180: Tensor[(192, 192, 1, 7), float32], %p280: Tensor[(192, 1, 1), float32], %p377: Tensor[(192, 1, 1), float32], __dict__=meta[StrMap][92]) -> Tensor[(1, 192, 17, 17), float32] {
  668. %480 = nn.conv2d(%p092, %p180, padding=[0, 3], channels=192, kernel_size=[1, 7])
  669. %481 = multiply(%480, %p280)
  670. %482 = add(%481, %p377)
  671. %483 = nn.relu(%482)
  672. %483
  673. }
  674. %489 = fn (%p093: Tensor[(1, 192, 17, 17), float32], %p181: Tensor[(192, 192, 7, 1), float32], %p281: Tensor[(192, 1, 1), float32], %p378: Tensor[(192, 1, 1), float32], __dict__=meta[StrMap][93]) -> Tensor[(1, 192, 17, 17), float32] {
  675. %485 = nn.conv2d(%p093, %p181, padding=[3, 0], channels=192, kernel_size=[7, 1])
  676. %486 = multiply(%485, %p281)
  677. %487 = add(%486, %p378)
  678. %488 = nn.relu(%487)
  679. %488
  680. }
  681. %494 = fn (%p094: Tensor[(1, 192, 17, 17), float32], %p182: Tensor[(192, 192, 1, 7), float32], %p282: Tensor[(192, 1, 1), float32], %p379: Tensor[(192, 1, 1), float32], __dict__=meta[StrMap][94]) -> Tensor[(1, 192, 17, 17), float32] {
  682. %490 = nn.conv2d(%p094, %p182, padding=[0, 3], channels=192, kernel_size=[1, 7])
  683. %491 = multiply(%490, %p282)
  684. %492 = add(%491, %p379)
  685. %493 = nn.relu(%492)
  686. %493
  687. }
  688. %499 = fn (%p095: Tensor[(1, 192, 17, 17), float32], %p183: Tensor[(192, 192, 7, 1), float32], %p283: Tensor[(192, 1, 1), float32], %p380: Tensor[(192, 1, 1), float32], __dict__=meta[StrMap][95]) -> Tensor[(1, 192, 17, 17), float32] {
  689. %495 = nn.conv2d(%p095, %p183, padding=[3, 0], channels=192, kernel_size=[7, 1])
  690. %496 = multiply(%495, %p283)
  691. %497 = add(%496, %p380)
  692. %498 = nn.relu(%497)
  693. %498
  694. }
  695. %504 = fn (%p096: Tensor[(1, 768, 17, 17), float32], %p184: Tensor[(192, 768, 1, 1), float32], %p284: Tensor[(192, 1, 1), float32], %p381: Tensor[(192, 1, 1), float32], __dict__=meta[StrMap][96]) -> Tensor[(1, 192, 17, 17), float32] {
  696. %500 = nn.conv2d(%p096, %p184, channels=192, kernel_size=[1, 1])
  697. %501 = multiply(%500, %p284)
  698. %502 = add(%501, %p381)
  699. %503 = nn.relu(%502)
  700. %503
  701. }
  702. %505 = %504(%460, meta[relay.Constant][192] // ty=Tensor[(192, 768, 1, 1), float32], meta[relay.Constant][193] // ty=Tensor[(192, 1, 1), float32], meta[relay.Constant][194] // ty=Tensor[(192, 1, 1), float32])
  703. %506 = %499(%505, meta[relay.Constant][195] // ty=Tensor[(192, 192, 7, 1), float32], meta[relay.Constant][196] // ty=Tensor[(192, 1, 1), float32], meta[relay.Constant][197] // ty=Tensor[(192, 1, 1), float32])
  704. %507 = %494(%506, meta[relay.Constant][198] // ty=Tensor[(192, 192, 1, 7), float32], meta[relay.Constant][199] // ty=Tensor[(192, 1, 1), float32], meta[relay.Constant][200] // ty=Tensor[(192, 1, 1), float32])
  705. %508 = %489(%507, meta[relay.Constant][201] // ty=Tensor[(192, 192, 7, 1), float32], meta[relay.Constant][202] // ty=Tensor[(192, 1, 1), float32], meta[relay.Constant][203] // ty=Tensor[(192, 1, 1), float32])
  706. %509 = %484(%508, meta[relay.Constant][204] // ty=Tensor[(192, 192, 1, 7), float32], meta[relay.Constant][205] // ty=Tensor[(192, 1, 1), float32], meta[relay.Constant][206] // ty=Tensor[(192, 1, 1), float32])
  707. %514 = fn (%p097: Tensor[(1, 768, 17, 17), float32], %p185: Tensor[(192, 768, 1, 1), float32], %p285: Tensor[(192, 1, 1), float32], %p382: Tensor[(192, 1, 1), float32], __dict__=meta[StrMap][97]) -> Tensor[(1, 192, 17, 17), float32] {
  708. %510 = nn.conv2d(%p097, %p185, channels=192, kernel_size=[1, 1])
  709. %511 = multiply(%510, %p285)
  710. %512 = add(%511, %p382)
  711. %513 = nn.relu(%512)
  712. %513
  713. }
  714. %516 = fn (%p098: Tensor[(1, 768, 17, 17), float32], __dict__=meta[StrMap][98]) -> Tensor[(1, 768, 17, 17), float32] {
  715. %515 = nn.avg_pool2d(%p098, pool_size=[3, 3], padding=[1, 1], count_include_pad=True)
  716. %515
  717. }
  718. %517 = %516(%460)
  719. %518 = %514(%517, meta[relay.Constant][207] // ty=Tensor[(192, 768, 1, 1), float32], meta[relay.Constant][208] // ty=Tensor[(192, 1, 1), float32], meta[relay.Constant][209] // ty=Tensor[(192, 1, 1), float32])
  720. %519 = %40(%461, %479, %509, %518)
  721. %520 = %37(%519, meta[relay.Constant][210] // ty=Tensor[(192, 768, 1, 1), float32], meta[relay.Constant][211] // ty=Tensor[(192, 1, 1), float32], meta[relay.Constant][212] // ty=Tensor[(192, 1, 1), float32])
  722. %521 = %32(%520, meta[relay.Constant][213] // ty=Tensor[(320, 192, 3, 3), float32], meta[relay.Constant][214] // ty=Tensor[(320, 1, 1), float32], meta[relay.Constant][215] // ty=Tensor[(320, 1, 1), float32])
  723. %526 = fn (%p099: Tensor[(1, 192, 17, 17), float32], %p186: Tensor[(192, 192, 3, 3), float32], %p286: Tensor[(192, 1, 1), float32], %p383: Tensor[(192, 1, 1), float32], __dict__=meta[StrMap][99]) -> Tensor[(1, 192, 8, 8), float32] {
  724. %522 = nn.conv2d(%p099, %p186, strides=[2, 2], channels=192, kernel_size=[3, 3])
  725. %523 = multiply(%522, %p286)
  726. %524 = add(%523, %p383)
  727. %525 = nn.relu(%524)
  728. %525
  729. }
  730. %531 = fn (%p0100: Tensor[(1, 192, 17, 17), float32], %p187: Tensor[(192, 192, 7, 1), float32], %p287: Tensor[(192, 1, 1), float32], %p384: Tensor[(192, 1, 1), float32], __dict__=meta[StrMap][100]) -> Tensor[(1, 192, 17, 17), float32] {
  731. %527 = nn.conv2d(%p0100, %p187, padding=[3, 0], channels=192, kernel_size=[7, 1])
  732. %528 = multiply(%527, %p287)
  733. %529 = add(%528, %p384)
  734. %530 = nn.relu(%529)
  735. %530
  736. }
  737. %536 = fn (%p0101: Tensor[(1, 192, 17, 17), float32], %p188: Tensor[(192, 192, 1, 7), float32], %p288: Tensor[(192, 1, 1), float32], %p385: Tensor[(192, 1, 1), float32], __dict__=meta[StrMap][101]) -> Tensor[(1, 192, 17, 17), float32] {
  738. %532 = nn.conv2d(%p0101, %p188, padding=[0, 3], channels=192, kernel_size=[1, 7])
  739. %533 = multiply(%532, %p288)
  740. %534 = add(%533, %p385)
  741. %535 = nn.relu(%534)
  742. %535
  743. }
  744. %541 = fn (%p0102: Tensor[(1, 768, 17, 17), float32], %p189: Tensor[(192, 768, 1, 1), float32], %p289: Tensor[(192, 1, 1), float32], %p386: Tensor[(192, 1, 1), float32], __dict__=meta[StrMap][102]) -> Tensor[(1, 192, 17, 17), float32] {
  745. %537 = nn.conv2d(%p0102, %p189, channels=192, kernel_size=[1, 1])
  746. %538 = multiply(%537, %p289)
  747. %539 = add(%538, %p386)
  748. %540 = nn.relu(%539)
  749. %540
  750. }
  751. %542 = %541(%519, meta[relay.Constant][216] // ty=Tensor[(192, 768, 1, 1), float32], meta[relay.Constant][217] // ty=Tensor[(192, 1, 1), float32], meta[relay.Constant][218] // ty=Tensor[(192, 1, 1), float32])
  752. %543 = %536(%542, meta[relay.Constant][219] // ty=Tensor[(192, 192, 1, 7), float32], meta[relay.Constant][220] // ty=Tensor[(192, 1, 1), float32], meta[relay.Constant][221] // ty=Tensor[(192, 1, 1), float32])
  753. %544 = %531(%543, meta[relay.Constant][222] // ty=Tensor[(192, 192, 7, 1), float32], meta[relay.Constant][223] // ty=Tensor[(192, 1, 1), float32], meta[relay.Constant][224] // ty=Tensor[(192, 1, 1), float32])
  754. %545 = %526(%544, meta[relay.Constant][225] // ty=Tensor[(192, 192, 3, 3), float32], meta[relay.Constant][226] // ty=Tensor[(192, 1, 1), float32], meta[relay.Constant][227] // ty=Tensor[(192, 1, 1), float32])
  755. %547 = fn (%p0103: Tensor[(1, 768, 17, 17), float32], __dict__=meta[StrMap][103]) -> Tensor[(1, 768, 8, 8), float32] {
  756. %546 = nn.max_pool2d(%p0103, pool_size=[3, 3], strides=[2, 2])
  757. %546
  758. }
  759. %548 = %547(%519)
  760. %549 = %27(%521, %545, %548)
  761. %550 = %24(%549, meta[relay.Constant][228] // ty=Tensor[(320, 1280, 1, 1), float32], meta[relay.Constant][229] // ty=Tensor[(320, 1, 1), float32], meta[relay.Constant][230] // ty=Tensor[(320, 1, 1), float32])
  762. %555 = fn (%p0104: Tensor[(1, 384, 8, 8), float32], %p190: Tensor[(384, 384, 1, 3), float32], %p290: Tensor[(384, 1, 1), float32], %p387: Tensor[(384, 1, 1), float32], __dict__=meta[StrMap][104]) -> Tensor[(1, 384, 8, 8), float32] {
  763. %551 = nn.conv2d(%p0104, %p190, padding=[0, 1], channels=384, kernel_size=[1, 3])
  764. %552 = multiply(%551, %p290)
  765. %553 = add(%552, %p387)
  766. %554 = nn.relu(%553)
  767. %554
  768. }
  769. %560 = fn (%p0105: Tensor[(1, 1280, 8, 8), float32], %p191: Tensor[(384, 1280, 1, 1), float32], %p291: Tensor[(384, 1, 1), float32], %p388: Tensor[(384, 1, 1), float32], __dict__=meta[StrMap][105]) -> Tensor[(1, 384, 8, 8), float32] {
  770. %556 = nn.conv2d(%p0105, %p191, channels=384, kernel_size=[1, 1])
  771. %557 = multiply(%556, %p291)
  772. %558 = add(%557, %p388)
  773. %559 = nn.relu(%558)
  774. %559
  775. }
  776. %561 = %560(%549, meta[relay.Constant][231] // ty=Tensor[(384, 1280, 1, 1), float32], meta[relay.Constant][232] // ty=Tensor[(384, 1, 1), float32], meta[relay.Constant][233] // ty=Tensor[(384, 1, 1), float32])
  777. %562 = %555(%561, meta[relay.Constant][234] // ty=Tensor[(384, 384, 1, 3), float32], meta[relay.Constant][235] // ty=Tensor[(384, 1, 1), float32], meta[relay.Constant][236] // ty=Tensor[(384, 1, 1), float32])
  778. %567 = fn (%p0106: Tensor[(1, 384, 8, 8), float32], %p192: Tensor[(384, 384, 3, 1), float32], %p292: Tensor[(384, 1, 1), float32], %p389: Tensor[(384, 1, 1), float32], __dict__=meta[StrMap][106]) -> Tensor[(1, 384, 8, 8), float32] {
  779. %563 = nn.conv2d(%p0106, %p192, padding=[1, 0], channels=384, kernel_size=[3, 1])
  780. %564 = multiply(%563, %p292)
  781. %565 = add(%564, %p389)
  782. %566 = nn.relu(%565)
  783. %566
  784. }
  785. %568 = %567(%561, meta[relay.Constant][237] // ty=Tensor[(384, 384, 3, 1), float32], meta[relay.Constant][238] // ty=Tensor[(384, 1, 1), float32], meta[relay.Constant][239] // ty=Tensor[(384, 1, 1), float32])
  786. %573 = fn (%p0107: Tensor[(1, 384, 8, 8), float32], %p193: Tensor[(384, 384, 1, 3), float32], %p293: Tensor[(384, 1, 1), float32], %p390: Tensor[(384, 1, 1), float32], __dict__=meta[StrMap][107]) -> Tensor[(1, 384, 8, 8), float32] {
  787. %569 = nn.conv2d(%p0107, %p193, padding=[0, 1], channels=384, kernel_size=[1, 3])
  788. %570 = multiply(%569, %p293)
  789. %571 = add(%570, %p390)
  790. %572 = nn.relu(%571)
  791. %572
  792. }
  793. %578 = fn (%p0108: Tensor[(1, 448, 8, 8), float32], %p194: Tensor[(384, 448, 3, 3), float32], %p294: Tensor[(384, 1, 1), float32], %p391: Tensor[(384, 1, 1), float32], __dict__=meta[StrMap][108]) -> Tensor[(1, 384, 8, 8), float32] {
  794. %574 = nn.conv2d(%p0108, %p194, padding=[1, 1], channels=384, kernel_size=[3, 3])
  795. %575 = multiply(%574, %p294)
  796. %576 = add(%575, %p391)
  797. %577 = nn.relu(%576)
  798. %577
  799. }
  800. %583 = fn (%p0109: Tensor[(1, 1280, 8, 8), float32], %p195: Tensor[(448, 1280, 1, 1), float32], %p295: Tensor[(448, 1, 1), float32], %p392: Tensor[(448, 1, 1), float32], __dict__=meta[StrMap][109]) -> Tensor[(1, 448, 8, 8), float32] {
  801. %579 = nn.conv2d(%p0109, %p195, channels=448, kernel_size=[1, 1])
  802. %580 = multiply(%579, %p295)
  803. %581 = add(%580, %p392)
  804. %582 = nn.relu(%581)
  805. %582
  806. }
  807. %584 = %583(%549, meta[relay.Constant][240] // ty=Tensor[(448, 1280, 1, 1), float32], meta[relay.Constant][241] // ty=Tensor[(448, 1, 1), float32], meta[relay.Constant][242] // ty=Tensor[(448, 1, 1), float32])
  808. %585 = %578(%584, meta[relay.Constant][243] // ty=Tensor[(384, 448, 3, 3), float32], meta[relay.Constant][244] // ty=Tensor[(384, 1, 1), float32], meta[relay.Constant][245] // ty=Tensor[(384, 1, 1), float32])
  809. %586 = %573(%585, meta[relay.Constant][246] // ty=Tensor[(384, 384, 1, 3), float32], meta[relay.Constant][247] // ty=Tensor[(384, 1, 1), float32], meta[relay.Constant][248] // ty=Tensor[(384, 1, 1), float32])
  810. %591 = fn (%p0110: Tensor[(1, 384, 8, 8), float32], %p196: Tensor[(384, 384, 3, 1), float32], %p296: Tensor[(384, 1, 1), float32], %p393: Tensor[(384, 1, 1), float32], __dict__=meta[StrMap][110]) -> Tensor[(1, 384, 8, 8), float32] {
  811. %587 = nn.conv2d(%p0110, %p196, padding=[1, 0], channels=384, kernel_size=[3, 1])
  812. %588 = multiply(%587, %p296)
  813. %589 = add(%588, %p393)
  814. %590 = nn.relu(%589)
  815. %590
  816. }
  817. %592 = %591(%585, meta[relay.Constant][249] // ty=Tensor[(384, 384, 3, 1), float32], meta[relay.Constant][250] // ty=Tensor[(384, 1, 1), float32], meta[relay.Constant][251] // ty=Tensor[(384, 1, 1), float32])
  818. %597 = fn (%p0111: Tensor[(1, 1280, 8, 8), float32], %p197: Tensor[(192, 1280, 1, 1), float32], %p297: Tensor[(192, 1, 1), float32], %p394: Tensor[(192, 1, 1), float32], __dict__=meta[StrMap][111]) -> Tensor[(1, 192, 8, 8), float32] {
  819. %593 = nn.conv2d(%p0111, %p197, channels=192, kernel_size=[1, 1])
  820. %594 = multiply(%593, %p297)
  821. %595 = add(%594, %p394)
  822. %596 = nn.relu(%595)
  823. %596
  824. }
  825. %599 = fn (%p0112: Tensor[(1, 1280, 8, 8), float32], __dict__=meta[StrMap][112]) -> Tensor[(1, 1280, 8, 8), float32] {
  826. %598 = nn.avg_pool2d(%p0112, pool_size=[3, 3], padding=[1, 1], count_include_pad=True)
  827. %598
  828. }
  829. %600 = %599(%549)
  830. %601 = %597(%600, meta[relay.Constant][252] // ty=Tensor[(192, 1280, 1, 1), float32], meta[relay.Constant][253] // ty=Tensor[(192, 1, 1), float32], meta[relay.Constant][254] // ty=Tensor[(192, 1, 1), float32])
  831. %602 = %19(%550, %562, %568, %586, %592, %601)
  832. %603 = %16(%602, meta[relay.Constant][255] // ty=Tensor[(320, 2048, 1, 1), float32], meta[relay.Constant][256] // ty=Tensor[(320, 1, 1), float32], meta[relay.Constant][257] // ty=Tensor[(320, 1, 1), float32])
  833. %608 = fn (%p0113: Tensor[(1, 384, 8, 8), float32], %p198: Tensor[(384, 384, 1, 3), float32], %p298: Tensor[(384, 1, 1), float32], %p395: Tensor[(384, 1, 1), float32], __dict__=meta[StrMap][113]) -> Tensor[(1, 384, 8, 8), float32] {
  834. %604 = nn.conv2d(%p0113, %p198, padding=[0, 1], channels=384, kernel_size=[1, 3])
  835. %605 = multiply(%604, %p298)
  836. %606 = add(%605, %p395)
  837. %607 = nn.relu(%606)
  838. %607
  839. }
  840. %613 = fn (%p0114: Tensor[(1, 2048, 8, 8), float32], %p199: Tensor[(384, 2048, 1, 1), float32], %p299: Tensor[(384, 1, 1), float32], %p396: Tensor[(384, 1, 1), float32], __dict__=meta[StrMap][114]) -> Tensor[(1, 384, 8, 8), float32] {
  841. %609 = nn.conv2d(%p0114, %p199, channels=384, kernel_size=[1, 1])
  842. %610 = multiply(%609, %p299)
  843. %611 = add(%610, %p396)
  844. %612 = nn.relu(%611)
  845. %612
  846. }
  847. %614 = %613(%602, meta[relay.Constant][258] // ty=Tensor[(384, 2048, 1, 1), float32], meta[relay.Constant][259] // ty=Tensor[(384, 1, 1), float32], meta[relay.Constant][260] // ty=Tensor[(384, 1, 1), float32])
  848. %615 = %608(%614, meta[relay.Constant][261] // ty=Tensor[(384, 384, 1, 3), float32], meta[relay.Constant][262] // ty=Tensor[(384, 1, 1), float32], meta[relay.Constant][263] // ty=Tensor[(384, 1, 1), float32])
  849. %620 = fn (%p0115: Tensor[(1, 384, 8, 8), float32], %p1100: Tensor[(384, 384, 3, 1), float32], %p2100: Tensor[(384, 1, 1), float32], %p397: Tensor[(384, 1, 1), float32], __dict__=meta[StrMap][115]) -> Tensor[(1, 384, 8, 8), float32] {
  850. %616 = nn.conv2d(%p0115, %p1100, padding=[1, 0], channels=384, kernel_size=[3, 1])
  851. %617 = multiply(%616, %p2100)
  852. %618 = add(%617, %p397)
  853. %619 = nn.relu(%618)
  854. %619
  855. }
  856. %621 = %620(%614, meta[relay.Constant][264] // ty=Tensor[(384, 384, 3, 1), float32], meta[relay.Constant][265] // ty=Tensor[(384, 1, 1), float32], meta[relay.Constant][266] // ty=Tensor[(384, 1, 1), float32])
  857. %626 = fn (%p0116: Tensor[(1, 384, 8, 8), float32], %p1101: Tensor[(384, 384, 1, 3), float32], %p2101: Tensor[(384, 1, 1), float32], %p398: Tensor[(384, 1, 1), float32], __dict__=meta[StrMap][116]) -> Tensor[(1, 384, 8, 8), float32] {
  858. %622 = nn.conv2d(%p0116, %p1101, padding=[0, 1], channels=384, kernel_size=[1, 3])
  859. %623 = multiply(%622, %p2101)
  860. %624 = add(%623, %p398)
  861. %625 = nn.relu(%624)
  862. %625
  863. }
  864. %631 = fn (%p0117: Tensor[(1, 448, 8, 8), float32], %p1102: Tensor[(384, 448, 3, 3), float32], %p2102: Tensor[(384, 1, 1), float32], %p399: Tensor[(384, 1, 1), float32], __dict__=meta[StrMap][117]) -> Tensor[(1, 384, 8, 8), float32] {
  865. %627 = nn.conv2d(%p0117, %p1102, padding=[1, 1], channels=384, kernel_size=[3, 3])
  866. %628 = multiply(%627, %p2102)
  867. %629 = add(%628, %p399)
  868. %630 = nn.relu(%629)
  869. %630
  870. }
  871. %636 = fn (%p0118: Tensor[(1, 2048, 8, 8), float32], %p1103: Tensor[(448, 2048, 1, 1), float32], %p2103: Tensor[(448, 1, 1), float32], %p3100: Tensor[(448, 1, 1), float32], __dict__=meta[StrMap][118]) -> Tensor[(1, 448, 8, 8), float32] {
  872. %632 = nn.conv2d(%p0118, %p1103, channels=448, kernel_size=[1, 1])
  873. %633 = multiply(%632, %p2103)
  874. %634 = add(%633, %p3100)
  875. %635 = nn.relu(%634)
  876. %635
  877. }
  878. %637 = %636(%602, meta[relay.Constant][267] // ty=Tensor[(448, 2048, 1, 1), float32], meta[relay.Constant][268] // ty=Tensor[(448, 1, 1), float32], meta[relay.Constant][269] // ty=Tensor[(448, 1, 1), float32])
  879. %638 = %631(%637, meta[relay.Constant][270] // ty=Tensor[(384, 448, 3, 3), float32], meta[relay.Constant][271] // ty=Tensor[(384, 1, 1), float32], meta[relay.Constant][272] // ty=Tensor[(384, 1, 1), float32])
  880. %639 = %626(%638, meta[relay.Constant][273] // ty=Tensor[(384, 384, 1, 3), float32], meta[relay.Constant][274] // ty=Tensor[(384, 1, 1), float32], meta[relay.Constant][275] // ty=Tensor[(384, 1, 1), float32])
  881. %644 = fn (%p0119: Tensor[(1, 384, 8, 8), float32], %p1104: Tensor[(384, 384, 3, 1), float32], %p2104: Tensor[(384, 1, 1), float32], %p3101: Tensor[(384, 1, 1), float32], __dict__=meta[StrMap][119]) -> Tensor[(1, 384, 8, 8), float32] {
  882. %640 = nn.conv2d(%p0119, %p1104, padding=[1, 0], channels=384, kernel_size=[3, 1])
  883. %641 = multiply(%640, %p2104)
  884. %642 = add(%641, %p3101)
  885. %643 = nn.relu(%642)
  886. %643
  887. }
  888. %645 = %644(%638, meta[relay.Constant][276] // ty=Tensor[(384, 384, 3, 1), float32], meta[relay.Constant][277] // ty=Tensor[(384, 1, 1), float32], meta[relay.Constant][278] // ty=Tensor[(384, 1, 1), float32])
  889. %650 = fn (%p0120: Tensor[(1, 2048, 8, 8), float32], %p1105: Tensor[(192, 2048, 1, 1), float32], %p2105: Tensor[(192, 1, 1), float32], %p3102: Tensor[(192, 1, 1), float32], __dict__=meta[StrMap][120]) -> Tensor[(1, 192, 8, 8), float32] {
  890. %646 = nn.conv2d(%p0120, %p1105, channels=192, kernel_size=[1, 1])
  891. %647 = multiply(%646, %p2105)
  892. %648 = add(%647, %p3102)
  893. %649 = nn.relu(%648)
  894. %649
  895. }
  896. %652 = fn (%p0121: Tensor[(1, 2048, 8, 8), float32], __dict__=meta[StrMap][121]) -> Tensor[(1, 2048, 8, 8), float32] {
  897. %651 = nn.max_pool2d(%p0121, pool_size=[3, 3], padding=[1, 1])
  898. %651
  899. }
  900. %653 = %652(%602)
  901. %654 = %650(%653, meta[relay.Constant][279] // ty=Tensor[(192, 2048, 1, 1), float32], meta[relay.Constant][280] // ty=Tensor[(192, 1, 1), float32], meta[relay.Constant][281] // ty=Tensor[(192, 1, 1), float32])
  902. %655 = %11(%603, %615, %621, %639, %645, %654)
  903. %656 = %8(%655)
  904. %657 = %6(%656)
  905. %658 = %4(%657, meta[relay.Constant][282] // ty=Tensor[(1000, 2048), float32], meta[relay.Constant][283] // ty=Tensor[(1000,), float32])
  906. %659 = %1(%658)
  907. %659
  908. }
  909. %660
  910. // meta data omitted. you can use show_meta_data=True to include meta data
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!