Skip to content

Instantly share code, notes, and snippets.

@masahi

masahi/ssd_relay.txt

Created January 15, 2019 09:23
Show Gist options
  • Save masahi/8dd3a3fd929bc94693b569f558850185 to your computer and use it in GitHub Desktop.
Save masahi/8dd3a3fd929bc94693b569f558850185 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
ssd_relay.txt
fn (%data: Tensor[(1, 3, 512, 512), float32])
-> Tuple[Tensor[(1, 100, 1), float32], Tensor[(1, 100, 1), float32], Tensor[(1, 100, 4), float32]] {
%0 = meta.relay.Constant(id=0) # ty=Tensor[(64, 3, 7, 7), float32]
%1 = meta.relay.Constant(id=1) # ty=Tensor[(64, 1, 1), float32]
%2 = fn(%p0: Tensor[(1, 3, 512, 512), float32],
%p1: Tensor[(64, 3, 7, 7), float32],
%p2: Tensor[(64, 1, 1), float32])
-> Tensor[(1, 64, 256, 256), float32] {
%3 = nn.conv2d(%p0, %p1, strides=[2, 2], padding=[3, 3], channels=64, kernel_size=[7, 7]) # ty=Tensor[(1, 64, 256, 256), float32]
%4 = add(%3, %p2) # ty=Tensor[(1, 64, 256, 256), float32]
%5 = nn.relu(%4) # ty=Tensor[(1, 64, 256, 256), float32]
%5
}
%6 = %2(%data, %0, %1) # ty=Tensor[(1, 64, 256, 256), float32]
%7 = fn(%p01: Tensor[(1, 64, 256, 256), float32])
-> Tensor[(1, 64, 128, 128), float32] {
%8 = nn.max_pool2d(%p01, pool_size=[3, 3], strides=[2, 2], padding=[1, 1]) # ty=Tensor[(1, 64, 128, 128), float32]
%8
}
%9 = %7(%6) # ty=Tensor[(1, 64, 128, 128), float32]
%10 = meta.relay.Constant(id=2) # ty=Tensor[(320, 64, 1, 1), float32]
%11 = fn(%p02: Tensor[(1, 64, 128, 128), float32],
%p11: Tensor[(320, 64, 1, 1), float32])
-> Tensor[(1, 320, 128, 128), float32] {
%12 = nn.conv2d(%p02, %p11, channels=320, kernel_size=[1, 1]) # ty=Tensor[(1, 320, 128, 128), float32]
%12
}
%13 = %11(%9, %10) # ty=Tensor[(1, 320, 128, 128), float32]
%14 = meta.relay.Constant(id=3) # ty=Tensor[(64, 1, 1), float32]
%15 = meta.relay.Constant(id=4) # ty=Tensor[(64, 1, 1), float32]
%16 = fn(%p03: Tensor[(1, 320, 128, 128), float32],
%p12: Tensor[(64, 1, 1), float32],
%p21: Tensor[(64, 1, 1), float32])
-> Tensor[(1, 64, 128, 128), float32] {
%17 = strided_slice(%p03, begin=[0, 0], end=[None, 64]) # ty=Tensor[(1, 64, 128, 128), float32]
%18 = add(%17, %p12) # ty=Tensor[(1, 64, 128, 128), float32]
%19 = add(%18, %p21) # ty=Tensor[(1, 64, 128, 128), float32]
%20 = nn.relu(%19) # ty=Tensor[(1, 64, 128, 128), float32]
%20
}
%21 = %16(%13, %14, %15) # ty=Tensor[(1, 64, 128, 128), float32]
%22 = meta.relay.Constant(id=5) # ty=Tensor[(64, 64, 3, 3), float32]
%23 = meta.relay.Constant(id=6) # ty=Tensor[(64, 1, 1), float32]
%24 = fn(%p04: Tensor[(1, 64, 128, 128), float32],
%p13: Tensor[(64, 64, 3, 3), float32],
%p22: Tensor[(64, 1, 1), float32])
-> Tensor[(1, 64, 128, 128), float32] {
%25 = nn.conv2d(%p04, %p13, padding=[1, 1], channels=64, kernel_size=[3, 3]) # ty=Tensor[(1, 64, 128, 128), float32]
%26 = add(%25, %p22) # ty=Tensor[(1, 64, 128, 128), float32]
%27 = nn.relu(%26) # ty=Tensor[(1, 64, 128, 128), float32]
%27
}
%28 = %24(%21, %22, %23) # ty=Tensor[(1, 64, 128, 128), float32]
%29 = meta.relay.Constant(id=7) # ty=Tensor[(256, 64, 1, 1), float32]
%30 = meta.relay.Constant(id=8) # ty=Tensor[(256, 1, 1), float32]
%31 = meta.relay.Constant(id=9) # ty=Tensor[(256, 1, 1), float32]
%32 = meta.relay.Constant(id=10) # ty=Tensor[(256, 1, 1), float32]
%33 = fn(%p05: Tensor[(1, 320, 128, 128), float32])
-> Tensor[(1, 256, 128, 128), float32] {
%34 = strided_slice(%p05, begin=[0, 64], end=[None, 320]) # ty=Tensor[(1, 256, 128, 128), float32]
%34
}
%35 = %33(%13) # ty=Tensor[(1, 256, 128, 128), float32]
%36 = meta.relay.Constant(id=11) # ty=Tensor[(256, 1, 1), float32]
%37 = meta.relay.Constant(id=12) # ty=Tensor[(256, 1, 1), float32]
%38 = fn(%p06: Tensor[(1, 64, 128, 128), float32],
%p14: Tensor[(256, 64, 1, 1), float32],
%p23: Tensor[(256, 1, 1), float32],
%p3: Tensor[(256, 1, 1), float32],
%p4: Tensor[(256, 1, 1), float32],
%p5: Tensor[(1, 256, 128, 128), float32],
%p6: Tensor[(256, 1, 1), float32],
%p7: Tensor[(256, 1, 1), float32])
-> Tensor[(1, 256, 128, 128), float32] {
%39 = nn.conv2d(%p06, %p14, channels=256, kernel_size=[1, 1]) # ty=Tensor[(1, 256, 128, 128), float32]
%40 = add(%39, %p23) # ty=Tensor[(1, 256, 128, 128), float32]
%41 = multiply(%40, %p3) # ty=Tensor[(1, 256, 128, 128), float32]
%42 = add(%41, %p4) # ty=Tensor[(1, 256, 128, 128), float32]
%43 = multiply(%p5, %p6) # ty=Tensor[(1, 256, 128, 128), float32]
%44 = add(%43, %p7) # ty=Tensor[(1, 256, 128, 128), float32]
%45 = add(%42, %44) # ty=Tensor[(1, 256, 128, 128), float32]
%46 = nn.relu(%45) # ty=Tensor[(1, 256, 128, 128), float32]
%46
}
%47 = %38(%28, %29, %30, %31, %32, %35, %36, %37) # ty=Tensor[(1, 256, 128, 128), float32]
%48 = meta.relay.Constant(id=13) # ty=Tensor[(64, 256, 1, 1), float32]
%49 = meta.relay.Constant(id=14) # ty=Tensor[(64, 1, 1), float32]
%50 = meta.relay.Constant(id=15) # ty=Tensor[(64, 1, 1), float32]
%51 = fn(%p07: Tensor[(1, 256, 128, 128), float32],
%p15: Tensor[(64, 256, 1, 1), float32],
%p24: Tensor[(64, 1, 1), float32],
%p31: Tensor[(64, 1, 1), float32])
-> Tensor[(1, 64, 128, 128), float32] {
%52 = nn.conv2d(%p07, %p15, channels=64, kernel_size=[1, 1]) # ty=Tensor[(1, 64, 128, 128), float32]
%53 = add(%52, %p24) # ty=Tensor[(1, 64, 128, 128), float32]
%54 = add(%53, %p31) # ty=Tensor[(1, 64, 128, 128), float32]
%55 = nn.relu(%54) # ty=Tensor[(1, 64, 128, 128), float32]
%55
}
%56 = %51(%47, %48, %49, %50) # ty=Tensor[(1, 64, 128, 128), float32]
%57 = meta.relay.Constant(id=16) # ty=Tensor[(64, 64, 3, 3), float32]
%58 = meta.relay.Constant(id=17) # ty=Tensor[(64, 1, 1), float32]
%59 = fn(%p08: Tensor[(1, 64, 128, 128), float32],
%p16: Tensor[(64, 64, 3, 3), float32],
%p25: Tensor[(64, 1, 1), float32])
-> Tensor[(1, 64, 128, 128), float32] {
%60 = nn.conv2d(%p08, %p16, padding=[1, 1], channels=64, kernel_size=[3, 3]) # ty=Tensor[(1, 64, 128, 128), float32]
%61 = add(%60, %p25) # ty=Tensor[(1, 64, 128, 128), float32]
%62 = nn.relu(%61) # ty=Tensor[(1, 64, 128, 128), float32]
%62
}
%63 = %59(%56, %57, %58) # ty=Tensor[(1, 64, 128, 128), float32]
%64 = meta.relay.Constant(id=18) # ty=Tensor[(256, 64, 1, 1), float32]
%65 = meta.relay.Constant(id=19) # ty=Tensor[(256, 1, 1), float32]
%66 = meta.relay.Constant(id=20) # ty=Tensor[(256, 1, 1), float32]
%67 = meta.relay.Constant(id=21) # ty=Tensor[(256, 1, 1), float32]
%68 = fn(%p09: Tensor[(1, 64, 128, 128), float32],
%p17: Tensor[(256, 64, 1, 1), float32],
%p26: Tensor[(256, 1, 1), float32],
%p32: Tensor[(256, 1, 1), float32],
%p41: Tensor[(256, 1, 1), float32],
%p51: Tensor[(1, 256, 128, 128), float32])
-> Tensor[(1, 256, 128, 128), float32] {
%69 = nn.conv2d(%p09, %p17, channels=256, kernel_size=[1, 1]) # ty=Tensor[(1, 256, 128, 128), float32]
%70 = add(%69, %p26) # ty=Tensor[(1, 256, 128, 128), float32]
%71 = multiply(%70, %p32) # ty=Tensor[(1, 256, 128, 128), float32]
%72 = add(%71, %p41) # ty=Tensor[(1, 256, 128, 128), float32]
%73 = add(%72, %p51) # ty=Tensor[(1, 256, 128, 128), float32]
%74 = nn.relu(%73) # ty=Tensor[(1, 256, 128, 128), float32]
%74
}
%75 = %68(%63, %64, %65, %66, %67, %47) # ty=Tensor[(1, 256, 128, 128), float32]
%76 = meta.relay.Constant(id=22) # ty=Tensor[(64, 256, 1, 1), float32]
%77 = meta.relay.Constant(id=23) # ty=Tensor[(64, 1, 1), float32]
%78 = meta.relay.Constant(id=24) # ty=Tensor[(64, 1, 1), float32]
%79 = meta.relay.Constant(id=25) # ty=Tensor[(64, 1, 1), float32]
%80 = fn(%p010: Tensor[(1, 256, 128, 128), float32],
%p18: Tensor[(64, 256, 1, 1), float32],
%p27: Tensor[(64, 1, 1), float32],
%p33: Tensor[(64, 1, 1), float32],
%p42: Tensor[(64, 1, 1), float32])
-> Tensor[(1, 64, 128, 128), float32] {
%81 = nn.conv2d(%p010, %p18, channels=64, kernel_size=[1, 1]) # ty=Tensor[(1, 64, 128, 128), float32]
%82 = add(%81, %p27) # ty=Tensor[(1, 64, 128, 128), float32]
%83 = multiply(%82, %p33) # ty=Tensor[(1, 64, 128, 128), float32]
%84 = add(%83, %p42) # ty=Tensor[(1, 64, 128, 128), float32]
%85 = nn.relu(%84) # ty=Tensor[(1, 64, 128, 128), float32]
%85
}
%86 = %80(%75, %76, %77, %78, %79) # ty=Tensor[(1, 64, 128, 128), float32]
%87 = meta.relay.Constant(id=26) # ty=Tensor[(64, 64, 3, 3), float32]
%88 = meta.relay.Constant(id=27) # ty=Tensor[(64, 1, 1), float32]
%89 = fn(%p011: Tensor[(1, 64, 128, 128), float32],
%p19: Tensor[(64, 64, 3, 3), float32],
%p28: Tensor[(64, 1, 1), float32])
-> Tensor[(1, 64, 128, 128), float32] {
%90 = nn.conv2d(%p011, %p19, padding=[1, 1], channels=64, kernel_size=[3, 3]) # ty=Tensor[(1, 64, 128, 128), float32]
%91 = add(%90, %p28) # ty=Tensor[(1, 64, 128, 128), float32]
%92 = nn.relu(%91) # ty=Tensor[(1, 64, 128, 128), float32]
%92
}
%93 = %89(%86, %87, %88) # ty=Tensor[(1, 64, 128, 128), float32]
%94 = meta.relay.Constant(id=28) # ty=Tensor[(256, 64, 1, 1), float32]
%95 = meta.relay.Constant(id=29) # ty=Tensor[(256, 1, 1), float32]
%96 = meta.relay.Constant(id=30) # ty=Tensor[(256, 1, 1), float32]
%97 = meta.relay.Constant(id=31) # ty=Tensor[(256, 1, 1), float32]
%98 = fn(%p012: Tensor[(1, 64, 128, 128), float32],
%p110: Tensor[(256, 64, 1, 1), float32],
%p29: Tensor[(256, 1, 1), float32],
%p34: Tensor[(256, 1, 1), float32],
%p43: Tensor[(256, 1, 1), float32],
%p52: Tensor[(1, 256, 128, 128), float32])
-> Tensor[(1, 256, 128, 128), float32] {
%99 = nn.conv2d(%p012, %p110, channels=256, kernel_size=[1, 1]) # ty=Tensor[(1, 256, 128, 128), float32]
%100 = add(%99, %p29) # ty=Tensor[(1, 256, 128, 128), float32]
%101 = multiply(%100, %p34) # ty=Tensor[(1, 256, 128, 128), float32]
%102 = add(%101, %p43) # ty=Tensor[(1, 256, 128, 128), float32]
%103 = add(%102, %p52) # ty=Tensor[(1, 256, 128, 128), float32]
%104 = nn.relu(%103) # ty=Tensor[(1, 256, 128, 128), float32]
%104
}
%105 = %98(%93, %94, %95, %96, %97, %75) # ty=Tensor[(1, 256, 128, 128), float32]
%106 = meta.relay.Constant(id=32) # ty=Tensor[(640, 256, 1, 1), float32]
%107 = fn(%p013: Tensor[(1, 256, 128, 128), float32],
%p111: Tensor[(640, 256, 1, 1), float32])
-> Tensor[(1, 640, 64, 64), float32] {
%108 = nn.conv2d(%p013, %p111, strides=[2, 2], channels=640, kernel_size=[1, 1]) # ty=Tensor[(1, 640, 64, 64), float32]
%108
}
%109 = %107(%105, %106) # ty=Tensor[(1, 640, 64, 64), float32]
%110 = meta.relay.Constant(id=33) # ty=Tensor[(128, 1, 1), float32]
%111 = meta.relay.Constant(id=34) # ty=Tensor[(128, 1, 1), float32]
%112 = fn(%p014: Tensor[(1, 640, 64, 64), float32],
%p112: Tensor[(128, 1, 1), float32],
%p210: Tensor[(128, 1, 1), float32])
-> Tensor[(1, 128, 64, 64), float32] {
%113 = strided_slice(%p014, begin=[0, 0], end=[None, 128]) # ty=Tensor[(1, 128, 64, 64), float32]
%114 = add(%113, %p112) # ty=Tensor[(1, 128, 64, 64), float32]
%115 = add(%114, %p210) # ty=Tensor[(1, 128, 64, 64), float32]
%116 = nn.relu(%115) # ty=Tensor[(1, 128, 64, 64), float32]
%116
}
%117 = %112(%109, %110, %111) # ty=Tensor[(1, 128, 64, 64), float32]
%118 = meta.relay.Constant(id=35) # ty=Tensor[(128, 128, 3, 3), float32]
%119 = meta.relay.Constant(id=36) # ty=Tensor[(128, 1, 1), float32]
%120 = fn(%p015: Tensor[(1, 128, 64, 64), float32],
%p113: Tensor[(128, 128, 3, 3), float32],
%p211: Tensor[(128, 1, 1), float32])
-> Tensor[(1, 128, 64, 64), float32] {
%121 = nn.conv2d(%p015, %p113, padding=[1, 1], channels=128, kernel_size=[3, 3]) # ty=Tensor[(1, 128, 64, 64), float32]
%122 = add(%121, %p211) # ty=Tensor[(1, 128, 64, 64), float32]
%123 = nn.relu(%122) # ty=Tensor[(1, 128, 64, 64), float32]
%123
}
%124 = %120(%117, %118, %119) # ty=Tensor[(1, 128, 64, 64), float32]
%125 = meta.relay.Constant(id=37) # ty=Tensor[(512, 128, 1, 1), float32]
%126 = meta.relay.Constant(id=38) # ty=Tensor[(512, 1, 1), float32]
%127 = meta.relay.Constant(id=39) # ty=Tensor[(512, 1, 1), float32]
%128 = meta.relay.Constant(id=40) # ty=Tensor[(512, 1, 1), float32]
%129 = fn(%p016: Tensor[(1, 640, 64, 64), float32])
-> Tensor[(1, 512, 64, 64), float32] {
%130 = strided_slice(%p016, begin=[0, 128], end=[None, 640]) # ty=Tensor[(1, 512, 64, 64), float32]
%130
}
%131 = %129(%109) # ty=Tensor[(1, 512, 64, 64), float32]
%132 = meta.relay.Constant(id=41) # ty=Tensor[(512, 1, 1), float32]
%133 = meta.relay.Constant(id=42) # ty=Tensor[(512, 1, 1), float32]
%134 = fn(%p017: Tensor[(1, 128, 64, 64), float32],
%p114: Tensor[(512, 128, 1, 1), float32],
%p212: Tensor[(512, 1, 1), float32],
%p35: Tensor[(512, 1, 1), float32],
%p44: Tensor[(512, 1, 1), float32],
%p53: Tensor[(1, 512, 64, 64), float32],
%p61: Tensor[(512, 1, 1), float32],
%p71: Tensor[(512, 1, 1), float32])
-> Tensor[(1, 512, 64, 64), float32] {
%135 = nn.conv2d(%p017, %p114, channels=512, kernel_size=[1, 1]) # ty=Tensor[(1, 512, 64, 64), float32]
%136 = add(%135, %p212) # ty=Tensor[(1, 512, 64, 64), float32]
%137 = multiply(%136, %p35) # ty=Tensor[(1, 512, 64, 64), float32]
%138 = add(%137, %p44) # ty=Tensor[(1, 512, 64, 64), float32]
%139 = multiply(%p53, %p61) # ty=Tensor[(1, 512, 64, 64), float32]
%140 = add(%139, %p71) # ty=Tensor[(1, 512, 64, 64), float32]
%141 = add(%138, %140) # ty=Tensor[(1, 512, 64, 64), float32]
%142 = nn.relu(%141) # ty=Tensor[(1, 512, 64, 64), float32]
%142
}
%143 = %134(%124, %125, %126, %127, %128, %131, %132, %133) # ty=Tensor[(1, 512, 64, 64), float32]
%144 = meta.relay.Constant(id=43) # ty=Tensor[(128, 512, 1, 1), float32]
%145 = meta.relay.Constant(id=44) # ty=Tensor[(128, 1, 1), float32]
%146 = meta.relay.Constant(id=45) # ty=Tensor[(128, 1, 1), float32]
%147 = fn(%p018: Tensor[(1, 512, 64, 64), float32],
%p115: Tensor[(128, 512, 1, 1), float32],
%p213: Tensor[(128, 1, 1), float32],
%p36: Tensor[(128, 1, 1), float32])
-> Tensor[(1, 128, 64, 64), float32] {
%148 = nn.conv2d(%p018, %p115, channels=128, kernel_size=[1, 1]) # ty=Tensor[(1, 128, 64, 64), float32]
%149 = add(%148, %p213) # ty=Tensor[(1, 128, 64, 64), float32]
%150 = add(%149, %p36) # ty=Tensor[(1, 128, 64, 64), float32]
%151 = nn.relu(%150) # ty=Tensor[(1, 128, 64, 64), float32]
%151
}
%152 = %147(%143, %144, %145, %146) # ty=Tensor[(1, 128, 64, 64), float32]
%153 = meta.relay.Constant(id=46) # ty=Tensor[(128, 128, 3, 3), float32]
%154 = meta.relay.Constant(id=47) # ty=Tensor[(128, 1, 1), float32]
%155 = fn(%p019: Tensor[(1, 128, 64, 64), float32],
%p116: Tensor[(128, 128, 3, 3), float32],
%p214: Tensor[(128, 1, 1), float32])
-> Tensor[(1, 128, 64, 64), float32] {
%156 = nn.conv2d(%p019, %p116, padding=[1, 1], channels=128, kernel_size=[3, 3]) # ty=Tensor[(1, 128, 64, 64), float32]
%157 = add(%156, %p214) # ty=Tensor[(1, 128, 64, 64), float32]
%158 = nn.relu(%157) # ty=Tensor[(1, 128, 64, 64), float32]
%158
}
%159 = %155(%152, %153, %154) # ty=Tensor[(1, 128, 64, 64), float32]
%160 = meta.relay.Constant(id=48) # ty=Tensor[(512, 128, 1, 1), float32]
%161 = meta.relay.Constant(id=49) # ty=Tensor[(512, 1, 1), float32]
%162 = meta.relay.Constant(id=50) # ty=Tensor[(512, 1, 1), float32]
%163 = meta.relay.Constant(id=51) # ty=Tensor[(512, 1, 1), float32]
%164 = fn(%p020: Tensor[(1, 128, 64, 64), float32],
%p117: Tensor[(512, 128, 1, 1), float32],
%p215: Tensor[(512, 1, 1), float32],
%p37: Tensor[(512, 1, 1), float32],
%p45: Tensor[(512, 1, 1), float32],
%p54: Tensor[(1, 512, 64, 64), float32])
-> Tensor[(1, 512, 64, 64), float32] {
%165 = nn.conv2d(%p020, %p117, channels=512, kernel_size=[1, 1]) # ty=Tensor[(1, 512, 64, 64), float32]
%166 = add(%165, %p215) # ty=Tensor[(1, 512, 64, 64), float32]
%167 = multiply(%166, %p37) # ty=Tensor[(1, 512, 64, 64), float32]
%168 = add(%167, %p45) # ty=Tensor[(1, 512, 64, 64), float32]
%169 = add(%168, %p54) # ty=Tensor[(1, 512, 64, 64), float32]
%170 = nn.relu(%169) # ty=Tensor[(1, 512, 64, 64), float32]
%170
}
%171 = %164(%159, %160, %161, %162, %163, %143) # ty=Tensor[(1, 512, 64, 64), float32]
%172 = meta.relay.Constant(id=52) # ty=Tensor[(128, 512, 1, 1), float32]
%173 = meta.relay.Constant(id=53) # ty=Tensor[(128, 1, 1), float32]
%174 = meta.relay.Constant(id=54) # ty=Tensor[(128, 1, 1), float32]
%175 = fn(%p021: Tensor[(1, 512, 64, 64), float32],
%p118: Tensor[(128, 512, 1, 1), float32],
%p216: Tensor[(128, 1, 1), float32],
%p38: Tensor[(128, 1, 1), float32])
-> Tensor[(1, 128, 64, 64), float32] {
%176 = nn.conv2d(%p021, %p118, channels=128, kernel_size=[1, 1]) # ty=Tensor[(1, 128, 64, 64), float32]
%177 = add(%176, %p216) # ty=Tensor[(1, 128, 64, 64), float32]
%178 = add(%177, %p38) # ty=Tensor[(1, 128, 64, 64), float32]
%179 = nn.relu(%178) # ty=Tensor[(1, 128, 64, 64), float32]
%179
}
%180 = %175(%171, %172, %173, %174) # ty=Tensor[(1, 128, 64, 64), float32]
%181 = meta.relay.Constant(id=55) # ty=Tensor[(128, 128, 3, 3), float32]
%182 = meta.relay.Constant(id=56) # ty=Tensor[(128, 1, 1), float32]
%183 = fn(%p022: Tensor[(1, 128, 64, 64), float32],
%p119: Tensor[(128, 128, 3, 3), float32],
%p217: Tensor[(128, 1, 1), float32])
-> Tensor[(1, 128, 64, 64), float32] {
%184 = nn.conv2d(%p022, %p119, padding=[1, 1], channels=128, kernel_size=[3, 3]) # ty=Tensor[(1, 128, 64, 64), float32]
%185 = add(%184, %p217) # ty=Tensor[(1, 128, 64, 64), float32]
%186 = nn.relu(%185) # ty=Tensor[(1, 128, 64, 64), float32]
%186
}
%187 = %183(%180, %181, %182) # ty=Tensor[(1, 128, 64, 64), float32]
%188 = meta.relay.Constant(id=57) # ty=Tensor[(512, 128, 1, 1), float32]
%189 = meta.relay.Constant(id=58) # ty=Tensor[(512, 1, 1), float32]
%190 = meta.relay.Constant(id=59) # ty=Tensor[(512, 1, 1), float32]
%191 = meta.relay.Constant(id=60) # ty=Tensor[(512, 1, 1), float32]
%192 = fn(%p023: Tensor[(1, 128, 64, 64), float32],
%p120: Tensor[(512, 128, 1, 1), float32],
%p218: Tensor[(512, 1, 1), float32],
%p39: Tensor[(512, 1, 1), float32],
%p46: Tensor[(512, 1, 1), float32],
%p55: Tensor[(1, 512, 64, 64), float32])
-> Tensor[(1, 512, 64, 64), float32] {
%193 = nn.conv2d(%p023, %p120, channels=512, kernel_size=[1, 1]) # ty=Tensor[(1, 512, 64, 64), float32]
%194 = add(%193, %p218) # ty=Tensor[(1, 512, 64, 64), float32]
%195 = multiply(%194, %p39) # ty=Tensor[(1, 512, 64, 64), float32]
%196 = add(%195, %p46) # ty=Tensor[(1, 512, 64, 64), float32]
%197 = add(%196, %p55) # ty=Tensor[(1, 512, 64, 64), float32]
%198 = nn.relu(%197) # ty=Tensor[(1, 512, 64, 64), float32]
%198
}
%199 = %192(%187, %188, %189, %190, %191, %171) # ty=Tensor[(1, 512, 64, 64), float32]
%200 = meta.relay.Constant(id=61) # ty=Tensor[(128, 512, 1, 1), float32]
%201 = meta.relay.Constant(id=62) # ty=Tensor[(128, 1, 1), float32]
%202 = meta.relay.Constant(id=63) # ty=Tensor[(128, 1, 1), float32]
%203 = fn(%p024: Tensor[(1, 512, 64, 64), float32],
%p121: Tensor[(128, 512, 1, 1), float32],
%p219: Tensor[(128, 1, 1), float32],
%p310: Tensor[(128, 1, 1), float32])
-> Tensor[(1, 128, 64, 64), float32] {
%204 = nn.conv2d(%p024, %p121, channels=128, kernel_size=[1, 1]) # ty=Tensor[(1, 128, 64, 64), float32]
%205 = add(%204, %p219) # ty=Tensor[(1, 128, 64, 64), float32]
%206 = add(%205, %p310) # ty=Tensor[(1, 128, 64, 64), float32]
%207 = nn.relu(%206) # ty=Tensor[(1, 128, 64, 64), float32]
%207
}
%208 = %203(%199, %200, %201, %202) # ty=Tensor[(1, 128, 64, 64), float32]
%209 = meta.relay.Constant(id=64) # ty=Tensor[(128, 128, 3, 3), float32]
%210 = meta.relay.Constant(id=65) # ty=Tensor[(128, 1, 1), float32]
%211 = fn(%p025: Tensor[(1, 128, 64, 64), float32],
%p122: Tensor[(128, 128, 3, 3), float32],
%p220: Tensor[(128, 1, 1), float32])
-> Tensor[(1, 128, 64, 64), float32] {
%212 = nn.conv2d(%p025, %p122, padding=[1, 1], channels=128, kernel_size=[3, 3]) # ty=Tensor[(1, 128, 64, 64), float32]
%213 = add(%212, %p220) # ty=Tensor[(1, 128, 64, 64), float32]
%214 = nn.relu(%213) # ty=Tensor[(1, 128, 64, 64), float32]
%214
}
%215 = %211(%208, %209, %210) # ty=Tensor[(1, 128, 64, 64), float32]
%216 = meta.relay.Constant(id=66) # ty=Tensor[(512, 128, 1, 1), float32]
%217 = meta.relay.Constant(id=67) # ty=Tensor[(512, 1, 1), float32]
%218 = meta.relay.Constant(id=68) # ty=Tensor[(512, 1, 1), float32]
%219 = meta.relay.Constant(id=69) # ty=Tensor[(512, 1, 1), float32]
%220 = fn(%p026: Tensor[(1, 128, 64, 64), float32],
%p123: Tensor[(512, 128, 1, 1), float32],
%p221: Tensor[(512, 1, 1), float32],
%p311: Tensor[(512, 1, 1), float32],
%p47: Tensor[(512, 1, 1), float32],
%p56: Tensor[(1, 512, 64, 64), float32])
-> Tensor[(1, 512, 64, 64), float32] {
%221 = nn.conv2d(%p026, %p123, channels=512, kernel_size=[1, 1]) # ty=Tensor[(1, 512, 64, 64), float32]
%222 = add(%221, %p221) # ty=Tensor[(1, 512, 64, 64), float32]
%223 = multiply(%222, %p311) # ty=Tensor[(1, 512, 64, 64), float32]
%224 = add(%223, %p47) # ty=Tensor[(1, 512, 64, 64), float32]
%225 = add(%224, %p56) # ty=Tensor[(1, 512, 64, 64), float32]
%226 = nn.relu(%225) # ty=Tensor[(1, 512, 64, 64), float32]
%226
}
%227 = %220(%215, %216, %217, %218, %219, %199) # ty=Tensor[(1, 512, 64, 64), float32]
%228 = meta.relay.Constant(id=70) # ty=Tensor[(1280, 512, 1, 1), float32]
%229 = fn(%p027: Tensor[(1, 512, 64, 64), float32],
%p124: Tensor[(1280, 512, 1, 1), float32])
-> Tensor[(1, 1280, 32, 32), float32] {
%230 = nn.conv2d(%p027, %p124, strides=[2, 2], channels=1280, kernel_size=[1, 1]) # ty=Tensor[(1, 1280, 32, 32), float32]
%230
}
%231 = %229(%227, %228) # ty=Tensor[(1, 1280, 32, 32), float32]
%232 = meta.relay.Constant(id=71) # ty=Tensor[(256, 1, 1), float32]
%233 = meta.relay.Constant(id=72) # ty=Tensor[(256, 1, 1), float32]
%234 = fn(%p028: Tensor[(1, 1280, 32, 32), float32],
%p125: Tensor[(256, 1, 1), float32],
%p222: Tensor[(256, 1, 1), float32])
-> Tensor[(1, 256, 32, 32), float32] {
%235 = strided_slice(%p028, begin=[0, 0], end=[None, 256]) # ty=Tensor[(1, 256, 32, 32), float32]
%236 = add(%235, %p125) # ty=Tensor[(1, 256, 32, 32), float32]
%237 = add(%236, %p222) # ty=Tensor[(1, 256, 32, 32), float32]
%238 = nn.relu(%237) # ty=Tensor[(1, 256, 32, 32), float32]
%238
}
%239 = %234(%231, %232, %233) # ty=Tensor[(1, 256, 32, 32), float32]
%240 = meta.relay.Constant(id=73) # ty=Tensor[(256, 256, 3, 3), float32]
%241 = meta.relay.Constant(id=74) # ty=Tensor[(256, 1, 1), float32]
%242 = fn(%p029: Tensor[(1, 256, 32, 32), float32],
%p126: Tensor[(256, 256, 3, 3), float32],
%p223: Tensor[(256, 1, 1), float32])
-> Tensor[(1, 256, 32, 32), float32] {
%243 = nn.conv2d(%p029, %p126, padding=[1, 1], channels=256, kernel_size=[3, 3]) # ty=Tensor[(1, 256, 32, 32), float32]
%244 = add(%243, %p223) # ty=Tensor[(1, 256, 32, 32), float32]
%245 = nn.relu(%244) # ty=Tensor[(1, 256, 32, 32), float32]
%245
}
%246 = %242(%239, %240, %241) # ty=Tensor[(1, 256, 32, 32), float32]
%247 = meta.relay.Constant(id=75) # ty=Tensor[(1024, 256, 1, 1), float32]
%248 = meta.relay.Constant(id=76) # ty=Tensor[(1024, 1, 1), float32]
%249 = meta.relay.Constant(id=77) # ty=Tensor[(1024, 1, 1), float32]
%250 = meta.relay.Constant(id=78) # ty=Tensor[(1024, 1, 1), float32]
%251 = fn(%p030: Tensor[(1, 1280, 32, 32), float32])
-> Tensor[(1, 1024, 32, 32), float32] {
%252 = strided_slice(%p030, begin=[0, 256], end=[None, 1280]) # ty=Tensor[(1, 1024, 32, 32), float32]
%252
}
%253 = %251(%231) # ty=Tensor[(1, 1024, 32, 32), float32]
%254 = meta.relay.Constant(id=79) # ty=Tensor[(1024, 1, 1), float32]
%255 = meta.relay.Constant(id=80) # ty=Tensor[(1024, 1, 1), float32]
%256 = fn(%p031: Tensor[(1, 256, 32, 32), float32],
%p127: Tensor[(1024, 256, 1, 1), float32],
%p224: Tensor[(1024, 1, 1), float32],
%p312: Tensor[(1024, 1, 1), float32],
%p48: Tensor[(1024, 1, 1), float32],
%p57: Tensor[(1, 1024, 32, 32), float32],
%p62: Tensor[(1024, 1, 1), float32],
%p72: Tensor[(1024, 1, 1), float32])
-> Tensor[(1, 1024, 32, 32), float32] {
%257 = nn.conv2d(%p031, %p127, channels=1024, kernel_size=[1, 1]) # ty=Tensor[(1, 1024, 32, 32), float32]
%258 = add(%257, %p224) # ty=Tensor[(1, 1024, 32, 32), float32]
%259 = multiply(%258, %p312) # ty=Tensor[(1, 1024, 32, 32), float32]
%260 = add(%259, %p48) # ty=Tensor[(1, 1024, 32, 32), float32]
%261 = multiply(%p57, %p62) # ty=Tensor[(1, 1024, 32, 32), float32]
%262 = add(%261, %p72) # ty=Tensor[(1, 1024, 32, 32), float32]
%263 = add(%260, %262) # ty=Tensor[(1, 1024, 32, 32), float32]
%264 = nn.relu(%263) # ty=Tensor[(1, 1024, 32, 32), float32]
%264
}
%265 = %256(%246, %247, %248, %249, %250, %253, %254, %255) # ty=Tensor[(1, 1024, 32, 32), float32]
%266 = meta.relay.Constant(id=81) # ty=Tensor[(256, 1024, 1, 1), float32]
%267 = meta.relay.Constant(id=82) # ty=Tensor[(256, 1, 1), float32]
%268 = meta.relay.Constant(id=83) # ty=Tensor[(256, 1, 1), float32]
%269 = fn(%p032: Tensor[(1, 1024, 32, 32), float32],
%p128: Tensor[(256, 1024, 1, 1), float32],
%p225: Tensor[(256, 1, 1), float32],
%p313: Tensor[(256, 1, 1), float32])
-> Tensor[(1, 256, 32, 32), float32] {
%270 = nn.conv2d(%p032, %p128, channels=256, kernel_size=[1, 1]) # ty=Tensor[(1, 256, 32, 32), float32]
%271 = add(%270, %p225) # ty=Tensor[(1, 256, 32, 32), float32]
%272 = add(%271, %p313) # ty=Tensor[(1, 256, 32, 32), float32]
%273 = nn.relu(%272) # ty=Tensor[(1, 256, 32, 32), float32]
%273
}
%274 = %269(%265, %266, %267, %268) # ty=Tensor[(1, 256, 32, 32), float32]
%275 = meta.relay.Constant(id=84) # ty=Tensor[(256, 256, 3, 3), float32]
%276 = meta.relay.Constant(id=85) # ty=Tensor[(256, 1, 1), float32]
%277 = fn(%p033: Tensor[(1, 256, 32, 32), float32],
%p129: Tensor[(256, 256, 3, 3), float32],
%p226: Tensor[(256, 1, 1), float32])
-> Tensor[(1, 256, 32, 32), float32] {
%278 = nn.conv2d(%p033, %p129, padding=[1, 1], channels=256, kernel_size=[3, 3]) # ty=Tensor[(1, 256, 32, 32), float32]
%279 = add(%278, %p226) # ty=Tensor[(1, 256, 32, 32), float32]
%280 = nn.relu(%279) # ty=Tensor[(1, 256, 32, 32), float32]
%280
}
%281 = %277(%274, %275, %276) # ty=Tensor[(1, 256, 32, 32), float32]
%282 = meta.relay.Constant(id=86) # ty=Tensor[(1024, 256, 1, 1), float32]
%283 = meta.relay.Constant(id=87) # ty=Tensor[(1024, 1, 1), float32]
%284 = meta.relay.Constant(id=88) # ty=Tensor[(1024, 1, 1), float32]
%285 = meta.relay.Constant(id=89) # ty=Tensor[(1024, 1, 1), float32]
%286 = fn(%p034: Tensor[(1, 256, 32, 32), float32],
%p130: Tensor[(1024, 256, 1, 1), float32],
%p227: Tensor[(1024, 1, 1), float32],
%p314: Tensor[(1024, 1, 1), float32],
%p49: Tensor[(1024, 1, 1), float32],
%p58: Tensor[(1, 1024, 32, 32), float32])
-> Tensor[(1, 1024, 32, 32), float32] {
%287 = nn.conv2d(%p034, %p130, channels=1024, kernel_size=[1, 1]) # ty=Tensor[(1, 1024, 32, 32), float32]
%288 = add(%287, %p227) # ty=Tensor[(1, 1024, 32, 32), float32]
%289 = multiply(%288, %p314) # ty=Tensor[(1, 1024, 32, 32), float32]
%290 = add(%289, %p49) # ty=Tensor[(1, 1024, 32, 32), float32]
%291 = add(%290, %p58) # ty=Tensor[(1, 1024, 32, 32), float32]
%292 = nn.relu(%291) # ty=Tensor[(1, 1024, 32, 32), float32]
%292
}
%293 = %286(%281, %282, %283, %284, %285, %265) # ty=Tensor[(1, 1024, 32, 32), float32]
%294 = meta.relay.Constant(id=90) # ty=Tensor[(256, 1024, 1, 1), float32]
%295 = meta.relay.Constant(id=91) # ty=Tensor[(256, 1, 1), float32]
%296 = meta.relay.Constant(id=92) # ty=Tensor[(256, 1, 1), float32]
%297 = fn(%p035: Tensor[(1, 1024, 32, 32), float32],
%p131: Tensor[(256, 1024, 1, 1), float32],
%p228: Tensor[(256, 1, 1), float32],
%p315: Tensor[(256, 1, 1), float32])
-> Tensor[(1, 256, 32, 32), float32] {
%298 = nn.conv2d(%p035, %p131, channels=256, kernel_size=[1, 1]) # ty=Tensor[(1, 256, 32, 32), float32]
%299 = add(%298, %p228) # ty=Tensor[(1, 256, 32, 32), float32]
%300 = add(%299, %p315) # ty=Tensor[(1, 256, 32, 32), float32]
%301 = nn.relu(%300) # ty=Tensor[(1, 256, 32, 32), float32]
%301
}
%302 = %297(%293, %294, %295, %296) # ty=Tensor[(1, 256, 32, 32), float32]
%303 = meta.relay.Constant(id=93) # ty=Tensor[(256, 256, 3, 3), float32]
%304 = meta.relay.Constant(id=94) # ty=Tensor[(256, 1, 1), float32]
%305 = fn(%p036: Tensor[(1, 256, 32, 32), float32],
%p132: Tensor[(256, 256, 3, 3), float32],
%p229: Tensor[(256, 1, 1), float32])
-> Tensor[(1, 256, 32, 32), float32] {
%306 = nn.conv2d(%p036, %p132, padding=[1, 1], channels=256, kernel_size=[3, 3]) # ty=Tensor[(1, 256, 32, 32), float32]
%307 = add(%306, %p229) # ty=Tensor[(1, 256, 32, 32), float32]
%308 = nn.relu(%307) # ty=Tensor[(1, 256, 32, 32), float32]
%308
}
%309 = %305(%302, %303, %304) # ty=Tensor[(1, 256, 32, 32), float32]
%310 = meta.relay.Constant(id=95) # ty=Tensor[(1024, 256, 1, 1), float32]
%311 = meta.relay.Constant(id=96) # ty=Tensor[(1024, 1, 1), float32]
%312 = meta.relay.Constant(id=97) # ty=Tensor[(1024, 1, 1), float32]
%313 = meta.relay.Constant(id=98) # ty=Tensor[(1024, 1, 1), float32]
%314 = fn(%p037: Tensor[(1, 256, 32, 32), float32],
%p133: Tensor[(1024, 256, 1, 1), float32],
%p230: Tensor[(1024, 1, 1), float32],
%p316: Tensor[(1024, 1, 1), float32],
%p410: Tensor[(1024, 1, 1), float32],
%p59: Tensor[(1, 1024, 32, 32), float32])
-> Tensor[(1, 1024, 32, 32), float32] {
%315 = nn.conv2d(%p037, %p133, channels=1024, kernel_size=[1, 1]) # ty=Tensor[(1, 1024, 32, 32), float32]
%316 = add(%315, %p230) # ty=Tensor[(1, 1024, 32, 32), float32]
%317 = multiply(%316, %p316) # ty=Tensor[(1, 1024, 32, 32), float32]
%318 = add(%317, %p410) # ty=Tensor[(1, 1024, 32, 32), float32]
%319 = add(%318, %p59) # ty=Tensor[(1, 1024, 32, 32), float32]
%320 = nn.relu(%319) # ty=Tensor[(1, 1024, 32, 32), float32]
%320
}
%321 = %314(%309, %310, %311, %312, %313, %293) # ty=Tensor[(1, 1024, 32, 32), float32]
%322 = meta.relay.Constant(id=99) # ty=Tensor[(256, 1024, 1, 1), float32]
%323 = meta.relay.Constant(id=100) # ty=Tensor[(256, 1, 1), float32]
%324 = meta.relay.Constant(id=101) # ty=Tensor[(256, 1, 1), float32]
%325 = fn(%p038: Tensor[(1, 1024, 32, 32), float32],
%p134: Tensor[(256, 1024, 1, 1), float32],
%p231: Tensor[(256, 1, 1), float32],
%p317: Tensor[(256, 1, 1), float32])
-> Tensor[(1, 256, 32, 32), float32] {
%326 = nn.conv2d(%p038, %p134, channels=256, kernel_size=[1, 1]) # ty=Tensor[(1, 256, 32, 32), float32]
%327 = add(%326, %p231) # ty=Tensor[(1, 256, 32, 32), float32]
%328 = add(%327, %p317) # ty=Tensor[(1, 256, 32, 32), float32]
%329 = nn.relu(%328) # ty=Tensor[(1, 256, 32, 32), float32]
%329
}
%330 = %325(%321, %322, %323, %324) # ty=Tensor[(1, 256, 32, 32), float32]
%331 = meta.relay.Constant(id=102) # ty=Tensor[(256, 256, 3, 3), float32]
%332 = meta.relay.Constant(id=103) # ty=Tensor[(256, 1, 1), float32]
%333 = fn(%p039: Tensor[(1, 256, 32, 32), float32],
%p135: Tensor[(256, 256, 3, 3), float32],
%p232: Tensor[(256, 1, 1), float32])
-> Tensor[(1, 256, 32, 32), float32] {
%334 = nn.conv2d(%p039, %p135, padding=[1, 1], channels=256, kernel_size=[3, 3]) # ty=Tensor[(1, 256, 32, 32), float32]
%335 = add(%334, %p232) # ty=Tensor[(1, 256, 32, 32), float32]
%336 = nn.relu(%335) # ty=Tensor[(1, 256, 32, 32), float32]
%336
}
%337 = %333(%330, %331, %332) # ty=Tensor[(1, 256, 32, 32), float32]
%338 = meta.relay.Constant(id=104) # ty=Tensor[(1024, 256, 1, 1), float32]
%339 = meta.relay.Constant(id=105) # ty=Tensor[(1024, 1, 1), float32]
%340 = meta.relay.Constant(id=106) # ty=Tensor[(1024, 1, 1), float32]
%341 = meta.relay.Constant(id=107) # ty=Tensor[(1024, 1, 1), float32]
%342 = fn(%p040: Tensor[(1, 256, 32, 32), float32],
%p136: Tensor[(1024, 256, 1, 1), float32],
%p233: Tensor[(1024, 1, 1), float32],
%p318: Tensor[(1024, 1, 1), float32],
%p411: Tensor[(1024, 1, 1), float32],
%p510: Tensor[(1, 1024, 32, 32), float32])
-> Tensor[(1, 1024, 32, 32), float32] {
%343 = nn.conv2d(%p040, %p136, channels=1024, kernel_size=[1, 1]) # ty=Tensor[(1, 1024, 32, 32), float32]
%344 = add(%343, %p233) # ty=Tensor[(1, 1024, 32, 32), float32]
%345 = multiply(%344, %p318) # ty=Tensor[(1, 1024, 32, 32), float32]
%346 = add(%345, %p411) # ty=Tensor[(1, 1024, 32, 32), float32]
%347 = add(%346, %p510) # ty=Tensor[(1, 1024, 32, 32), float32]
%348 = nn.relu(%347) # ty=Tensor[(1, 1024, 32, 32), float32]
%348
}
%349 = %342(%337, %338, %339, %340, %341, %321) # ty=Tensor[(1, 1024, 32, 32), float32]
%350 = meta.relay.Constant(id=108) # ty=Tensor[(256, 1024, 1, 1), float32]
%351 = meta.relay.Constant(id=109) # ty=Tensor[(256, 1, 1), float32]
%352 = meta.relay.Constant(id=110) # ty=Tensor[(256, 1, 1), float32]
%353 = fn(%p041: Tensor[(1, 1024, 32, 32), float32],
%p137: Tensor[(256, 1024, 1, 1), float32],
%p234: Tensor[(256, 1, 1), float32],
%p319: Tensor[(256, 1, 1), float32])
-> Tensor[(1, 256, 32, 32), float32] {
%354 = nn.conv2d(%p041, %p137, channels=256, kernel_size=[1, 1]) # ty=Tensor[(1, 256, 32, 32), float32]
%355 = add(%354, %p234) # ty=Tensor[(1, 256, 32, 32), float32]
%356 = add(%355, %p319) # ty=Tensor[(1, 256, 32, 32), float32]
%357 = nn.relu(%356) # ty=Tensor[(1, 256, 32, 32), float32]
%357
}
%358 = %353(%349, %350, %351, %352) # ty=Tensor[(1, 256, 32, 32), float32]
%359 = meta.relay.Constant(id=111) # ty=Tensor[(256, 256, 3, 3), float32]
%360 = meta.relay.Constant(id=112) # ty=Tensor[(256, 1, 1), float32]
%361 = fn(%p042: Tensor[(1, 256, 32, 32), float32],
%p138: Tensor[(256, 256, 3, 3), float32],
%p235: Tensor[(256, 1, 1), float32])
-> Tensor[(1, 256, 32, 32), float32] {
%362 = nn.conv2d(%p042, %p138, padding=[1, 1], channels=256, kernel_size=[3, 3]) # ty=Tensor[(1, 256, 32, 32), float32]
%363 = add(%362, %p235) # ty=Tensor[(1, 256, 32, 32), float32]
%364 = nn.relu(%363) # ty=Tensor[(1, 256, 32, 32), float32]
%364
}
%365 = %361(%358, %359, %360) # ty=Tensor[(1, 256, 32, 32), float32]
%366 = meta.relay.Constant(id=113) # ty=Tensor[(1024, 256, 1, 1), float32]
%367 = meta.relay.Constant(id=114) # ty=Tensor[(1024, 1, 1), float32]
%368 = meta.relay.Constant(id=115) # ty=Tensor[(1024, 1, 1), float32]
%369 = meta.relay.Constant(id=116) # ty=Tensor[(1024, 1, 1), float32]
%370 = fn(%p043: Tensor[(1, 256, 32, 32), float32],
%p139: Tensor[(1024, 256, 1, 1), float32],
%p236: Tensor[(1024, 1, 1), float32],
%p320: Tensor[(1024, 1, 1), float32],
%p412: Tensor[(1024, 1, 1), float32],
%p511: Tensor[(1, 1024, 32, 32), float32])
-> Tensor[(1, 1024, 32, 32), float32] {
%371 = nn.conv2d(%p043, %p139, channels=1024, kernel_size=[1, 1]) # ty=Tensor[(1, 1024, 32, 32), float32]
%372 = add(%371, %p236) # ty=Tensor[(1, 1024, 32, 32), float32]
%373 = multiply(%372, %p320) # ty=Tensor[(1, 1024, 32, 32), float32]
%374 = add(%373, %p412) # ty=Tensor[(1, 1024, 32, 32), float32]
%375 = add(%374, %p511) # ty=Tensor[(1, 1024, 32, 32), float32]
%376 = nn.relu(%375) # ty=Tensor[(1, 1024, 32, 32), float32]
%376
}
%377 = %370(%365, %366, %367, %368, %369, %349) # ty=Tensor[(1, 1024, 32, 32), float32]
%378 = meta.relay.Constant(id=117) # ty=Tensor[(256, 1024, 1, 1), float32]
%379 = meta.relay.Constant(id=118) # ty=Tensor[(256, 1, 1), float32]
%380 = meta.relay.Constant(id=119) # ty=Tensor[(256, 1, 1), float32]
%381 = fn(%p044: Tensor[(1, 1024, 32, 32), float32],
%p140: Tensor[(256, 1024, 1, 1), float32],
%p237: Tensor[(256, 1, 1), float32],
%p321: Tensor[(256, 1, 1), float32])
-> Tensor[(1, 256, 32, 32), float32] {
%382 = nn.conv2d(%p044, %p140, channels=256, kernel_size=[1, 1]) # ty=Tensor[(1, 256, 32, 32), float32]
%383 = add(%382, %p237) # ty=Tensor[(1, 256, 32, 32), float32]
%384 = add(%383, %p321) # ty=Tensor[(1, 256, 32, 32), float32]
%385 = nn.relu(%384) # ty=Tensor[(1, 256, 32, 32), float32]
%385
}
%386 = %381(%377, %378, %379, %380) # ty=Tensor[(1, 256, 32, 32), float32]
%387 = meta.relay.Constant(id=120) # ty=Tensor[(256, 256, 3, 3), float32]
%388 = meta.relay.Constant(id=121) # ty=Tensor[(256, 1, 1), float32]
%389 = fn(%p045: Tensor[(1, 256, 32, 32), float32],
%p141: Tensor[(256, 256, 3, 3), float32],
%p238: Tensor[(256, 1, 1), float32])
-> Tensor[(1, 256, 32, 32), float32] {
%390 = nn.conv2d(%p045, %p141, padding=[1, 1], channels=256, kernel_size=[3, 3]) # ty=Tensor[(1, 256, 32, 32), float32]
%391 = add(%390, %p238) # ty=Tensor[(1, 256, 32, 32), float32]
%392 = nn.relu(%391) # ty=Tensor[(1, 256, 32, 32), float32]
%392
}
%393 = %389(%386, %387, %388) # ty=Tensor[(1, 256, 32, 32), float32]
%394 = meta.relay.Constant(id=122) # ty=Tensor[(1024, 256, 1, 1), float32]
%395 = meta.relay.Constant(id=123) # ty=Tensor[(1024, 1, 1), float32]
%396 = meta.relay.Constant(id=124) # ty=Tensor[(1024, 1, 1), float32]
%397 = meta.relay.Constant(id=125) # ty=Tensor[(1024, 1, 1), float32]
%398 = fn(%p046: Tensor[(1, 256, 32, 32), float32],
%p142: Tensor[(1024, 256, 1, 1), float32],
%p239: Tensor[(1024, 1, 1), float32],
%p322: Tensor[(1024, 1, 1), float32],
%p413: Tensor[(1024, 1, 1), float32],
%p512: Tensor[(1, 1024, 32, 32), float32])
-> Tensor[(1, 1024, 32, 32), float32] {
%399 = nn.conv2d(%p046, %p142, channels=1024, kernel_size=[1, 1]) # ty=Tensor[(1, 1024, 32, 32), float32]
%400 = add(%399, %p239) # ty=Tensor[(1, 1024, 32, 32), float32]
%401 = multiply(%400, %p322) # ty=Tensor[(1, 1024, 32, 32), float32]
%402 = add(%401, %p413) # ty=Tensor[(1, 1024, 32, 32), float32]
%403 = add(%402, %p512) # ty=Tensor[(1, 1024, 32, 32), float32]
%404 = nn.relu(%403) # ty=Tensor[(1, 1024, 32, 32), float32]
%404
}
%405 = %398(%393, %394, %395, %396, %397, %377) # ty=Tensor[(1, 1024, 32, 32), float32]
%406 = meta.relay.Constant(id=126) # ty=Tensor[(100, 1024, 3, 3), float32]
%407 = fn(%p047: Tensor[(1, 1024, 32, 32), float32],
%p143: Tensor[(100, 1024, 3, 3), float32])
-> Tensor[(1, 100, 32, 32), float32] {
%408 = nn.conv2d(%p047, %p143, padding=[1, 1], channels=100, kernel_size=[3, 3]) # ty=Tensor[(1, 100, 32, 32), float32]
%408
}
%409 = %407(%405, %406) # ty=Tensor[(1, 100, 32, 32), float32]
%410 = meta.relay.Constant(id=127) # ty=Tensor[(84, 1, 1), float32]
%411 = fn(%p048: Tensor[(1, 100, 32, 32), float32],
%p144: Tensor[(84, 1, 1), float32])
-> Tensor[(1, 84, 32, 32), float32] {
%412 = strided_slice(%p048, begin=[0, 0], end=[None, 84]) # ty=Tensor[(1, 84, 32, 32), float32]
%413 = add(%412, %p144) # ty=Tensor[(1, 84, 32, 32), float32]
%413
}
%414 = %411(%409, %410) # ty=Tensor[(1, 84, 32, 32), float32]
%415 = meta.relay.Constant(id=128) # ty=Tensor[(2560, 1024, 1, 1), float32]
%416 = fn(%p049: Tensor[(1, 1024, 32, 32), float32],
%p145: Tensor[(2560, 1024, 1, 1), float32])
-> Tensor[(1, 2560, 16, 16), float32] {
%417 = nn.conv2d(%p049, %p145, strides=[2, 2], channels=2560, kernel_size=[1, 1]) # ty=Tensor[(1, 2560, 16, 16), float32]
%417
}
%418 = %416(%405, %415) # ty=Tensor[(1, 2560, 16, 16), float32]
%419 = meta.relay.Constant(id=129) # ty=Tensor[(512, 1, 1), float32]
%420 = meta.relay.Constant(id=130) # ty=Tensor[(512, 1, 1), float32]
%421 = fn(%p050: Tensor[(1, 2560, 16, 16), float32],
%p146: Tensor[(512, 1, 1), float32],
%p240: Tensor[(512, 1, 1), float32])
-> Tensor[(1, 512, 16, 16), float32] {
%422 = strided_slice(%p050, begin=[0, 0], end=[None, 512]) # ty=Tensor[(1, 512, 16, 16), float32]
%423 = add(%422, %p146) # ty=Tensor[(1, 512, 16, 16), float32]
%424 = add(%423, %p240) # ty=Tensor[(1, 512, 16, 16), float32]
%425 = nn.relu(%424) # ty=Tensor[(1, 512, 16, 16), float32]
%425
}
%426 = %421(%418, %419, %420) # ty=Tensor[(1, 512, 16, 16), float32]
%427 = meta.relay.Constant(id=131) # ty=Tensor[(512, 512, 3, 3), float32]
%428 = meta.relay.Constant(id=132) # ty=Tensor[(512, 1, 1), float32]
%429 = fn(%p051: Tensor[(1, 512, 16, 16), float32],
%p147: Tensor[(512, 512, 3, 3), float32],
%p241: Tensor[(512, 1, 1), float32])
-> Tensor[(1, 512, 16, 16), float32] {
%430 = nn.conv2d(%p051, %p147, padding=[1, 1], channels=512, kernel_size=[3, 3]) # ty=Tensor[(1, 512, 16, 16), float32]
%431 = add(%430, %p241) # ty=Tensor[(1, 512, 16, 16), float32]
%432 = nn.relu(%431) # ty=Tensor[(1, 512, 16, 16), float32]
%432
}
%433 = %429(%426, %427, %428) # ty=Tensor[(1, 512, 16, 16), float32]
%434 = meta.relay.Constant(id=133) # ty=Tensor[(2048, 512, 1, 1), float32]
%435 = meta.relay.Constant(id=134) # ty=Tensor[(2048, 1, 1), float32]
%436 = meta.relay.Constant(id=135) # ty=Tensor[(2048, 1, 1), float32]
%437 = meta.relay.Constant(id=136) # ty=Tensor[(2048, 1, 1), float32]
%438 = fn(%p052: Tensor[(1, 2560, 16, 16), float32])
-> Tensor[(1, 2048, 16, 16), float32] {
%439 = strided_slice(%p052, begin=[0, 512], end=[None, 2560]) # ty=Tensor[(1, 2048, 16, 16), float32]
%439
}
%440 = %438(%418) # ty=Tensor[(1, 2048, 16, 16), float32]
%441 = meta.relay.Constant(id=137) # ty=Tensor[(2048, 1, 1), float32]
%442 = meta.relay.Constant(id=138) # ty=Tensor[(2048, 1, 1), float32]
%443 = fn(%p053: Tensor[(1, 512, 16, 16), float32],
%p148: Tensor[(2048, 512, 1, 1), float32],
%p242: Tensor[(2048, 1, 1), float32],
%p323: Tensor[(2048, 1, 1), float32],
%p414: Tensor[(2048, 1, 1), float32],
%p513: Tensor[(1, 2048, 16, 16), float32],
%p63: Tensor[(2048, 1, 1), float32],
%p73: Tensor[(2048, 1, 1), float32])
-> Tensor[(1, 2048, 16, 16), float32] {
%444 = nn.conv2d(%p053, %p148, channels=2048, kernel_size=[1, 1]) # ty=Tensor[(1, 2048, 16, 16), float32]
%445 = add(%444, %p242) # ty=Tensor[(1, 2048, 16, 16), float32]
%446 = multiply(%445, %p323) # ty=Tensor[(1, 2048, 16, 16), float32]
%447 = add(%446, %p414) # ty=Tensor[(1, 2048, 16, 16), float32]
%448 = multiply(%p513, %p63) # ty=Tensor[(1, 2048, 16, 16), float32]
%449 = add(%448, %p73) # ty=Tensor[(1, 2048, 16, 16), float32]
%450 = add(%447, %449) # ty=Tensor[(1, 2048, 16, 16), float32]
%451 = nn.relu(%450) # ty=Tensor[(1, 2048, 16, 16), float32]
%451
}
%452 = %443(%433, %434, %435, %436, %437, %440, %441, %442) # ty=Tensor[(1, 2048, 16, 16), float32]
%453 = meta.relay.Constant(id=139) # ty=Tensor[(512, 2048, 1, 1), float32]
%454 = meta.relay.Constant(id=140) # ty=Tensor[(512, 1, 1), float32]
%455 = meta.relay.Constant(id=141) # ty=Tensor[(512, 1, 1), float32]
%456 = fn(%p054: Tensor[(1, 2048, 16, 16), float32],
%p149: Tensor[(512, 2048, 1, 1), float32],
%p243: Tensor[(512, 1, 1), float32],
%p324: Tensor[(512, 1, 1), float32])
-> Tensor[(1, 512, 16, 16), float32] {
%457 = nn.conv2d(%p054, %p149, channels=512, kernel_size=[1, 1]) # ty=Tensor[(1, 512, 16, 16), float32]
%458 = add(%457, %p243) # ty=Tensor[(1, 512, 16, 16), float32]
%459 = add(%458, %p324) # ty=Tensor[(1, 512, 16, 16), float32]
%460 = nn.relu(%459) # ty=Tensor[(1, 512, 16, 16), float32]
%460
}
%461 = %456(%452, %453, %454, %455) # ty=Tensor[(1, 512, 16, 16), float32]
%462 = meta.relay.Constant(id=142) # ty=Tensor[(512, 512, 3, 3), float32]
%463 = meta.relay.Constant(id=143) # ty=Tensor[(512, 1, 1), float32]
%464 = fn(%p055: Tensor[(1, 512, 16, 16), float32],
%p150: Tensor[(512, 512, 3, 3), float32],
%p244: Tensor[(512, 1, 1), float32])
-> Tensor[(1, 512, 16, 16), float32] {
%465 = nn.conv2d(%p055, %p150, padding=[1, 1], channels=512, kernel_size=[3, 3]) # ty=Tensor[(1, 512, 16, 16), float32]
%466 = add(%465, %p244) # ty=Tensor[(1, 512, 16, 16), float32]
%467 = nn.relu(%466) # ty=Tensor[(1, 512, 16, 16), float32]
%467
}
%468 = %464(%461, %462, %463) # ty=Tensor[(1, 512, 16, 16), float32]
%469 = meta.relay.Constant(id=144) # ty=Tensor[(2048, 512, 1, 1), float32]
%470 = meta.relay.Constant(id=145) # ty=Tensor[(2048, 1, 1), float32]
%471 = meta.relay.Constant(id=146) # ty=Tensor[(2048, 1, 1), float32]
%472 = meta.relay.Constant(id=147) # ty=Tensor[(2048, 1, 1), float32]
%473 = fn(%p056: Tensor[(1, 512, 16, 16), float32],
%p151: Tensor[(2048, 512, 1, 1), float32],
%p245: Tensor[(2048, 1, 1), float32],
%p325: Tensor[(2048, 1, 1), float32],
%p415: Tensor[(2048, 1, 1), float32],
%p514: Tensor[(1, 2048, 16, 16), float32])
-> Tensor[(1, 2048, 16, 16), float32] {
%474 = nn.conv2d(%p056, %p151, channels=2048, kernel_size=[1, 1]) # ty=Tensor[(1, 2048, 16, 16), float32]
%475 = add(%474, %p245) # ty=Tensor[(1, 2048, 16, 16), float32]
%476 = multiply(%475, %p325) # ty=Tensor[(1, 2048, 16, 16), float32]
%477 = add(%476, %p415) # ty=Tensor[(1, 2048, 16, 16), float32]
%478 = add(%477, %p514) # ty=Tensor[(1, 2048, 16, 16), float32]
%479 = nn.relu(%478) # ty=Tensor[(1, 2048, 16, 16), float32]
%479
}
%480 = %473(%468, %469, %470, %471, %472, %452) # ty=Tensor[(1, 2048, 16, 16), float32]
%481 = meta.relay.Constant(id=148) # ty=Tensor[(512, 2048, 1, 1), float32]
%482 = meta.relay.Constant(id=149) # ty=Tensor[(512, 1, 1), float32]
%483 = meta.relay.Constant(id=150) # ty=Tensor[(512, 1, 1), float32]
%484 = fn(%p057: Tensor[(1, 2048, 16, 16), float32],
%p152: Tensor[(512, 2048, 1, 1), float32],
%p246: Tensor[(512, 1, 1), float32],
%p326: Tensor[(512, 1, 1), float32])
-> Tensor[(1, 512, 16, 16), float32] {
%485 = nn.conv2d(%p057, %p152, channels=512, kernel_size=[1, 1]) # ty=Tensor[(1, 512, 16, 16), float32]
%486 = add(%485, %p246) # ty=Tensor[(1, 512, 16, 16), float32]
%487 = add(%486, %p326) # ty=Tensor[(1, 512, 16, 16), float32]
%488 = nn.relu(%487) # ty=Tensor[(1, 512, 16, 16), float32]
%488
}
%489 = %484(%480, %481, %482, %483) # ty=Tensor[(1, 512, 16, 16), float32]
%490 = meta.relay.Constant(id=151) # ty=Tensor[(512, 512, 3, 3), float32]
%491 = meta.relay.Constant(id=152) # ty=Tensor[(512, 1, 1), float32]
%492 = fn(%p058: Tensor[(1, 512, 16, 16), float32],
%p153: Tensor[(512, 512, 3, 3), float32],
%p247: Tensor[(512, 1, 1), float32])
-> Tensor[(1, 512, 16, 16), float32] {
%493 = nn.conv2d(%p058, %p153, padding=[1, 1], channels=512, kernel_size=[3, 3]) # ty=Tensor[(1, 512, 16, 16), float32]
%494 = add(%493, %p247) # ty=Tensor[(1, 512, 16, 16), float32]
%495 = nn.relu(%494) # ty=Tensor[(1, 512, 16, 16), float32]
%495
}
%496 = %492(%489, %490, %491) # ty=Tensor[(1, 512, 16, 16), float32]
%497 = meta.relay.Constant(id=153) # ty=Tensor[(2048, 512, 1, 1), float32]
%498 = meta.relay.Constant(id=154) # ty=Tensor[(2048, 1, 1), float32]
%499 = meta.relay.Constant(id=155) # ty=Tensor[(2048, 1, 1), float32]
%500 = meta.relay.Constant(id=156) # ty=Tensor[(2048, 1, 1), float32]
%501 = fn(%p059: Tensor[(1, 512, 16, 16), float32],
%p154: Tensor[(2048, 512, 1, 1), float32],
%p248: Tensor[(2048, 1, 1), float32],
%p327: Tensor[(2048, 1, 1), float32],
%p416: Tensor[(2048, 1, 1), float32],
%p515: Tensor[(1, 2048, 16, 16), float32])
-> Tensor[(1, 2048, 16, 16), float32] {
%502 = nn.conv2d(%p059, %p154, channels=2048, kernel_size=[1, 1]) # ty=Tensor[(1, 2048, 16, 16), float32]
%503 = add(%502, %p248) # ty=Tensor[(1, 2048, 16, 16), float32]
%504 = multiply(%503, %p327) # ty=Tensor[(1, 2048, 16, 16), float32]
%505 = add(%504, %p416) # ty=Tensor[(1, 2048, 16, 16), float32]
%506 = add(%505, %p515) # ty=Tensor[(1, 2048, 16, 16), float32]
%507 = nn.relu(%506) # ty=Tensor[(1, 2048, 16, 16), float32]
%507
}
%508 = %501(%496, %497, %498, %499, %500, %480) # ty=Tensor[(1, 2048, 16, 16), float32]
%509 = meta.relay.Constant(id=157) # ty=Tensor[(150, 2048, 3, 3), float32]
%510 = fn(%p060: Tensor[(1, 2048, 16, 16), float32],
%p155: Tensor[(150, 2048, 3, 3), float32])
-> Tensor[(1, 150, 16, 16), float32] {
%511 = nn.conv2d(%p060, %p155, padding=[1, 1], channels=150, kernel_size=[3, 3]) # ty=Tensor[(1, 150, 16, 16), float32]
%511
}
%512 = %510(%508, %509) # ty=Tensor[(1, 150, 16, 16), float32]
%513 = meta.relay.Constant(id=158) # ty=Tensor[(126, 1, 1), float32]
%514 = fn(%p061: Tensor[(1, 150, 16, 16), float32],
%p156: Tensor[(126, 1, 1), float32])
-> Tensor[(1, 126, 16, 16), float32] {
%515 = strided_slice(%p061, begin=[0, 0], end=[None, 126]) # ty=Tensor[(1, 126, 16, 16), float32]
%516 = add(%515, %p156) # ty=Tensor[(1, 126, 16, 16), float32]
%516
}
%517 = %514(%512, %513) # ty=Tensor[(1, 126, 16, 16), float32]
%518 = meta.relay.Constant(id=159) # ty=Tensor[(512, 2048, 1, 1), float32]
%519 = meta.relay.Constant(id=160) # ty=Tensor[(512, 1, 1), float32]
%520 = fn(%p062: Tensor[(1, 2048, 16, 16), float32],
%p157: Tensor[(512, 2048, 1, 1), float32],
%p249: Tensor[(512, 1, 1), float32])
-> Tensor[(1, 512, 16, 16), float32] {
%521 = nn.conv2d(%p062, %p157, channels=512, kernel_size=[1, 1]) # ty=Tensor[(1, 512, 16, 16), float32]
%522 = add(%521, %p249) # ty=Tensor[(1, 512, 16, 16), float32]
%523 = nn.relu(%522) # ty=Tensor[(1, 512, 16, 16), float32]
%523
}
%524 = %520(%508, %518, %519) # ty=Tensor[(1, 512, 16, 16), float32]
%525 = meta.relay.Constant(id=161) # ty=Tensor[(512, 512, 3, 3), float32]
%526 = meta.relay.Constant(id=162) # ty=Tensor[(512, 1, 1), float32]
%527 = fn(%p063: Tensor[(1, 512, 16, 16), float32],
%p158: Tensor[(512, 512, 3, 3), float32],
%p250: Tensor[(512, 1, 1), float32])
-> Tensor[(1, 512, 8, 8), float32] {
%528 = nn.conv2d(%p063, %p158, strides=[2, 2], padding=[1, 1], channels=512, kernel_size=[3, 3]) # ty=Tensor[(1, 512, 8, 8), float32]
%529 = add(%528, %p250) # ty=Tensor[(1, 512, 8, 8), float32]
%530 = nn.relu(%529) # ty=Tensor[(1, 512, 8, 8), float32]
%530
}
%531 = %527(%524, %525, %526) # ty=Tensor[(1, 512, 8, 8), float32]
%532 = meta.relay.Constant(id=163) # ty=Tensor[(150, 512, 3, 3), float32]
%533 = fn(%p064: Tensor[(1, 512, 8, 8), float32],
%p159: Tensor[(150, 512, 3, 3), float32])
-> Tensor[(1, 150, 8, 8), float32] {
%534 = nn.conv2d(%p064, %p159, padding=[1, 1], channels=150, kernel_size=[3, 3]) # ty=Tensor[(1, 150, 8, 8), float32]
%534
}
%535 = %533(%531, %532) # ty=Tensor[(1, 150, 8, 8), float32]
%536 = meta.relay.Constant(id=164) # ty=Tensor[(126, 1, 1), float32]
%537 = fn(%p065: Tensor[(1, 150, 8, 8), float32],
%p160: Tensor[(126, 1, 1), float32])
-> Tensor[(1, 126, 8, 8), float32] {
%538 = strided_slice(%p065, begin=[0, 0], end=[None, 126]) # ty=Tensor[(1, 126, 8, 8), float32]
%539 = add(%538, %p160) # ty=Tensor[(1, 126, 8, 8), float32]
%539
}
%540 = %537(%535, %536) # ty=Tensor[(1, 126, 8, 8), float32]
%541 = meta.relay.Constant(id=165) # ty=Tensor[(512, 512, 1, 1), float32]
%542 = meta.relay.Constant(id=166) # ty=Tensor[(512, 1, 1), float32]
%543 = fn(%p066: Tensor[(1, 512, 8, 8), float32],
%p161: Tensor[(512, 512, 1, 1), float32],
%p251: Tensor[(512, 1, 1), float32])
-> Tensor[(1, 512, 8, 8), float32] {
%544 = nn.conv2d(%p066, %p161, channels=512, kernel_size=[1, 1]) # ty=Tensor[(1, 512, 8, 8), float32]
%545 = add(%544, %p251) # ty=Tensor[(1, 512, 8, 8), float32]
%546 = nn.relu(%545) # ty=Tensor[(1, 512, 8, 8), float32]
%546
}
%547 = %543(%531, %541, %542) # ty=Tensor[(1, 512, 8, 8), float32]
%548 = meta.relay.Constant(id=167) # ty=Tensor[(512, 512, 3, 3), float32]
%549 = meta.relay.Constant(id=168) # ty=Tensor[(512, 1, 1), float32]
%550 = fn(%p067: Tensor[(1, 512, 8, 8), float32],
%p162: Tensor[(512, 512, 3, 3), float32],
%p252: Tensor[(512, 1, 1), float32])
-> Tensor[(1, 512, 4, 4), float32] {
%551 = nn.conv2d(%p067, %p162, strides=[2, 2], padding=[1, 1], channels=512, kernel_size=[3, 3]) # ty=Tensor[(1, 512, 4, 4), float32]
%552 = add(%551, %p252) # ty=Tensor[(1, 512, 4, 4), float32]
%553 = nn.relu(%552) # ty=Tensor[(1, 512, 4, 4), float32]
%553
}
%554 = %550(%547, %548, %549) # ty=Tensor[(1, 512, 4, 4), float32]
%555 = meta.relay.Constant(id=169) # ty=Tensor[(150, 512, 3, 3), float32]
%556 = fn(%p068: Tensor[(1, 512, 4, 4), float32],
%p163: Tensor[(150, 512, 3, 3), float32])
-> Tensor[(1, 150, 4, 4), float32] {
%557 = nn.conv2d(%p068, %p163, padding=[1, 1], channels=150, kernel_size=[3, 3]) # ty=Tensor[(1, 150, 4, 4), float32]
%557
}
%558 = %556(%554, %555) # ty=Tensor[(1, 150, 4, 4), float32]
%559 = meta.relay.Constant(id=170) # ty=Tensor[(126, 1, 1), float32]
%560 = fn(%p069: Tensor[(1, 150, 4, 4), float32],
%p164: Tensor[(126, 1, 1), float32])
-> Tensor[(1, 126, 4, 4), float32] {
%561 = strided_slice(%p069, begin=[0, 0], end=[None, 126]) # ty=Tensor[(1, 126, 4, 4), float32]
%562 = add(%561, %p164) # ty=Tensor[(1, 126, 4, 4), float32]
%562
}
%563 = %560(%558, %559) # ty=Tensor[(1, 126, 4, 4), float32]
%564 = meta.relay.Constant(id=171) # ty=Tensor[(256, 512, 1, 1), float32]
%565 = meta.relay.Constant(id=172) # ty=Tensor[(256, 1, 1), float32]
%566 = fn(%p070: Tensor[(1, 512, 4, 4), float32],
%p165: Tensor[(256, 512, 1, 1), float32],
%p253: Tensor[(256, 1, 1), float32])
-> Tensor[(1, 256, 4, 4), float32] {
%567 = nn.conv2d(%p070, %p165, channels=256, kernel_size=[1, 1]) # ty=Tensor[(1, 256, 4, 4), float32]
%568 = add(%567, %p253) # ty=Tensor[(1, 256, 4, 4), float32]
%569 = nn.relu(%568) # ty=Tensor[(1, 256, 4, 4), float32]
%569
}
%570 = %566(%554, %564, %565) # ty=Tensor[(1, 256, 4, 4), float32]
%571 = meta.relay.Constant(id=173) # ty=Tensor[(256, 256, 3, 3), float32]
%572 = meta.relay.Constant(id=174) # ty=Tensor[(256, 1, 1), float32]
%573 = fn(%p071: Tensor[(1, 256, 4, 4), float32],
%p166: Tensor[(256, 256, 3, 3), float32],
%p254: Tensor[(256, 1, 1), float32])
-> Tensor[(1, 256, 2, 2), float32] {
%574 = nn.conv2d(%p071, %p166, strides=[2, 2], padding=[1, 1], channels=256, kernel_size=[3, 3]) # ty=Tensor[(1, 256, 2, 2), float32]
%575 = add(%574, %p254) # ty=Tensor[(1, 256, 2, 2), float32]
%576 = nn.relu(%575) # ty=Tensor[(1, 256, 2, 2), float32]
%576
}
%577 = %573(%570, %571, %572) # ty=Tensor[(1, 256, 2, 2), float32]
%578 = meta.relay.Constant(id=175) # ty=Tensor[(100, 256, 3, 3), float32]
%579 = fn(%p072: Tensor[(1, 256, 2, 2), float32],
%p167: Tensor[(100, 256, 3, 3), float32])
-> Tensor[(1, 100, 2, 2), float32] {
%580 = nn.conv2d(%p072, %p167, padding=[1, 1], channels=100, kernel_size=[3, 3]) # ty=Tensor[(1, 100, 2, 2), float32]
%580
}
%581 = %579(%577, %578) # ty=Tensor[(1, 100, 2, 2), float32]
%582 = meta.relay.Constant(id=176) # ty=Tensor[(84, 1, 1), float32]
%583 = fn(%p073: Tensor[(1, 100, 2, 2), float32],
%p168: Tensor[(84, 1, 1), float32])
-> Tensor[(1, 84, 2, 2), float32] {
%584 = strided_slice(%p073, begin=[0, 0], end=[None, 84]) # ty=Tensor[(1, 84, 2, 2), float32]
%585 = add(%584, %p168) # ty=Tensor[(1, 84, 2, 2), float32]
%585
}
%586 = %583(%581, %582) # ty=Tensor[(1, 84, 2, 2), float32]
%587 = meta.relay.Constant(id=177) # ty=Tensor[(256, 256, 1, 1), float32]
%588 = meta.relay.Constant(id=178) # ty=Tensor[(256, 1, 1), float32]
%589 = fn(%p074: Tensor[(1, 256, 2, 2), float32],
%p169: Tensor[(256, 256, 1, 1), float32],
%p255: Tensor[(256, 1, 1), float32])
-> Tensor[(1, 256, 2, 2), float32] {
%590 = nn.conv2d(%p074, %p169, channels=256, kernel_size=[1, 1]) # ty=Tensor[(1, 256, 2, 2), float32]
%591 = add(%590, %p255) # ty=Tensor[(1, 256, 2, 2), float32]
%592 = nn.relu(%591) # ty=Tensor[(1, 256, 2, 2), float32]
%592
}
%593 = %589(%577, %587, %588) # ty=Tensor[(1, 256, 2, 2), float32]
%594 = meta.relay.Constant(id=179) # ty=Tensor[(256, 256, 3, 3), float32]
%595 = meta.relay.Constant(id=180) # ty=Tensor[(256, 1, 1), float32]
%596 = fn(%p075: Tensor[(1, 256, 2, 2), float32],
%p170: Tensor[(256, 256, 3, 3), float32],
%p256: Tensor[(256, 1, 1), float32])
-> Tensor[(1, 256, 1, 1), float32] {
%597 = nn.conv2d(%p075, %p170, strides=[2, 2], padding=[1, 1], channels=256, kernel_size=[3, 3]) # ty=Tensor[(1, 256, 1, 1), float32]
%598 = add(%597, %p256) # ty=Tensor[(1, 256, 1, 1), float32]
%599 = nn.relu(%598) # ty=Tensor[(1, 256, 1, 1), float32]
%599
}
%600 = %596(%593, %594, %595) # ty=Tensor[(1, 256, 1, 1), float32]
%601 = meta.relay.Constant(id=181) # ty=Tensor[(100, 256, 3, 3), float32]
%602 = fn(%p076: Tensor[(1, 256, 1, 1), float32],
%p171: Tensor[(100, 256, 3, 3), float32])
-> Tensor[(1, 100, 1, 1), float32] {
%603 = nn.conv2d(%p076, %p171, padding=[1, 1], channels=100, kernel_size=[3, 3]) # ty=Tensor[(1, 100, 1, 1), float32]
%603
}
%604 = %602(%600, %601) # ty=Tensor[(1, 100, 1, 1), float32]
%605 = meta.relay.Constant(id=182) # ty=Tensor[(84, 1, 1), float32]
%606 = fn(%p077: Tensor[(1, 100, 1, 1), float32],
%p172: Tensor[(84, 1, 1), float32])
-> Tensor[(1, 84, 1, 1), float32] {
%607 = strided_slice(%p077, begin=[0, 0], end=[None, 84]) # ty=Tensor[(1, 84, 1, 1), float32]
%608 = add(%607, %p172) # ty=Tensor[(1, 84, 1, 1), float32]
%608
}
%609 = %606(%604, %605) # ty=Tensor[(1, 84, 1, 1), float32]
%610 = fn(%p078: Tensor[(1, 84, 32, 32), float32],
%p173: Tensor[(1, 126, 16, 16), float32],
%p257: Tensor[(1, 126, 8, 8), float32],
%p328: Tensor[(1, 126, 4, 4), float32],
%p417: Tensor[(1, 84, 2, 2), float32],
%p516: Tensor[(1, 84, 1, 1), float32])
-> Tensor[(1, 6132, 21), float32] {
%611 = transpose(%p078, axes=[0, 2, 3, 1]) # ty=Tensor[(1, 32, 32, 84), float32]
%612 = nn.batch_flatten(%611) # ty=Tensor[(1, 86016), float32]
%613 = transpose(%p173, axes=[0, 2, 3, 1]) # ty=Tensor[(1, 16, 16, 126), float32]
%614 = nn.batch_flatten(%613) # ty=Tensor[(1, 32256), float32]
%615 = transpose(%p257, axes=[0, 2, 3, 1]) # ty=Tensor[(1, 8, 8, 126), float32]
%616 = nn.batch_flatten(%615) # ty=Tensor[(1, 8064), float32]
%617 = transpose(%p328, axes=[0, 2, 3, 1]) # ty=Tensor[(1, 4, 4, 126), float32]
%618 = nn.batch_flatten(%617) # ty=Tensor[(1, 2016), float32]
%619 = transpose(%p417, axes=[0, 2, 3, 1]) # ty=Tensor[(1, 2, 2, 84), float32]
%620 = nn.batch_flatten(%619) # ty=Tensor[(1, 336), float32]
%621 = transpose(%p516, axes=[0, 2, 3, 1]) # ty=Tensor[(1, 1, 1, 84), float32]
%622 = nn.batch_flatten(%621) # ty=Tensor[(1, 84), float32]
%623 = (%612, %614, %616, %618, %620, %622)
%624 = concatenate(%623, axis=1) # ty=Tensor[(1, 128772), float32]
%625 = reshape(%624, newshape=[0, -1, 21]) # ty=Tensor[(1, 6132, 21), float32]
%625
}
%626 = %610(%414, %517, %540, %563, %586, %609) # ty=Tensor[(1, 6132, 21), float32]
%627 = fn(%p079: Tensor[(1, 6132, 21), float32])
-> Tensor[(1, 6132, 21), float32] {
%628 = nn.softmax(%p079) # ty=Tensor[(1, 6132, 21), float32]
%628
}
%629 = %627(%626) # ty=Tensor[(1, 6132, 21), float32]
%630 = fn(%p080: Tensor[(1, 6132, 21), float32])
-> Tensor[(1, 6132, 1), float32] {
%631 = slice_axis(%p080, meta.relay.attrs.SliceAxisAttrs(id=183)) # ty=Tensor[(1, 6132, 1), float32]
%632 = zeros_like(%631) # ty=Tensor[(1, 6132, 1), float32]
%632
}
%633 = %630(%629) # ty=Tensor[(1, 6132, 1), float32]
%634 = fn(%p081: Tensor[(1, 6132, 1), float32])
-> Tensor[(1, 6132, 1), float32] {
%635 = add(%p081, 0f) # ty=Tensor[(1, 6132, 1), float32]
%635
}
%636 = %634(%633) # ty=Tensor[(1, 6132, 1), float32]
%637 = fn(%p082: Tensor[(1, 6132, 1), float32])
-> Tensor[(1, 6132, 1), float32] {
%638 = add(%p082, 1f) # ty=Tensor[(1, 6132, 1), float32]
%638
}
%639 = %637(%633) # ty=Tensor[(1, 6132, 1), float32]
%640 = fn(%p083: Tensor[(1, 6132, 1), float32])
-> Tensor[(1, 6132, 1), float32] {
%641 = add(%p083, 2f) # ty=Tensor[(1, 6132, 1), float32]
%641
}
%642 = %640(%633) # ty=Tensor[(1, 6132, 1), float32]
%643 = fn(%p084: Tensor[(1, 6132, 1), float32])
-> Tensor[(1, 6132, 1), float32] {
%644 = add(%p084, 3f) # ty=Tensor[(1, 6132, 1), float32]
%644
}
%645 = %643(%633) # ty=Tensor[(1, 6132, 1), float32]
%646 = fn(%p085: Tensor[(1, 6132, 1), float32])
-> Tensor[(1, 6132, 1), float32] {
%647 = add(%p085, 4f) # ty=Tensor[(1, 6132, 1), float32]
%647
}
%648 = %646(%633) # ty=Tensor[(1, 6132, 1), float32]
%649 = fn(%p086: Tensor[(1, 6132, 1), float32])
-> Tensor[(1, 6132, 1), float32] {
%650 = add(%p086, 5f) # ty=Tensor[(1, 6132, 1), float32]
%650
}
%651 = %649(%633) # ty=Tensor[(1, 6132, 1), float32]
%652 = fn(%p087: Tensor[(1, 6132, 1), float32])
-> Tensor[(1, 6132, 1), float32] {
%653 = add(%p087, 6f) # ty=Tensor[(1, 6132, 1), float32]
%653
}
%654 = %652(%633) # ty=Tensor[(1, 6132, 1), float32]
%655 = fn(%p088: Tensor[(1, 6132, 1), float32])
-> Tensor[(1, 6132, 1), float32] {
%656 = add(%p088, 7f) # ty=Tensor[(1, 6132, 1), float32]
%656
}
%657 = %655(%633) # ty=Tensor[(1, 6132, 1), float32]
%658 = fn(%p089: Tensor[(1, 6132, 1), float32])
-> Tensor[(1, 6132, 1), float32] {
%659 = add(%p089, 8f) # ty=Tensor[(1, 6132, 1), float32]
%659
}
%660 = %658(%633) # ty=Tensor[(1, 6132, 1), float32]
%661 = fn(%p090: Tensor[(1, 6132, 1), float32])
-> Tensor[(1, 6132, 1), float32] {
%662 = add(%p090, 9f) # ty=Tensor[(1, 6132, 1), float32]
%662
}
%663 = %661(%633) # ty=Tensor[(1, 6132, 1), float32]
%664 = fn(%p091: Tensor[(1, 6132, 1), float32])
-> Tensor[(1, 6132, 1), float32] {
%665 = add(%p091, 10f) # ty=Tensor[(1, 6132, 1), float32]
%665
}
%666 = %664(%633) # ty=Tensor[(1, 6132, 1), float32]
%667 = fn(%p092: Tensor[(1, 6132, 1), float32])
-> Tensor[(1, 6132, 1), float32] {
%668 = add(%p092, 11f) # ty=Tensor[(1, 6132, 1), float32]
%668
}
%669 = %667(%633) # ty=Tensor[(1, 6132, 1), float32]
%670 = fn(%p093: Tensor[(1, 6132, 1), float32])
-> Tensor[(1, 6132, 1), float32] {
%671 = add(%p093, 12f) # ty=Tensor[(1, 6132, 1), float32]
%671
}
%672 = %670(%633) # ty=Tensor[(1, 6132, 1), float32]
%673 = fn(%p094: Tensor[(1, 6132, 1), float32])
-> Tensor[(1, 6132, 1), float32] {
%674 = add(%p094, 13f) # ty=Tensor[(1, 6132, 1), float32]
%674
}
%675 = %673(%633) # ty=Tensor[(1, 6132, 1), float32]
%676 = fn(%p095: Tensor[(1, 6132, 1), float32])
-> Tensor[(1, 6132, 1), float32] {
%677 = add(%p095, 14f) # ty=Tensor[(1, 6132, 1), float32]
%677
}
%678 = %676(%633) # ty=Tensor[(1, 6132, 1), float32]
%679 = fn(%p096: Tensor[(1, 6132, 1), float32])
-> Tensor[(1, 6132, 1), float32] {
%680 = add(%p096, 15f) # ty=Tensor[(1, 6132, 1), float32]
%680
}
%681 = %679(%633) # ty=Tensor[(1, 6132, 1), float32]
%682 = fn(%p097: Tensor[(1, 6132, 1), float32])
-> Tensor[(1, 6132, 1), float32] {
%683 = add(%p097, 16f) # ty=Tensor[(1, 6132, 1), float32]
%683
}
%684 = %682(%633) # ty=Tensor[(1, 6132, 1), float32]
%685 = fn(%p098: Tensor[(1, 6132, 1), float32])
-> Tensor[(1, 6132, 1), float32] {
%686 = add(%p098, 17f) # ty=Tensor[(1, 6132, 1), float32]
%686
}
%687 = %685(%633) # ty=Tensor[(1, 6132, 1), float32]
%688 = fn(%p099: Tensor[(1, 6132, 1), float32])
-> Tensor[(1, 6132, 1), float32] {
%689 = add(%p099, 18f) # ty=Tensor[(1, 6132, 1), float32]
%689
}
%690 = %688(%633) # ty=Tensor[(1, 6132, 1), float32]
%691 = fn(%p0100: Tensor[(1, 6132, 1), float32])
-> Tensor[(1, 6132, 1), float32] {
%692 = add(%p0100, 19f) # ty=Tensor[(1, 6132, 1), float32]
%692
}
%693 = %691(%633) # ty=Tensor[(1, 6132, 1), float32]
%694 = meta.relay.Constant(id=184) # ty=Tensor[(16, 1, 1), float32]
%695 = fn(%p0101: Tensor[(1, 100, 32, 32), float32],
%p174: Tensor[(16, 1, 1), float32])
-> Tensor[(1, 16, 32, 32), float32] {
%696 = strided_slice(%p0101, begin=[0, 84], end=[None, 100]) # ty=Tensor[(1, 16, 32, 32), float32]
%697 = add(%696, %p174) # ty=Tensor[(1, 16, 32, 32), float32]
%697
}
%698 = %695(%409, %694) # ty=Tensor[(1, 16, 32, 32), float32]
%699 = meta.relay.Constant(id=185) # ty=Tensor[(24, 1, 1), float32]
%700 = fn(%p0102: Tensor[(1, 150, 16, 16), float32],
%p175: Tensor[(24, 1, 1), float32])
-> Tensor[(1, 24, 16, 16), float32] {
%701 = strided_slice(%p0102, begin=[0, 126], end=[None, 150]) # ty=Tensor[(1, 24, 16, 16), float32]
%702 = add(%701, %p175) # ty=Tensor[(1, 24, 16, 16), float32]
%702
}
%703 = %700(%512, %699) # ty=Tensor[(1, 24, 16, 16), float32]
%704 = meta.relay.Constant(id=186) # ty=Tensor[(24, 1, 1), float32]
%705 = fn(%p0103: Tensor[(1, 150, 8, 8), float32],
%p176: Tensor[(24, 1, 1), float32])
-> Tensor[(1, 24, 8, 8), float32] {
%706 = strided_slice(%p0103, begin=[0, 126], end=[None, 150]) # ty=Tensor[(1, 24, 8, 8), float32]
%707 = add(%706, %p176) # ty=Tensor[(1, 24, 8, 8), float32]
%707
}
%708 = %705(%535, %704) # ty=Tensor[(1, 24, 8, 8), float32]
%709 = meta.relay.Constant(id=187) # ty=Tensor[(24, 1, 1), float32]
%710 = fn(%p0104: Tensor[(1, 150, 4, 4), float32],
%p177: Tensor[(24, 1, 1), float32])
-> Tensor[(1, 24, 4, 4), float32] {
%711 = strided_slice(%p0104, begin=[0, 126], end=[None, 150]) # ty=Tensor[(1, 24, 4, 4), float32]
%712 = add(%711, %p177) # ty=Tensor[(1, 24, 4, 4), float32]
%712
}
%713 = %710(%558, %709) # ty=Tensor[(1, 24, 4, 4), float32]
%714 = meta.relay.Constant(id=188) # ty=Tensor[(16, 1, 1), float32]
%715 = fn(%p0105: Tensor[(1, 100, 2, 2), float32],
%p178: Tensor[(16, 1, 1), float32])
-> Tensor[(1, 16, 2, 2), float32] {
%716 = strided_slice(%p0105, begin=[0, 84], end=[None, 100]) # ty=Tensor[(1, 16, 2, 2), float32]
%717 = add(%716, %p178) # ty=Tensor[(1, 16, 2, 2), float32]
%717
}
%718 = %715(%581, %714) # ty=Tensor[(1, 16, 2, 2), float32]
%719 = meta.relay.Constant(id=189) # ty=Tensor[(16, 1, 1), float32]
%720 = fn(%p0106: Tensor[(1, 100, 1, 1), float32],
%p179: Tensor[(16, 1, 1), float32])
-> Tensor[(1, 16, 1, 1), float32] {
%721 = strided_slice(%p0106, begin=[0, 84], end=[None, 100]) # ty=Tensor[(1, 16, 1, 1), float32]
%722 = add(%721, %p179) # ty=Tensor[(1, 16, 1, 1), float32]
%722
}
%723 = %720(%604, %719) # ty=Tensor[(1, 16, 1, 1), float32]
%724 = fn(%p0107: Tensor[(1, 16, 32, 32), float32],
%p180: Tensor[(1, 24, 16, 16), float32],
%p258: Tensor[(1, 24, 8, 8), float32],
%p329: Tensor[(1, 24, 4, 4), float32],
%p418: Tensor[(1, 16, 2, 2), float32],
%p517: Tensor[(1, 16, 1, 1), float32])
-> Tuple[Tensor[(1, 6132, 1), float32], Tensor[(1, 6132, 1), float32], Tensor[(1, 6132, 1), float32], Tensor[(1, 6132, 1), float32]] {
%725 = transpose(%p0107, axes=[0, 2, 3, 1]) # ty=Tensor[(1, 32, 32, 16), float32]
%726 = nn.batch_flatten(%725) # ty=Tensor[(1, 16384), float32]
%727 = transpose(%p180, axes=[0, 2, 3, 1]) # ty=Tensor[(1, 16, 16, 24), float32]
%728 = nn.batch_flatten(%727) # ty=Tensor[(1, 6144), float32]
%729 = transpose(%p258, axes=[0, 2, 3, 1]) # ty=Tensor[(1, 8, 8, 24), float32]
%730 = nn.batch_flatten(%729) # ty=Tensor[(1, 1536), float32]
%731 = transpose(%p329, axes=[0, 2, 3, 1]) # ty=Tensor[(1, 4, 4, 24), float32]
%732 = nn.batch_flatten(%731) # ty=Tensor[(1, 384), float32]
%733 = transpose(%p418, axes=[0, 2, 3, 1]) # ty=Tensor[(1, 2, 2, 16), float32]
%734 = nn.batch_flatten(%733) # ty=Tensor[(1, 64), float32]
%735 = transpose(%p517, axes=[0, 2, 3, 1]) # ty=Tensor[(1, 1, 1, 16), float32]
%736 = nn.batch_flatten(%735) # ty=Tensor[(1, 16), float32]
%737 = (%726, %728, %730, %732, %734, %736)
%738 = concatenate(%737, axis=1) # ty=Tensor[(1, 24528), float32]
%739 = reshape(%738, newshape=[0, -1, 4]) # ty=Tensor[(1, 6132, 4), float32]
%740 = split(%739, indices_or_sections=int64(4), axis=-1) # ty=Tuple[Tensor[(1, 6132, 1), float32], Tensor[(1, 6132, 1), float32], Tensor[(1, 6132, 1), float32], Tensor[(1, 6132, 1), float32]]
%740
}
%741 = %724(%698, %703, %708, %713, %718, %723) # ty=Tuple[Tensor[(1, 6132, 1), float32], Tensor[(1, 6132, 1), float32], Tensor[(1, 6132, 1), float32], Tensor[(1, 6132, 1), float32]]
%742 = %741.0
%743 = meta.relay.Constant(id=190) # ty=Tensor[(1, 1, 128, 128, 16), float32]
%744 = fn(%p0108: Tensor[(1, 1024, 32, 32), float32])
-> Tensor[(1, 1024, 32, 32), float32] {
%745 = multiply(%p0108, 0f) # ty=Tensor[(1, 1024, 32, 32), float32]
%745
}
%746 = %744(%405) # ty=Tensor[(1, 1024, 32, 32), float32]
%747 = meta.relay.Constant(id=191) # ty=Tensor[(1, 1, 64, 64, 24), float32]
%748 = fn(%p0109: Tensor[(1, 2048, 16, 16), float32])
-> Tensor[(1, 2048, 16, 16), float32] {
%749 = multiply(%p0109, 0f) # ty=Tensor[(1, 2048, 16, 16), float32]
%749
}
%750 = %748(%508) # ty=Tensor[(1, 2048, 16, 16), float32]
%751 = meta.relay.Constant(id=192) # ty=Tensor[(1, 1, 32, 32, 24), float32]
%752 = fn(%p0110: Tensor[(1, 512, 8, 8), float32])
-> Tensor[(1, 512, 8, 8), float32] {
%753 = multiply(%p0110, 0f) # ty=Tensor[(1, 512, 8, 8), float32]
%753
}
%754 = %752(%531) # ty=Tensor[(1, 512, 8, 8), float32]
%755 = meta.relay.Constant(id=193) # ty=Tensor[(1, 1, 16, 16, 24), float32]
%756 = fn(%p0111: Tensor[(1, 512, 4, 4), float32])
-> Tensor[(1, 512, 4, 4), float32] {
%757 = multiply(%p0111, 0f) # ty=Tensor[(1, 512, 4, 4), float32]
%757
}
%758 = %756(%554) # ty=Tensor[(1, 512, 4, 4), float32]
%759 = meta.relay.Constant(id=194) # ty=Tensor[(1, 1, 16, 16, 16), float32]
%760 = fn(%p0112: Tensor[(1, 256, 2, 2), float32])
-> Tensor[(1, 256, 2, 2), float32] {
%761 = multiply(%p0112, 0f) # ty=Tensor[(1, 256, 2, 2), float32]
%761
}
%762 = %760(%577) # ty=Tensor[(1, 256, 2, 2), float32]
%763 = meta.relay.Constant(id=195) # ty=Tensor[(1, 1, 16, 16, 16), float32]
%764 = fn(%p0113: Tensor[(1, 256, 1, 1), float32])
-> Tensor[(1, 256, 1, 1), float32] {
%765 = multiply(%p0113, 0f) # ty=Tensor[(1, 256, 1, 1), float32]
%765
}
%766 = %764(%600) # ty=Tensor[(1, 256, 1, 1), float32]
%767 = fn(%p0114: Tensor[(1, 1, 128, 128, 16), float32],
%p181: Tensor[(1, 1024, 32, 32), float32],
%p259: Tensor[(1, 1, 64, 64, 24), float32],
%p330: Tensor[(1, 2048, 16, 16), float32],
%p419: Tensor[(1, 1, 32, 32, 24), float32],
%p518: Tensor[(1, 512, 8, 8), float32],
%p64: Tensor[(1, 1, 16, 16, 24), float32],
%p74: Tensor[(1, 512, 4, 4), float32],
%p8: Tensor[(1, 1, 16, 16, 16), float32],
%p9: Tensor[(1, 256, 2, 2), float32],
%p10: Tensor[(1, 1, 16, 16, 16), float32],
%p1110: Tensor[(1, 256, 1, 1), float32])
-> Tuple[Tensor[(1, 6132, 1), float32], Tensor[(1, 6132, 1), float32], Tensor[(1, 6132, 1), float32], Tensor[(1, 6132, 1), float32]] {
%768 = slice_like(%p0114, %p181, meta.relay.attrs.SliceLikeAttrs(id=196)) # ty=Tensor[(1, 1, 32, 32, 16), float32]
%769 = reshape(%768, newshape=[1, -1, 4]) # ty=Tensor[(1, 4096, 4), float32]
%770 = reshape(%769, newshape=[1, -1, 4]) # ty=Tensor[(1, 4096, 4), float32]
%771 = reshape(%770, newshape=[1, -1]) # ty=Tensor[(1, 16384), float32]
%772 = slice_like(%p259, %p330, meta.relay.attrs.SliceLikeAttrs(id=197)) # ty=Tensor[(1, 1, 16, 16, 24), float32]
%773 = reshape(%772, newshape=[1, -1, 4]) # ty=Tensor[(1, 1536, 4), float32]
%774 = reshape(%773, newshape=[1, -1, 4]) # ty=Tensor[(1, 1536, 4), float32]
%775 = reshape(%774, newshape=[1, -1]) # ty=Tensor[(1, 6144), float32]
%776 = slice_like(%p419, %p518, meta.relay.attrs.SliceLikeAttrs(id=198)) # ty=Tensor[(1, 1, 8, 8, 24), float32]
%777 = reshape(%776, newshape=[1, -1, 4]) # ty=Tensor[(1, 384, 4), float32]
%778 = reshape(%777, newshape=[1, -1, 4]) # ty=Tensor[(1, 384, 4), float32]
%779 = reshape(%778, newshape=[1, -1]) # ty=Tensor[(1, 1536), float32]
%780 = slice_like(%p64, %p74, meta.relay.attrs.SliceLikeAttrs(id=199)) # ty=Tensor[(1, 1, 4, 4, 24), float32]
%781 = reshape(%780, newshape=[1, -1, 4]) # ty=Tensor[(1, 96, 4), float32]
%782 = reshape(%781, newshape=[1, -1, 4]) # ty=Tensor[(1, 96, 4), float32]
%783 = reshape(%782, newshape=[1, -1]) # ty=Tensor[(1, 384), float32]
%784 = slice_like(%p8, %p9, meta.relay.attrs.SliceLikeAttrs(id=200)) # ty=Tensor[(1, 1, 2, 2, 16), float32]
%785 = reshape(%784, newshape=[1, -1, 4]) # ty=Tensor[(1, 16, 4), float32]
%786 = reshape(%785, newshape=[1, -1, 4]) # ty=Tensor[(1, 16, 4), float32]
%787 = reshape(%786, newshape=[1, -1]) # ty=Tensor[(1, 64), float32]
%788 = slice_like(%p10, %p1110, meta.relay.attrs.SliceLikeAttrs(id=201)) # ty=Tensor[(1, 1, 1, 1, 16), float32]
%789 = reshape(%788, newshape=[1, -1, 4]) # ty=Tensor[(1, 4, 4), float32]
%790 = reshape(%789, newshape=[1, -1, 4]) # ty=Tensor[(1, 4, 4), float32]
%791 = reshape(%790, newshape=[1, -1]) # ty=Tensor[(1, 16), float32]
%792 = (%771, %775, %779, %783, %787, %791)
%793 = concatenate(%792, axis=1) # ty=Tensor[(1, 24528), float32]
%794 = reshape(%793, newshape=[1, -1, 4]) # ty=Tensor[(1, 6132, 4), float32]
%795 = split(%794, indices_or_sections=int64(4), axis=-1) # ty=Tuple[Tensor[(1, 6132, 1), float32], Tensor[(1, 6132, 1), float32], Tensor[(1, 6132, 1), float32], Tensor[(1, 6132, 1), float32]]
%795
}
%796 = %767(%743, %746, %747, %750, %751, %754, %755, %758, %759, %762, %763, %766) # ty=Tuple[Tensor[(1, 6132, 1), float32], Tensor[(1, 6132, 1), float32], Tensor[(1, 6132, 1), float32], Tensor[(1, 6132, 1), float32]]
%797 = %796.2
%798 = %796.0
%799 = fn(%p0115: Tensor[(1, 6132, 1), float32],
%p182: Tensor[(1, 6132, 1), float32],
%p260: Tensor[(1, 6132, 1), float32])
-> Tensor[(1, 6132, 1), float32] {
%800 = multiply(%p0115, 0.1f) # ty=Tensor[(1, 6132, 1), float32]
%801 = add(%800, 0f) # ty=Tensor[(1, 6132, 1), float32]
%802 = multiply(%801, %p182) # ty=Tensor[(1, 6132, 1), float32]
%803 = add(%802, %p260) # ty=Tensor[(1, 6132, 1), float32]
%803
}
%804 = %799(%742, %797, %798) # ty=Tensor[(1, 6132, 1), float32]
%805 = %741.2
%806 = %796.2
%807 = fn(%p0116: Tensor[(1, 6132, 1), float32],
%p183: Tensor[(1, 6132, 1), float32])
-> Tensor[(1, 6132, 1), float32] {
%808 = multiply(%p0116, 0.2f) # ty=Tensor[(1, 6132, 1), float32]
%809 = add(%808, 0f) # ty=Tensor[(1, 6132, 1), float32]
%810 = exp(%809) # ty=Tensor[(1, 6132, 1), float32]
%811 = multiply(%810, %p183) # ty=Tensor[(1, 6132, 1), float32]
%812 = divide(%811, 2f) # ty=Tensor[(1, 6132, 1), float32]
%812
}
%813 = %807(%805, %806) # ty=Tensor[(1, 6132, 1), float32]
%814 = fn(%p0117: Tensor[(1, 6132, 1), float32],
%p184: Tensor[(1, 6132, 1), float32])
-> Tensor[(1, 6132, 1), float32] {
%815 = subtract(%p0117, %p184) # ty=Tensor[(1, 6132, 1), float32]
%815
}
%816 = %814(%804, %813) # ty=Tensor[(1, 6132, 1), float32]
%817 = %741.1
%818 = %796.3
%819 = %796.1
%820 = fn(%p0118: Tensor[(1, 6132, 1), float32],
%p185: Tensor[(1, 6132, 1), float32],
%p261: Tensor[(1, 6132, 1), float32])
-> Tensor[(1, 6132, 1), float32] {
%821 = multiply(%p0118, 0.1f) # ty=Tensor[(1, 6132, 1), float32]
%822 = add(%821, 0f) # ty=Tensor[(1, 6132, 1), float32]
%823 = multiply(%822, %p185) # ty=Tensor[(1, 6132, 1), float32]
%824 = add(%823, %p261) # ty=Tensor[(1, 6132, 1), float32]
%824
}
%825 = %820(%817, %818, %819) # ty=Tensor[(1, 6132, 1), float32]
%826 = %741.3
%827 = %796.3
%828 = fn(%p0119: Tensor[(1, 6132, 1), float32],
%p186: Tensor[(1, 6132, 1), float32])
-> Tensor[(1, 6132, 1), float32] {
%829 = multiply(%p0119, 0.2f) # ty=Tensor[(1, 6132, 1), float32]
%830 = add(%829, 0f) # ty=Tensor[(1, 6132, 1), float32]
%831 = exp(%830) # ty=Tensor[(1, 6132, 1), float32]
%832 = multiply(%831, %p186) # ty=Tensor[(1, 6132, 1), float32]
%833 = divide(%832, 2f) # ty=Tensor[(1, 6132, 1), float32]
%833
}
%834 = %828(%826, %827) # ty=Tensor[(1, 6132, 1), float32]
%835 = fn(%p0120: Tensor[(1, 6132, 1), float32],
%p187: Tensor[(1, 6132, 1), float32])
-> Tensor[(1, 6132, 1), float32] {
%836 = subtract(%p0120, %p187) # ty=Tensor[(1, 6132, 1), float32]
%836
}
%837 = %835(%825, %834) # ty=Tensor[(1, 6132, 1), float32]
%838 = fn(%p0121: Tensor[(1, 6132, 1), float32],
%p188: Tensor[(1, 6132, 1), float32])
-> Tensor[(1, 6132, 1), float32] {
%839 = add(%p0121, %p188) # ty=Tensor[(1, 6132, 1), float32]
%839
}
%840 = %838(%804, %813) # ty=Tensor[(1, 6132, 1), float32]
%841 = fn(%p0122: Tensor[(1, 6132, 1), float32],
%p189: Tensor[(1, 6132, 1), float32])
-> Tensor[(1, 6132, 1), float32] {
%842 = add(%p0122, %p189) # ty=Tensor[(1, 6132, 1), float32]
%842
}
%843 = %841(%825, %834) # ty=Tensor[(1, 6132, 1), float32]
%844 = fn(%p0123: Tensor[(1, 6132, 21), float32],
%p190: Tensor[(1, 6132, 1), float32],
%p262: Tensor[(1, 6132, 1), float32],
%p331: Tensor[(1, 6132, 1), float32],
%p420: Tensor[(1, 6132, 1), float32],
%p519: Tensor[(1, 6132, 1), float32],
%p65: Tensor[(1, 6132, 1), float32],
%p75: Tensor[(1, 6132, 1), float32],
%p81: Tensor[(1, 6132, 1), float32],
%p91: Tensor[(1, 6132, 1), float32],
%p101: Tensor[(1, 6132, 1), float32],
%p1111: Tensor[(1, 6132, 1), float32],
%p1210: Tensor[(1, 6132, 1), float32],
%p1310: Tensor[(1, 6132, 1), float32],
%p1410: Tensor[(1, 6132, 1), float32],
%p1510: Tensor[(1, 6132, 1), float32],
%p1610: Tensor[(1, 6132, 1), float32],
%p1710: Tensor[(1, 6132, 1), float32],
%p1810: Tensor[(1, 6132, 1), float32],
%p191: Tensor[(1, 6132, 1), float32],
%p20: Tensor[(1, 6132, 1), float32],
%p2110: Tensor[(1, 6132, 1), float32],
%p2210: Tensor[(1, 6132, 1), float32],
%p2310: Tensor[(1, 6132, 1), float32],
%p2410: Tensor[(1, 6132, 1), float32])
-> Tensor[(1, 122640, 6), float32] {
%845 = slice_axis(%p0123, meta.relay.attrs.SliceAxisAttrs(id=202)) # ty=Tensor[(1, 6132, 20), float32]
%846 = greater(%845, 0.01f) # ty=Tensor[(1, 6132, 20), bool]
%847 = (%p190, %p262, %p331, %p420, %p519, %p65, %p75, %p81, %p91, %p101, %p1111, %p1210, %p1310, %p1410, %p1510, %p1610, %p1710, %p1810, %p191, %p20)
%848 = concatenate(%847, axis=-1) # ty=Tensor[(1, 6132, 20), float32]
%849 = ones_like(%848) # ty=Tensor[(1, 6132, 20), float32]
%850 = multiply(%849, -1f) # ty=Tensor[(1, 6132, 20), float32]
%851 = where(%846, %848, %850) # ty=Tensor[(1, 6132, 20), float32]
%852 = slice_axis(%851, meta.relay.attrs.SliceAxisAttrs(id=203)) # ty=Tensor[(1, 6132, 1), float32]
%853 = zeros_like(%845) # ty=Tensor[(1, 6132, 20), float32]
%854 = where(%846, %845, %853) # ty=Tensor[(1, 6132, 20), float32]
%855 = slice_axis(%854, meta.relay.attrs.SliceAxisAttrs(id=204)) # ty=Tensor[(1, 6132, 1), float32]
%856 = (%p2110, %p2210, %p2310, %p2410)
%857 = concatenate(%856, axis=-1) # ty=Tensor[(1, 6132, 4), float32]
%858 = (%852, %855, %857)
%859 = concatenate(%858, axis=-1) # ty=Tensor[(1, 6132, 6), float32]
%860 = slice_axis(%851, meta.relay.attrs.SliceAxisAttrs(id=205)) # ty=Tensor[(1, 6132, 1), float32]
%861 = slice_axis(%854, meta.relay.attrs.SliceAxisAttrs(id=206)) # ty=Tensor[(1, 6132, 1), float32]
%862 = (%860, %861, %857)
%863 = concatenate(%862, axis=-1) # ty=Tensor[(1, 6132, 6), float32]
%864 = slice_axis(%851, meta.relay.attrs.SliceAxisAttrs(id=207)) # ty=Tensor[(1, 6132, 1), float32]
%865 = slice_axis(%854, meta.relay.attrs.SliceAxisAttrs(id=208)) # ty=Tensor[(1, 6132, 1), float32]
%866 = (%864, %865, %857)
%867 = concatenate(%866, axis=-1) # ty=Tensor[(1, 6132, 6), float32]
%868 = slice_axis(%851, meta.relay.attrs.SliceAxisAttrs(id=209)) # ty=Tensor[(1, 6132, 1), float32]
%869 = slice_axis(%854, meta.relay.attrs.SliceAxisAttrs(id=210)) # ty=Tensor[(1, 6132, 1), float32]
%870 = (%868, %869, %857)
%871 = concatenate(%870, axis=-1) # ty=Tensor[(1, 6132, 6), float32]
%872 = slice_axis(%851, meta.relay.attrs.SliceAxisAttrs(id=211)) # ty=Tensor[(1, 6132, 1), float32]
%873 = slice_axis(%854, meta.relay.attrs.SliceAxisAttrs(id=212)) # ty=Tensor[(1, 6132, 1), float32]
%874 = (%872, %873, %857)
%875 = concatenate(%874, axis=-1) # ty=Tensor[(1, 6132, 6), float32]
%876 = slice_axis(%851, meta.relay.attrs.SliceAxisAttrs(id=213)) # ty=Tensor[(1, 6132, 1), float32]
%877 = slice_axis(%854, meta.relay.attrs.SliceAxisAttrs(id=214)) # ty=Tensor[(1, 6132, 1), float32]
%878 = (%876, %877, %857)
%879 = concatenate(%878, axis=-1) # ty=Tensor[(1, 6132, 6), float32]
%880 = slice_axis(%851, meta.relay.attrs.SliceAxisAttrs(id=215)) # ty=Tensor[(1, 6132, 1), float32]
%881 = slice_axis(%854, meta.relay.attrs.SliceAxisAttrs(id=216)) # ty=Tensor[(1, 6132, 1), float32]
%882 = (%880, %881, %857)
%883 = concatenate(%882, axis=-1) # ty=Tensor[(1, 6132, 6), float32]
%884 = slice_axis(%851, meta.relay.attrs.SliceAxisAttrs(id=217)) # ty=Tensor[(1, 6132, 1), float32]
%885 = slice_axis(%854, meta.relay.attrs.SliceAxisAttrs(id=218)) # ty=Tensor[(1, 6132, 1), float32]
%886 = (%884, %885, %857)
%887 = concatenate(%886, axis=-1) # ty=Tensor[(1, 6132, 6), float32]
%888 = slice_axis(%851, meta.relay.attrs.SliceAxisAttrs(id=219)) # ty=Tensor[(1, 6132, 1), float32]
%889 = slice_axis(%854, meta.relay.attrs.SliceAxisAttrs(id=220)) # ty=Tensor[(1, 6132, 1), float32]
%890 = (%888, %889, %857)
%891 = concatenate(%890, axis=-1) # ty=Tensor[(1, 6132, 6), float32]
%892 = slice_axis(%851, meta.relay.attrs.SliceAxisAttrs(id=221)) # ty=Tensor[(1, 6132, 1), float32]
%893 = slice_axis(%854, meta.relay.attrs.SliceAxisAttrs(id=222)) # ty=Tensor[(1, 6132, 1), float32]
%894 = (%892, %893, %857)
%895 = concatenate(%894, axis=-1) # ty=Tensor[(1, 6132, 6), float32]
%896 = slice_axis(%851, meta.relay.attrs.SliceAxisAttrs(id=223)) # ty=Tensor[(1, 6132, 1), float32]
%897 = slice_axis(%854, meta.relay.attrs.SliceAxisAttrs(id=224)) # ty=Tensor[(1, 6132, 1), float32]
%898 = (%896, %897, %857)
%899 = concatenate(%898, axis=-1) # ty=Tensor[(1, 6132, 6), float32]
%900 = slice_axis(%851, meta.relay.attrs.SliceAxisAttrs(id=225)) # ty=Tensor[(1, 6132, 1), float32]
%901 = slice_axis(%854, meta.relay.attrs.SliceAxisAttrs(id=226)) # ty=Tensor[(1, 6132, 1), float32]
%902 = (%900, %901, %857)
%903 = concatenate(%902, axis=-1) # ty=Tensor[(1, 6132, 6), float32]
%904 = slice_axis(%851, meta.relay.attrs.SliceAxisAttrs(id=227)) # ty=Tensor[(1, 6132, 1), float32]
%905 = slice_axis(%854, meta.relay.attrs.SliceAxisAttrs(id=228)) # ty=Tensor[(1, 6132, 1), float32]
%906 = (%904, %905, %857)
%907 = concatenate(%906, axis=-1) # ty=Tensor[(1, 6132, 6), float32]
%908 = slice_axis(%851, meta.relay.attrs.SliceAxisAttrs(id=229)) # ty=Tensor[(1, 6132, 1), float32]
%909 = slice_axis(%854, meta.relay.attrs.SliceAxisAttrs(id=230)) # ty=Tensor[(1, 6132, 1), float32]
%910 = (%908, %909, %857)
%911 = concatenate(%910, axis=-1) # ty=Tensor[(1, 6132, 6), float32]
%912 = slice_axis(%851, meta.relay.attrs.SliceAxisAttrs(id=231)) # ty=Tensor[(1, 6132, 1), float32]
%913 = slice_axis(%854, meta.relay.attrs.SliceAxisAttrs(id=232)) # ty=Tensor[(1, 6132, 1), float32]
%914 = (%912, %913, %857)
%915 = concatenate(%914, axis=-1) # ty=Tensor[(1, 6132, 6), float32]
%916 = slice_axis(%851, meta.relay.attrs.SliceAxisAttrs(id=233)) # ty=Tensor[(1, 6132, 1), float32]
%917 = slice_axis(%854, meta.relay.attrs.SliceAxisAttrs(id=234)) # ty=Tensor[(1, 6132, 1), float32]
%918 = (%916, %917, %857)
%919 = concatenate(%918, axis=-1) # ty=Tensor[(1, 6132, 6), float32]
%920 = slice_axis(%851, meta.relay.attrs.SliceAxisAttrs(id=235)) # ty=Tensor[(1, 6132, 1), float32]
%921 = slice_axis(%854, meta.relay.attrs.SliceAxisAttrs(id=236)) # ty=Tensor[(1, 6132, 1), float32]
%922 = (%920, %921, %857)
%923 = concatenate(%922, axis=-1) # ty=Tensor[(1, 6132, 6), float32]
%924 = slice_axis(%851, meta.relay.attrs.SliceAxisAttrs(id=237)) # ty=Tensor[(1, 6132, 1), float32]
%925 = slice_axis(%854, meta.relay.attrs.SliceAxisAttrs(id=238)) # ty=Tensor[(1, 6132, 1), float32]
%926 = (%924, %925, %857)
%927 = concatenate(%926, axis=-1) # ty=Tensor[(1, 6132, 6), float32]
%928 = slice_axis(%851, meta.relay.attrs.SliceAxisAttrs(id=239)) # ty=Tensor[(1, 6132, 1), float32]
%929 = slice_axis(%854, meta.relay.attrs.SliceAxisAttrs(id=240)) # ty=Tensor[(1, 6132, 1), float32]
%930 = (%928, %929, %857)
%931 = concatenate(%930, axis=-1) # ty=Tensor[(1, 6132, 6), float32]
%932 = slice_axis(%851, meta.relay.attrs.SliceAxisAttrs(id=241)) # ty=Tensor[(1, 6132, 1), float32]
%933 = slice_axis(%854, meta.relay.attrs.SliceAxisAttrs(id=242)) # ty=Tensor[(1, 6132, 1), float32]
%934 = (%932, %933, %857)
%935 = concatenate(%934, axis=-1) # ty=Tensor[(1, 6132, 6), float32]
%936 = (%859, %863, %867, %871, %875, %879, %883, %887, %891, %895, %899, %903, %907, %911, %915, %919, %923, %927, %931, %935)
%937 = concatenate(%936, axis=1) # ty=Tensor[(1, 122640, 6), float32]
%937
}
%938 = %844(%629, %636, %639, %642, %645, %648, %651, %654, %657, %660, %663, %666, %669, %672, %675, %678, %681, %684, %687, %690, %693, %816, %837, %840, %843) # ty=Tensor[(1, 122640, 6), float32]
%939 = fn(%p0124: Tensor[(1, 122640, 6), float32])
-> Tuple[Tensor[(1,), int32], Tensor[(1, 122640, 6), float32]] {
%940 = vision.get_valid_counts(%p0124, meta.relay.attrs.GetValidCountsAttrs(id=243)) # ty=Tuple[Tensor[(1,), int32], Tensor[(1, 122640, 6), float32]]
%940
}
%941 = %939(%938) # ty=Tuple[Tensor[(1,), int32], Tensor[(1, 122640, 6), float32]]
%942 = %941.1
%943 = %941.0
%944 = fn(%p0125: Tensor[(1, 122640, 6), float32],
%p192: Tensor[(1,), int32])
-> Tensor[(1, 122640, 6), float32] {
%945 = vision.nms(%p0125, %p192, meta.relay.attrs.NMSAttrs(id=244)) # ty=Tensor[(1, 122640, 6), float32]
%945
}
%946 = %944(%942, %943) # ty=Tensor[(1, 122640, 6), float32]
%947 = fn(%p0126: Tensor[(1, 122640, 6), float32])
-> Tuple[Tensor[(1, 100, 1), float32], Tensor[(1, 100, 1), float32], Tensor[(1, 100, 4), float32]] {
%948 = slice_axis(%p0126, meta.relay.attrs.SliceAxisAttrs(id=245)) # ty=Tensor[(1, 100, 6), float32]
%949 = slice_axis(%948, meta.relay.attrs.SliceAxisAttrs(id=246)) # ty=Tensor[(1, 100, 1), float32]
%950 = slice_axis(%948, meta.relay.attrs.SliceAxisAttrs(id=247)) # ty=Tensor[(1, 100, 1), float32]
%951 = slice_axis(%948, meta.relay.attrs.SliceAxisAttrs(id=248)) # ty=Tensor[(1, 100, 4), float32]
%952 = (%949, %950, %951)
%952
}
%953 = %947(%946) # ty=Tuple[Tensor[(1, 100, 1), float32], Tensor[(1, 100, 1), float32], Tensor[(1, 100, 4), float32]]
%953
}
# meta data omitted. you can use show_meta_data=True to include meta-data
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment