daily pastebin goal
25%
SHARE
TWEET

Untitled

a guest Mar 22nd, 2019 119 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  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
RAW Paste Data
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
 
Top