Skip to content

Instantly share code, notes, and snippets.

@zhiics

zhiics/mobilenetv1.0

Last active July 16, 2019 22:46
Show Gist options
  • Save zhiics/4b373b28b6457af83f6f6a3d21fd5c0f to your computer and use it in GitHub Desktop.
Save zhiics/4b373b28b6457af83f6f6a3d21fd5c0f to your computer and use it in GitHub Desktop.
Download ZIP
Raw
mobilenetv1.0
Before optimization
-------------------
v0.0.3
fn (%data: Tensor[(1, 3, 224, 224), float32], %mobilenet0_conv0_weight: Tensor[(32, 3, 3, 3), float32], %mobilenet0_batchnorm0_gamma: Tensor[(32,), float32], %mobilenet0_batchnorm0_beta: Tensor[(32,), float32], %mobilenet0_batchnorm0_running_mean: Tensor[(32,), float32], %mobilenet0_batchnorm0_running_var: Tensor[(32,), float32], %mobilenet0_conv1_weight: Tensor[(32, 1, 3, 3), float32], %mobilenet0_batchnorm1_gamma: Tensor[(32,), float32], %mobilenet0_batchnorm1_beta: Tensor[(32,), float32], %mobilenet0_batchnorm1_running_mean: Tensor[(32,), float32], %mobilenet0_batchnorm1_running_var: Tensor[(32,), float32], %mobilenet0_conv2_weight: Tensor[(64, 32, 1, 1), float32], %mobilenet0_batchnorm2_gamma: Tensor[(64,), float32], %mobilenet0_batchnorm2_beta: Tensor[(64,), float32], %mobilenet0_batchnorm2_running_mean: Tensor[(64,), float32], %mobilenet0_batchnorm2_running_var: Tensor[(64,), float32], %mobilenet0_conv3_weight: Tensor[(64, 1, 3, 3), float32], %mobilenet0_batchnorm3_gamma: Tensor[(64,), float32], %mobilenet0_batchnorm3_beta: Tensor[(64,), float32], %mobilenet0_batchnorm3_running_mean: Tensor[(64,), float32], %mobilenet0_batchnorm3_running_var: Tensor[(64,), float32], %mobilenet0_conv4_weight: Tensor[(128, 64, 1, 1), float32], %mobilenet0_batchnorm4_gamma: Tensor[(128,), float32], %mobilenet0_batchnorm4_beta: Tensor[(128,), float32], %mobilenet0_batchnorm4_running_mean: Tensor[(128,), float32], %mobilenet0_batchnorm4_running_var: Tensor[(128,), float32], %mobilenet0_conv5_weight: Tensor[(128, 1, 3, 3), float32], %mobilenet0_batchnorm5_gamma: Tensor[(128,), float32], %mobilenet0_batchnorm5_beta: Tensor[(128,), float32], %mobilenet0_batchnorm5_running_mean: Tensor[(128,), float32], %mobilenet0_batchnorm5_running_var: Tensor[(128,), float32], %mobilenet0_conv6_weight: Tensor[(128, 128, 1, 1), float32], %mobilenet0_batchnorm6_gamma: Tensor[(128,), float32], %mobilenet0_batchnorm6_beta: Tensor[(128,), float32], %mobilenet0_batchnorm6_running_mean: Tensor[(128,), float32], %mobilenet0_batchnorm6_running_var: Tensor[(128,), float32], %mobilenet0_conv7_weight: Tensor[(128, 1, 3, 3), float32], %mobilenet0_batchnorm7_gamma: Tensor[(128,), float32], %mobilenet0_batchnorm7_beta: Tensor[(128,), float32], %mobilenet0_batchnorm7_running_mean: Tensor[(128,), float32], %mobilenet0_batchnorm7_running_var: Tensor[(128,), float32], %mobilenet0_conv8_weight: Tensor[(256, 128, 1, 1), float32], %mobilenet0_batchnorm8_gamma: Tensor[(256,), float32], %mobilenet0_batchnorm8_beta: Tensor[(256,), float32], %mobilenet0_batchnorm8_running_mean: Tensor[(256,), float32], %mobilenet0_batchnorm8_running_var: Tensor[(256,), float32], %mobilenet0_conv9_weight: Tensor[(256, 1, 3, 3), float32], %mobilenet0_batchnorm9_gamma: Tensor[(256,), float32], %mobilenet0_batchnorm9_beta: Tensor[(256,), float32], %mobilenet0_batchnorm9_running_mean: Tensor[(256,), float32], %mobilenet0_batchnorm9_running_var: Tensor[(256,), float32], %mobilenet0_conv10_weight: Tensor[(256, 256, 1, 1), float32], %mobilenet0_batchnorm10_gamma: Tensor[(256,), float32], %mobilenet0_batchnorm10_beta: Tensor[(256,), float32], %mobilenet0_batchnorm10_running_mean: Tensor[(256,), float32], %mobilenet0_batchnorm10_running_var: Tensor[(256,), float32], %mobilenet0_conv11_weight: Tensor[(256, 1, 3, 3), float32], %mobilenet0_batchnorm11_gamma: Tensor[(256,), float32], %mobilenet0_batchnorm11_beta: Tensor[(256,), float32], %mobilenet0_batchnorm11_running_mean: Tensor[(256,), float32], %mobilenet0_batchnorm11_running_var: Tensor[(256,), float32], %mobilenet0_conv12_weight: Tensor[(512, 256, 1, 1), float32], %mobilenet0_batchnorm12_gamma: Tensor[(512,), float32], %mobilenet0_batchnorm12_beta: Tensor[(512,), float32], %mobilenet0_batchnorm12_running_mean: Tensor[(512,), float32], %mobilenet0_batchnorm12_running_var: Tensor[(512,), float32], %mobilenet0_conv13_weight: Tensor[(512, 1, 3, 3), float32], %mobilenet0_batchnorm13_gamma: Tensor[(512,), float32], %mobilenet0_batchnorm13_beta: Tensor[(512,), float32], %mobilenet0_batchnorm13_running_mean: Tensor[(512,), float32], %mobilenet0_batchnorm13_running_var: Tensor[(512,), float32], %mobilenet0_conv14_weight: Tensor[(512, 512, 1, 1), float32], %mobilenet0_batchnorm14_gamma: Tensor[(512,), float32], %mobilenet0_batchnorm14_beta: Tensor[(512,), float32], %mobilenet0_batchnorm14_running_mean: Tensor[(512,), float32], %mobilenet0_batchnorm14_running_var: Tensor[(512,), float32], %mobilenet0_conv15_weight: Tensor[(512, 1, 3, 3), float32], %mobilenet0_batchnorm15_gamma: Tensor[(512,), float32], %mobilenet0_batchnorm15_beta: Tensor[(512,), float32], %mobilenet0_batchnorm15_running_mean: Tensor[(512,), float32], %mobilenet0_batchnorm15_running_var: Tensor[(512,), float32], %mobilenet0_conv16_weight: Tensor[(512, 512, 1, 1), float32], %mobilenet0_batchnorm16_gamma: Tensor[(512,), float32], %mobilenet0_batchnorm16_beta: Tensor[(512,), float32], %mobilenet0_batchnorm16_running_mean: Tensor[(512,), float32], %mobilenet0_batchnorm16_running_var: Tensor[(512,), float32], %mobilenet0_conv17_weight: Tensor[(512, 1, 3, 3), float32], %mobilenet0_batchnorm17_gamma: Tensor[(512,), float32], %mobilenet0_batchnorm17_beta: Tensor[(512,), float32], %mobilenet0_batchnorm17_running_mean: Tensor[(512,), float32], %mobilenet0_batchnorm17_running_var: Tensor[(512,), float32], %mobilenet0_conv18_weight: Tensor[(512, 512, 1, 1), float32], %mobilenet0_batchnorm18_gamma: Tensor[(512,), float32], %mobilenet0_batchnorm18_beta: Tensor[(512,), float32], %mobilenet0_batchnorm18_running_mean: Tensor[(512,), float32], %mobilenet0_batchnorm18_running_var: Tensor[(512,), float32], %mobilenet0_conv19_weight: Tensor[(512, 1, 3, 3), float32], %mobilenet0_batchnorm19_gamma: Tensor[(512,), float32], %mobilenet0_batchnorm19_beta: Tensor[(512,), float32], %mobilenet0_batchnorm19_running_mean: Tensor[(512,), float32], %mobilenet0_batchnorm19_running_var: Tensor[(512,), float32], %mobilenet0_conv20_weight: Tensor[(512, 512, 1, 1), float32], %mobilenet0_batchnorm20_gamma: Tensor[(512,), float32], %mobilenet0_batchnorm20_beta: Tensor[(512,), float32], %mobilenet0_batchnorm20_running_mean: Tensor[(512,), float32], %mobilenet0_batchnorm20_running_var: Tensor[(512,), float32], %mobilenet0_conv21_weight: Tensor[(512, 1, 3, 3), float32], %mobilenet0_batchnorm21_gamma: Tensor[(512,), float32], %mobilenet0_batchnorm21_beta: Tensor[(512,), float32], %mobilenet0_batchnorm21_running_mean: Tensor[(512,), float32], %mobilenet0_batchnorm21_running_var: Tensor[(512,), float32], %mobilenet0_conv22_weight: Tensor[(512, 512, 1, 1), float32], %mobilenet0_batchnorm22_gamma: Tensor[(512,), float32], %mobilenet0_batchnorm22_beta: Tensor[(512,), float32], %mobilenet0_batchnorm22_running_mean: Tensor[(512,), float32], %mobilenet0_batchnorm22_running_var: Tensor[(512,), float32], %mobilenet0_conv23_weight: Tensor[(512, 1, 3, 3), float32], %mobilenet0_batchnorm23_gamma: Tensor[(512,), float32], %mobilenet0_batchnorm23_beta: Tensor[(512,), float32], %mobilenet0_batchnorm23_running_mean: Tensor[(512,), float32], %mobilenet0_batchnorm23_running_var: Tensor[(512,), float32], %mobilenet0_conv24_weight: Tensor[(1024, 512, 1, 1), float32], %mobilenet0_batchnorm24_gamma: Tensor[(1024,), float32], %mobilenet0_batchnorm24_beta: Tensor[(1024,), float32], %mobilenet0_batchnorm24_running_mean: Tensor[(1024,), float32], %mobilenet0_batchnorm24_running_var: Tensor[(1024,), float32], %mobilenet0_conv25_weight: Tensor[(1024, 1, 3, 3), float32], %mobilenet0_batchnorm25_gamma: Tensor[(1024,), float32], %mobilenet0_batchnorm25_beta: Tensor[(1024,), float32], %mobilenet0_batchnorm25_running_mean: Tensor[(1024,), float32], %mobilenet0_batchnorm25_running_var: Tensor[(1024,), float32], %mobilenet0_conv26_weight: Tensor[(1024, 1024, 1, 1), float32], %mobilenet0_batchnorm26_gamma: Tensor[(1024,), float32], %mobilenet0_batchnorm26_beta: Tensor[(1024,), float32], %mobilenet0_batchnorm26_running_mean: Tensor[(1024,), float32], %mobilenet0_batchnorm26_running_var: Tensor[(1024,), float32], %mobilenet0_dense0_weight: Tensor[(1000, 1024), float32], %mobilenet0_dense0_bias: Tensor[(1000,), float32]) -> Tensor[(1, 1000), float32] {
%0 = nn.conv2d(%data, %mobilenet0_conv0_weight, strides=[2, 2], padding=[1, 1], channels=32, kernel_size=[3, 3]) /* ty=Tensor[(1, 32, 112, 112), float32] */;
%1 = nn.batch_norm(%0, %mobilenet0_batchnorm0_gamma, %mobilenet0_batchnorm0_beta, %mobilenet0_batchnorm0_running_mean, %mobilenet0_batchnorm0_running_var) /* ty=(Tensor[(1, 32, 112, 112), float32], Tensor[(32,), float32], Tensor[(32,), float32]) */;
%2 = %1.0;
%3 = nn.relu(%2) /* ty=Tensor[(1, 32, 112, 112), float32] */;
%4 = nn.conv2d(%3, %mobilenet0_conv1_weight, padding=[1, 1], groups=32, channels=32, kernel_size=[3, 3]) /* ty=Tensor[(1, 32, 112, 112), float32] */;
%5 = nn.batch_norm(%4, %mobilenet0_batchnorm1_gamma, %mobilenet0_batchnorm1_beta, %mobilenet0_batchnorm1_running_mean, %mobilenet0_batchnorm1_running_var) /* ty=(Tensor[(1, 32, 112, 112), float32], Tensor[(32,), float32], Tensor[(32,), float32]) */;
%6 = %5.0;
%7 = nn.relu(%6) /* ty=Tensor[(1, 32, 112, 112), float32] */;
%8 = nn.conv2d(%7, %mobilenet0_conv2_weight, channels=64, kernel_size=[1, 1]) /* ty=Tensor[(1, 64, 112, 112), float32] */;
%9 = nn.batch_norm(%8, %mobilenet0_batchnorm2_gamma, %mobilenet0_batchnorm2_beta, %mobilenet0_batchnorm2_running_mean, %mobilenet0_batchnorm2_running_var) /* ty=(Tensor[(1, 64, 112, 112), float32], Tensor[(64,), float32], Tensor[(64,), float32]) */;
%10 = %9.0;
%11 = nn.relu(%10) /* ty=Tensor[(1, 64, 112, 112), float32] */;
%12 = nn.conv2d(%11, %mobilenet0_conv3_weight, strides=[2, 2], padding=[1, 1], groups=64, channels=64, kernel_size=[3, 3]) /* ty=Tensor[(1, 64, 56, 56), float32] */;
%13 = nn.batch_norm(%12, %mobilenet0_batchnorm3_gamma, %mobilenet0_batchnorm3_beta, %mobilenet0_batchnorm3_running_mean, %mobilenet0_batchnorm3_running_var) /* ty=(Tensor[(1, 64, 56, 56), float32], Tensor[(64,), float32], Tensor[(64,), float32]) */;
%14 = %13.0;
%15 = nn.relu(%14) /* ty=Tensor[(1, 64, 56, 56), float32] */;
%16 = nn.conv2d(%15, %mobilenet0_conv4_weight, channels=128, kernel_size=[1, 1]) /* ty=Tensor[(1, 128, 56, 56), float32] */;
%17 = nn.batch_norm(%16, %mobilenet0_batchnorm4_gamma, %mobilenet0_batchnorm4_beta, %mobilenet0_batchnorm4_running_mean, %mobilenet0_batchnorm4_running_var) /* ty=(Tensor[(1, 128, 56, 56), float32], Tensor[(128,), float32], Tensor[(128,), float32]) */;
%18 = %17.0;
%19 = nn.relu(%18) /* ty=Tensor[(1, 128, 56, 56), float32] */;
%20 = nn.conv2d(%19, %mobilenet0_conv5_weight, padding=[1, 1], groups=128, channels=128, kernel_size=[3, 3]) /* ty=Tensor[(1, 128, 56, 56), float32] */;
%21 = nn.batch_norm(%20, %mobilenet0_batchnorm5_gamma, %mobilenet0_batchnorm5_beta, %mobilenet0_batchnorm5_running_mean, %mobilenet0_batchnorm5_running_var) /* ty=(Tensor[(1, 128, 56, 56), float32], Tensor[(128,), float32], Tensor[(128,), float32]) */;
%22 = %21.0;
%23 = nn.relu(%22) /* ty=Tensor[(1, 128, 56, 56), float32] */;
%24 = nn.conv2d(%23, %mobilenet0_conv6_weight, channels=128, kernel_size=[1, 1]) /* ty=Tensor[(1, 128, 56, 56), float32] */;
%25 = nn.batch_norm(%24, %mobilenet0_batchnorm6_gamma, %mobilenet0_batchnorm6_beta, %mobilenet0_batchnorm6_running_mean, %mobilenet0_batchnorm6_running_var) /* ty=(Tensor[(1, 128, 56, 56), float32], Tensor[(128,), float32], Tensor[(128,), float32]) */;
%26 = %25.0;
%27 = nn.relu(%26) /* ty=Tensor[(1, 128, 56, 56), float32] */;
%28 = nn.conv2d(%27, %mobilenet0_conv7_weight, strides=[2, 2], padding=[1, 1], groups=128, channels=128, kernel_size=[3, 3]) /* ty=Tensor[(1, 128, 28, 28), float32] */;
%29 = nn.batch_norm(%28, %mobilenet0_batchnorm7_gamma, %mobilenet0_batchnorm7_beta, %mobilenet0_batchnorm7_running_mean, %mobilenet0_batchnorm7_running_var) /* ty=(Tensor[(1, 128, 28, 28), float32], Tensor[(128,), float32], Tensor[(128,), float32]) */;
%30 = %29.0;
%31 = nn.relu(%30) /* ty=Tensor[(1, 128, 28, 28), float32] */;
%32 = nn.conv2d(%31, %mobilenet0_conv8_weight, channels=256, kernel_size=[1, 1]) /* ty=Tensor[(1, 256, 28, 28), float32] */;
%33 = nn.batch_norm(%32, %mobilenet0_batchnorm8_gamma, %mobilenet0_batchnorm8_beta, %mobilenet0_batchnorm8_running_mean, %mobilenet0_batchnorm8_running_var) /* ty=(Tensor[(1, 256, 28, 28), float32], Tensor[(256,), float32], Tensor[(256,), float32]) */;
%34 = %33.0;
%35 = nn.relu(%34) /* ty=Tensor[(1, 256, 28, 28), float32] */;
%36 = nn.conv2d(%35, %mobilenet0_conv9_weight, padding=[1, 1], groups=256, channels=256, kernel_size=[3, 3]) /* ty=Tensor[(1, 256, 28, 28), float32] */;
%37 = nn.batch_norm(%36, %mobilenet0_batchnorm9_gamma, %mobilenet0_batchnorm9_beta, %mobilenet0_batchnorm9_running_mean, %mobilenet0_batchnorm9_running_var) /* ty=(Tensor[(1, 256, 28, 28), float32], Tensor[(256,), float32], Tensor[(256,), float32]) */;
%38 = %37.0;
%39 = nn.relu(%38) /* ty=Tensor[(1, 256, 28, 28), float32] */;
%40 = nn.conv2d(%39, %mobilenet0_conv10_weight, channels=256, kernel_size=[1, 1]) /* ty=Tensor[(1, 256, 28, 28), float32] */;
%41 = nn.batch_norm(%40, %mobilenet0_batchnorm10_gamma, %mobilenet0_batchnorm10_beta, %mobilenet0_batchnorm10_running_mean, %mobilenet0_batchnorm10_running_var) /* ty=(Tensor[(1, 256, 28, 28), float32], Tensor[(256,), float32], Tensor[(256,), float32]) */;
%42 = %41.0;
%43 = nn.relu(%42) /* ty=Tensor[(1, 256, 28, 28), float32] */;
%44 = nn.conv2d(%43, %mobilenet0_conv11_weight, strides=[2, 2], padding=[1, 1], groups=256, channels=256, kernel_size=[3, 3]) /* ty=Tensor[(1, 256, 14, 14), float32] */;
%45 = nn.batch_norm(%44, %mobilenet0_batchnorm11_gamma, %mobilenet0_batchnorm11_beta, %mobilenet0_batchnorm11_running_mean, %mobilenet0_batchnorm11_running_var) /* ty=(Tensor[(1, 256, 14, 14), float32], Tensor[(256,), float32], Tensor[(256,), float32]) */;
%46 = %45.0;
%47 = nn.relu(%46) /* ty=Tensor[(1, 256, 14, 14), float32] */;
%48 = nn.conv2d(%47, %mobilenet0_conv12_weight, channels=512, kernel_size=[1, 1]) /* ty=Tensor[(1, 512, 14, 14), float32] */;
%49 = nn.batch_norm(%48, %mobilenet0_batchnorm12_gamma, %mobilenet0_batchnorm12_beta, %mobilenet0_batchnorm12_running_mean, %mobilenet0_batchnorm12_running_var) /* ty=(Tensor[(1, 512, 14, 14), float32], Tensor[(512,), float32], Tensor[(512,), float32]) */;
%50 = %49.0;
%51 = nn.relu(%50) /* ty=Tensor[(1, 512, 14, 14), float32] */;
%52 = nn.conv2d(%51, %mobilenet0_conv13_weight, padding=[1, 1], groups=512, channels=512, kernel_size=[3, 3]) /* ty=Tensor[(1, 512, 14, 14), float32] */;
%53 = nn.batch_norm(%52, %mobilenet0_batchnorm13_gamma, %mobilenet0_batchnorm13_beta, %mobilenet0_batchnorm13_running_mean, %mobilenet0_batchnorm13_running_var) /* ty=(Tensor[(1, 512, 14, 14), float32], Tensor[(512,), float32], Tensor[(512,), float32]) */;
%54 = %53.0;
%55 = nn.relu(%54) /* ty=Tensor[(1, 512, 14, 14), float32] */;
%56 = nn.conv2d(%55, %mobilenet0_conv14_weight, channels=512, kernel_size=[1, 1]) /* ty=Tensor[(1, 512, 14, 14), float32] */;
%57 = nn.batch_norm(%56, %mobilenet0_batchnorm14_gamma, %mobilenet0_batchnorm14_beta, %mobilenet0_batchnorm14_running_mean, %mobilenet0_batchnorm14_running_var) /* ty=(Tensor[(1, 512, 14, 14), float32], Tensor[(512,), float32], Tensor[(512,), float32]) */;
%58 = %57.0;
%59 = nn.relu(%58) /* ty=Tensor[(1, 512, 14, 14), float32] */;
%60 = nn.conv2d(%59, %mobilenet0_conv15_weight, padding=[1, 1], groups=512, channels=512, kernel_size=[3, 3]) /* ty=Tensor[(1, 512, 14, 14), float32] */;
%61 = nn.batch_norm(%60, %mobilenet0_batchnorm15_gamma, %mobilenet0_batchnorm15_beta, %mobilenet0_batchnorm15_running_mean, %mobilenet0_batchnorm15_running_var) /* ty=(Tensor[(1, 512, 14, 14), float32], Tensor[(512,), float32], Tensor[(512,), float32]) */;
%62 = %61.0;
%63 = nn.relu(%62) /* ty=Tensor[(1, 512, 14, 14), float32] */;
%64 = nn.conv2d(%63, %mobilenet0_conv16_weight, channels=512, kernel_size=[1, 1]) /* ty=Tensor[(1, 512, 14, 14), float32] */;
%65 = nn.batch_norm(%64, %mobilenet0_batchnorm16_gamma, %mobilenet0_batchnorm16_beta, %mobilenet0_batchnorm16_running_mean, %mobilenet0_batchnorm16_running_var) /* ty=(Tensor[(1, 512, 14, 14), float32], Tensor[(512,), float32], Tensor[(512,), float32]) */;
%66 = %65.0;
%67 = nn.relu(%66) /* ty=Tensor[(1, 512, 14, 14), float32] */;
%68 = nn.conv2d(%67, %mobilenet0_conv17_weight, padding=[1, 1], groups=512, channels=512, kernel_size=[3, 3]) /* ty=Tensor[(1, 512, 14, 14), float32] */;
%69 = nn.batch_norm(%68, %mobilenet0_batchnorm17_gamma, %mobilenet0_batchnorm17_beta, %mobilenet0_batchnorm17_running_mean, %mobilenet0_batchnorm17_running_var) /* ty=(Tensor[(1, 512, 14, 14), float32], Tensor[(512,), float32], Tensor[(512,), float32]) */;
%70 = %69.0;
%71 = nn.relu(%70) /* ty=Tensor[(1, 512, 14, 14), float32] */;
%72 = nn.conv2d(%71, %mobilenet0_conv18_weight, channels=512, kernel_size=[1, 1]) /* ty=Tensor[(1, 512, 14, 14), float32] */;
%73 = nn.batch_norm(%72, %mobilenet0_batchnorm18_gamma, %mobilenet0_batchnorm18_beta, %mobilenet0_batchnorm18_running_mean, %mobilenet0_batchnorm18_running_var) /* ty=(Tensor[(1, 512, 14, 14), float32], Tensor[(512,), float32], Tensor[(512,), float32]) */;
%74 = %73.0;
%75 = nn.relu(%74) /* ty=Tensor[(1, 512, 14, 14), float32] */;
%76 = nn.conv2d(%75, %mobilenet0_conv19_weight, padding=[1, 1], groups=512, channels=512, kernel_size=[3, 3]) /* ty=Tensor[(1, 512, 14, 14), float32] */;
%77 = nn.batch_norm(%76, %mobilenet0_batchnorm19_gamma, %mobilenet0_batchnorm19_beta, %mobilenet0_batchnorm19_running_mean, %mobilenet0_batchnorm19_running_var) /* ty=(Tensor[(1, 512, 14, 14), float32], Tensor[(512,), float32], Tensor[(512,), float32]) */;
%78 = %77.0;
%79 = nn.relu(%78) /* ty=Tensor[(1, 512, 14, 14), float32] */;
%80 = nn.conv2d(%79, %mobilenet0_conv20_weight, channels=512, kernel_size=[1, 1]) /* ty=Tensor[(1, 512, 14, 14), float32] */;
%81 = nn.batch_norm(%80, %mobilenet0_batchnorm20_gamma, %mobilenet0_batchnorm20_beta, %mobilenet0_batchnorm20_running_mean, %mobilenet0_batchnorm20_running_var) /* ty=(Tensor[(1, 512, 14, 14), float32], Tensor[(512,), float32], Tensor[(512,), float32]) */;
%82 = %81.0;
%83 = nn.relu(%82) /* ty=Tensor[(1, 512, 14, 14), float32] */;
%84 = nn.conv2d(%83, %mobilenet0_conv21_weight, padding=[1, 1], groups=512, channels=512, kernel_size=[3, 3]) /* ty=Tensor[(1, 512, 14, 14), float32] */;
%85 = nn.batch_norm(%84, %mobilenet0_batchnorm21_gamma, %mobilenet0_batchnorm21_beta, %mobilenet0_batchnorm21_running_mean, %mobilenet0_batchnorm21_running_var) /* ty=(Tensor[(1, 512, 14, 14), float32], Tensor[(512,), float32], Tensor[(512,), float32]) */;
%86 = %85.0;
%87 = nn.relu(%86) /* ty=Tensor[(1, 512, 14, 14), float32] */;
%88 = nn.conv2d(%87, %mobilenet0_conv22_weight, channels=512, kernel_size=[1, 1]) /* ty=Tensor[(1, 512, 14, 14), float32] */;
%89 = nn.batch_norm(%88, %mobilenet0_batchnorm22_gamma, %mobilenet0_batchnorm22_beta, %mobilenet0_batchnorm22_running_mean, %mobilenet0_batchnorm22_running_var) /* ty=(Tensor[(1, 512, 14, 14), float32], Tensor[(512,), float32], Tensor[(512,), float32]) */;
%90 = %89.0;
%91 = nn.relu(%90) /* ty=Tensor[(1, 512, 14, 14), float32] */;
%92 = nn.conv2d(%91, %mobilenet0_conv23_weight, strides=[2, 2], padding=[1, 1], groups=512, channels=512, kernel_size=[3, 3]) /* ty=Tensor[(1, 512, 7, 7), float32] */;
%93 = nn.batch_norm(%92, %mobilenet0_batchnorm23_gamma, %mobilenet0_batchnorm23_beta, %mobilenet0_batchnorm23_running_mean, %mobilenet0_batchnorm23_running_var) /* ty=(Tensor[(1, 512, 7, 7), float32], Tensor[(512,), float32], Tensor[(512,), float32]) */;
%94 = %93.0;
%95 = nn.relu(%94) /* ty=Tensor[(1, 512, 7, 7), float32] */;
%96 = nn.conv2d(%95, %mobilenet0_conv24_weight, channels=1024, kernel_size=[1, 1]) /* ty=Tensor[(1, 1024, 7, 7), float32] */;
%97 = nn.batch_norm(%96, %mobilenet0_batchnorm24_gamma, %mobilenet0_batchnorm24_beta, %mobilenet0_batchnorm24_running_mean, %mobilenet0_batchnorm24_running_var) /* ty=(Tensor[(1, 1024, 7, 7), float32], Tensor[(1024,), float32], Tensor[(1024,), float32]) */;
%98 = %97.0;
%99 = nn.relu(%98) /* ty=Tensor[(1, 1024, 7, 7), float32] */;
%100 = nn.conv2d(%99, %mobilenet0_conv25_weight, padding=[1, 1], groups=1024, channels=1024, kernel_size=[3, 3]) /* ty=Tensor[(1, 1024, 7, 7), float32] */;
%101 = nn.batch_norm(%100, %mobilenet0_batchnorm25_gamma, %mobilenet0_batchnorm25_beta, %mobilenet0_batchnorm25_running_mean, %mobilenet0_batchnorm25_running_var) /* ty=(Tensor[(1, 1024, 7, 7), float32], Tensor[(1024,), float32], Tensor[(1024,), float32]) */;
%102 = %101.0;
%103 = nn.relu(%102) /* ty=Tensor[(1, 1024, 7, 7), float32] */;
%104 = nn.conv2d(%103, %mobilenet0_conv26_weight, channels=1024, kernel_size=[1, 1]) /* ty=Tensor[(1, 1024, 7, 7), float32] */;
%105 = nn.batch_norm(%104, %mobilenet0_batchnorm26_gamma, %mobilenet0_batchnorm26_beta, %mobilenet0_batchnorm26_running_mean, %mobilenet0_batchnorm26_running_var) /* ty=(Tensor[(1, 1024, 7, 7), float32], Tensor[(1024,), float32], Tensor[(1024,), float32]) */;
%106 = %105.0;
%107 = nn.relu(%106) /* ty=Tensor[(1, 1024, 7, 7), float32] */;
%108 = nn.global_avg_pool2d(%107) /* ty=Tensor[(1, 1024, 1, 1), float32] */;
%109 = nn.batch_flatten(%108) /* ty=Tensor[(1, 1024), float32] */;
%110 = nn.batch_flatten(%109) /* ty=Tensor[(1, 1024), float32] */;
%111 = nn.dense(%110, %mobilenet0_dense0_weight, units=1000) /* ty=Tensor[(1, 1000), float32] */;
nn.bias_add(%111, %mobilenet0_dense0_bias, axis=-1) /* ty=Tensor[(1, 1000), float32] */
}
After optimization
------------------
def @main(%data: Tensor[(1, 3, 224, 224), float32]) -> Tensor[(1, 1000), float32] {
%0 = fn (%p0: Tensor[(1, 3, 224, 224), float32], %p1: Tensor[(32, 3, 3, 3), float32], Primitive=1) -> Tensor[(1, 32, 112, 112), float32] {
nn.conv2d(%p0, %p1, strides=[2, 2], padding=[1, 1], channels=32, kernel_size=[3, 3]) /* ty=Tensor[(1, 32, 112, 112), float32] */
};
%1 = %0(%data, meta[relay.Constant][0] /* ty=Tensor[(32, 3, 3, 3), float32] */ /* ty=Tensor[(32, 3, 3, 3), float32] */) /* ty=Tensor[(1, 32, 112, 112), float32] */;
%2 = fn (%p01: Tensor[(32,), float32], %p11: float32, Primitive=1) -> Tensor[(32,), float32] {
add(%p01, %p11) /* ty=Tensor[(32,), float32] */
};
%3 = %2(meta[relay.Constant][1] /* ty=Tensor[(32,), float32] */ /* ty=Tensor[(32,), float32] */, 1e-05f /* ty=float32 */) /* ty=Tensor[(32,), float32] */;
%4 = fn (%p02: Tensor[(32,), float32], Primitive=1) -> Tensor[(32,), float32] {
sqrt(%p02) /* ty=Tensor[(32,), float32] */
};
%5 = %4(%3) /* ty=Tensor[(32,), float32] */;
%6 = fn (%p03: float32, %p12: Tensor[(32,), float32], Primitive=1) -> Tensor[(32,), float32] {
divide(%p03, %p12) /* ty=Tensor[(32,), float32] */
};
%7 = %6(1f /* ty=float32 */, %5) /* ty=Tensor[(32,), float32] */;
%8 = fn (%p04: Tensor[(32,), float32], %p13: Tensor[(32,), float32], Primitive=1) -> Tensor[(32,), float32] {
multiply(%p04, %p13) /* ty=Tensor[(32,), float32] */
};
%9 = %8(%7, meta[relay.Constant][2] /* ty=Tensor[(32,), float32] */ /* ty=Tensor[(32,), float32] */) /* ty=Tensor[(32,), float32] */;
%10 = fn (%p05: Tensor[(32,), float32], Primitive=1) -> Tensor[(32, 1, 1), float32] {
expand_dims(%p05, axis=1, num_newaxis=2) /* ty=Tensor[(32, 1, 1), float32] */
};
%11 = %10(%9) /* ty=Tensor[(32, 1, 1), float32] */;
%12 = fn (%p06: Tensor[(1, 32, 112, 112), float32], %p14: Tensor[(32, 1, 1), float32], Primitive=1) -> Tensor[(1, 32, 112, 112), float32] {
multiply(%p06, %p14) /* ty=Tensor[(1, 32, 112, 112), float32] */
};
%13 = %12(%1, %11) /* ty=Tensor[(1, 32, 112, 112), float32] */;
%14 = fn (%p07: Tensor[(32,), float32], Primitive=1) -> Tensor[(32,), float32] {
negative(%p07) /* ty=Tensor[(32,), float32] */
};
%15 = %14(meta[relay.Constant][3] /* ty=Tensor[(32,), float32] */ /* ty=Tensor[(32,), float32] */) /* ty=Tensor[(32,), float32] */;
%16 = fn (%p08: Tensor[(32,), float32], %p15: Tensor[(32,), float32], Primitive=1) -> Tensor[(32,), float32] {
multiply(%p08, %p15) /* ty=Tensor[(32,), float32] */
};
%17 = %16(%15, %9) /* ty=Tensor[(32,), float32] */;
%18 = fn (%p09: Tensor[(32,), float32], %p16: Tensor[(32,), float32], Primitive=1) -> Tensor[(32,), float32] {
add(%p09, %p16) /* ty=Tensor[(32,), float32] */
};
%19 = %18(%17, meta[relay.Constant][4] /* ty=Tensor[(32,), float32] */ /* ty=Tensor[(32,), float32] */) /* ty=Tensor[(32,), float32] */;
%20 = fn (%p010: Tensor[(32,), float32], Primitive=1) -> Tensor[(32, 1, 1), float32] {
expand_dims(%p010, axis=1, num_newaxis=2) /* ty=Tensor[(32, 1, 1), float32] */
};
%21 = %20(%19) /* ty=Tensor[(32, 1, 1), float32] */;
%22 = fn (%p011: Tensor[(1, 32, 112, 112), float32], %p17: Tensor[(32, 1, 1), float32], Primitive=1) -> Tensor[(1, 32, 112, 112), float32] {
add(%p011, %p17) /* ty=Tensor[(1, 32, 112, 112), float32] */
};
%23 = %22(%13, %21) /* ty=Tensor[(1, 32, 112, 112), float32] */;
%24 = fn (%p012: Tensor[(1, 32, 112, 112), float32], Primitive=1) -> Tensor[(1, 32, 112, 112), float32] {
nn.relu(%p012) /* ty=Tensor[(1, 32, 112, 112), float32] */
};
%25 = %24(%23) /* ty=Tensor[(1, 32, 112, 112), float32] */;
%26 = fn (%p013: Tensor[(1, 32, 112, 112), float32], %p18: Tensor[(32, 1, 3, 3), float32], Primitive=1) -> Tensor[(1, 32, 112, 112), float32] {
nn.conv2d(%p013, %p18, padding=[1, 1], groups=32, channels=32, kernel_size=[3, 3]) /* ty=Tensor[(1, 32, 112, 112), float32] */
};
%27 = %26(%25, meta[relay.Constant][5] /* ty=Tensor[(32, 1, 3, 3), float32] */ /* ty=Tensor[(32, 1, 3, 3), float32] */) /* ty=Tensor[(1, 32, 112, 112), float32] */;
%28 = fn (%p014: Tensor[(32,), float32], %p19: float32, Primitive=1) -> Tensor[(32,), float32] {
add(%p014, %p19) /* ty=Tensor[(32,), float32] */
};
%29 = %28(meta[relay.Constant][6] /* ty=Tensor[(32,), float32] */ /* ty=Tensor[(32,), float32] */, 1e-05f /* ty=float32 */) /* ty=Tensor[(32,), float32] */;
%30 = fn (%p015: Tensor[(32,), float32], Primitive=1) -> Tensor[(32,), float32] {
sqrt(%p015) /* ty=Tensor[(32,), float32] */
};
%31 = %30(%29) /* ty=Tensor[(32,), float32] */;
%32 = fn (%p016: float32, %p110: Tensor[(32,), float32], Primitive=1) -> Tensor[(32,), float32] {
divide(%p016, %p110) /* ty=Tensor[(32,), float32] */
};
%33 = %32(1f /* ty=float32 */, %31) /* ty=Tensor[(32,), float32] */;
%34 = fn (%p017: Tensor[(32,), float32], %p111: Tensor[(32,), float32], Primitive=1) -> Tensor[(32,), float32] {
multiply(%p017, %p111) /* ty=Tensor[(32,), float32] */
};
%35 = %34(%33, meta[relay.Constant][7] /* ty=Tensor[(32,), float32] */ /* ty=Tensor[(32,), float32] */) /* ty=Tensor[(32,), float32] */;
%36 = fn (%p018: Tensor[(32,), float32], Primitive=1) -> Tensor[(32, 1, 1), float32] {
expand_dims(%p018, axis=1, num_newaxis=2) /* ty=Tensor[(32, 1, 1), float32] */
};
%37 = %36(%35) /* ty=Tensor[(32, 1, 1), float32] */;
%38 = fn (%p019: Tensor[(1, 32, 112, 112), float32], %p112: Tensor[(32, 1, 1), float32], Primitive=1) -> Tensor[(1, 32, 112, 112), float32] {
multiply(%p019, %p112) /* ty=Tensor[(1, 32, 112, 112), float32] */
};
%39 = %38(%27, %37) /* ty=Tensor[(1, 32, 112, 112), float32] */;
%40 = fn (%p020: Tensor[(32,), float32], Primitive=1) -> Tensor[(32,), float32] {
negative(%p020) /* ty=Tensor[(32,), float32] */
};
%41 = %40(meta[relay.Constant][8] /* ty=Tensor[(32,), float32] */ /* ty=Tensor[(32,), float32] */) /* ty=Tensor[(32,), float32] */;
%42 = fn (%p021: Tensor[(32,), float32], %p113: Tensor[(32,), float32], Primitive=1) -> Tensor[(32,), float32] {
multiply(%p021, %p113) /* ty=Tensor[(32,), float32] */
};
%43 = %42(%41, %35) /* ty=Tensor[(32,), float32] */;
%44 = fn (%p022: Tensor[(32,), float32], %p114: Tensor[(32,), float32], Primitive=1) -> Tensor[(32,), float32] {
add(%p022, %p114) /* ty=Tensor[(32,), float32] */
};
%45 = %44(%43, meta[relay.Constant][9] /* ty=Tensor[(32,), float32] */ /* ty=Tensor[(32,), float32] */) /* ty=Tensor[(32,), float32] */;
%46 = fn (%p023: Tensor[(32,), float32], Primitive=1) -> Tensor[(32, 1, 1), float32] {
expand_dims(%p023, axis=1, num_newaxis=2) /* ty=Tensor[(32, 1, 1), float32] */
};
%47 = %46(%45) /* ty=Tensor[(32, 1, 1), float32] */;
%48 = fn (%p024: Tensor[(1, 32, 112, 112), float32], %p115: Tensor[(32, 1, 1), float32], Primitive=1) -> Tensor[(1, 32, 112, 112), float32] {
add(%p024, %p115) /* ty=Tensor[(1, 32, 112, 112), float32] */
};
%49 = %48(%39, %47) /* ty=Tensor[(1, 32, 112, 112), float32] */;
%50 = fn (%p025: Tensor[(1, 32, 112, 112), float32], Primitive=1) -> Tensor[(1, 32, 112, 112), float32] {
nn.relu(%p025) /* ty=Tensor[(1, 32, 112, 112), float32] */
};
%51 = %50(%49) /* ty=Tensor[(1, 32, 112, 112), float32] */;
%52 = fn (%p026: Tensor[(1, 32, 112, 112), float32], %p116: Tensor[(64, 32, 1, 1), float32], Primitive=1) -> Tensor[(1, 64, 112, 112), float32] {
nn.conv2d(%p026, %p116, channels=64, kernel_size=[1, 1]) /* ty=Tensor[(1, 64, 112, 112), float32] */
};
%53 = %52(%51, meta[relay.Constant][10] /* ty=Tensor[(64, 32, 1, 1), float32] */ /* ty=Tensor[(64, 32, 1, 1), float32] */) /* ty=Tensor[(1, 64, 112, 112), float32] */;
%54 = fn (%p027: Tensor[(64,), float32], %p117: float32, Primitive=1) -> Tensor[(64,), float32] {
add(%p027, %p117) /* ty=Tensor[(64,), float32] */
};
%55 = %54(meta[relay.Constant][11] /* ty=Tensor[(64,), float32] */ /* ty=Tensor[(64,), float32] */, 1e-05f /* ty=float32 */) /* ty=Tensor[(64,), float32] */;
%56 = fn (%p028: Tensor[(64,), float32], Primitive=1) -> Tensor[(64,), float32] {
sqrt(%p028) /* ty=Tensor[(64,), float32] */
};
%57 = %56(%55) /* ty=Tensor[(64,), float32] */;
%58 = fn (%p029: float32, %p118: Tensor[(64,), float32], Primitive=1) -> Tensor[(64,), float32] {
divide(%p029, %p118) /* ty=Tensor[(64,), float32] */
};
%59 = %58(1f /* ty=float32 */, %57) /* ty=Tensor[(64,), float32] */;
%60 = fn (%p030: Tensor[(64,), float32], %p119: Tensor[(64,), float32], Primitive=1) -> Tensor[(64,), float32] {
multiply(%p030, %p119) /* ty=Tensor[(64,), float32] */
};
%61 = %60(%59, meta[relay.Constant][12] /* ty=Tensor[(64,), float32] */ /* ty=Tensor[(64,), float32] */) /* ty=Tensor[(64,), float32] */;
%62 = fn (%p031: Tensor[(64,), float32], Primitive=1) -> Tensor[(64, 1, 1), float32] {
expand_dims(%p031, axis=1, num_newaxis=2) /* ty=Tensor[(64, 1, 1), float32] */
};
%63 = %62(%61) /* ty=Tensor[(64, 1, 1), float32] */;
%64 = fn (%p032: Tensor[(1, 64, 112, 112), float32], %p120: Tensor[(64, 1, 1), float32], Primitive=1) -> Tensor[(1, 64, 112, 112), float32] {
multiply(%p032, %p120) /* ty=Tensor[(1, 64, 112, 112), float32] */
};
%65 = %64(%53, %63) /* ty=Tensor[(1, 64, 112, 112), float32] */;
%66 = fn (%p033: Tensor[(64,), float32], Primitive=1) -> Tensor[(64,), float32] {
negative(%p033) /* ty=Tensor[(64,), float32] */
};
%67 = %66(meta[relay.Constant][13] /* ty=Tensor[(64,), float32] */ /* ty=Tensor[(64,), float32] */) /* ty=Tensor[(64,), float32] */;
%68 = fn (%p034: Tensor[(64,), float32], %p121: Tensor[(64,), float32], Primitive=1) -> Tensor[(64,), float32] {
multiply(%p034, %p121) /* ty=Tensor[(64,), float32] */
};
%69 = %68(%67, %61) /* ty=Tensor[(64,), float32] */;
%70 = fn (%p035: Tensor[(64,), float32], %p122: Tensor[(64,), float32], Primitive=1) -> Tensor[(64,), float32] {
add(%p035, %p122) /* ty=Tensor[(64,), float32] */
};
%71 = %70(%69, meta[relay.Constant][14] /* ty=Tensor[(64,), float32] */ /* ty=Tensor[(64,), float32] */) /* ty=Tensor[(64,), float32] */;
%72 = fn (%p036: Tensor[(64,), float32], Primitive=1) -> Tensor[(64, 1, 1), float32] {
expand_dims(%p036, axis=1, num_newaxis=2) /* ty=Tensor[(64, 1, 1), float32] */
};
%73 = %72(%71) /* ty=Tensor[(64, 1, 1), float32] */;
%74 = fn (%p037: Tensor[(1, 64, 112, 112), float32], %p123: Tensor[(64, 1, 1), float32], Primitive=1) -> Tensor[(1, 64, 112, 112), float32] {
add(%p037, %p123) /* ty=Tensor[(1, 64, 112, 112), float32] */
};
%75 = %74(%65, %73) /* ty=Tensor[(1, 64, 112, 112), float32] */;
%76 = fn (%p038: Tensor[(1, 64, 112, 112), float32], Primitive=1) -> Tensor[(1, 64, 112, 112), float32] {
nn.relu(%p038) /* ty=Tensor[(1, 64, 112, 112), float32] */
};
%77 = %76(%75) /* ty=Tensor[(1, 64, 112, 112), float32] */;
%78 = fn (%p039: Tensor[(1, 64, 112, 112), float32], %p124: Tensor[(64, 1, 3, 3), float32], Primitive=1) -> Tensor[(1, 64, 56, 56), float32] {
nn.conv2d(%p039, %p124, strides=[2, 2], padding=[1, 1], groups=64, channels=64, kernel_size=[3, 3]) /* ty=Tensor[(1, 64, 56, 56), float32] */
};
%79 = %78(%77, meta[relay.Constant][15] /* ty=Tensor[(64, 1, 3, 3), float32] */ /* ty=Tensor[(64, 1, 3, 3), float32] */) /* ty=Tensor[(1, 64, 56, 56), float32] */;
%80 = fn (%p040: Tensor[(64,), float32], %p125: float32, Primitive=1) -> Tensor[(64,), float32] {
add(%p040, %p125) /* ty=Tensor[(64,), float32] */
};
%81 = %80(meta[relay.Constant][16] /* ty=Tensor[(64,), float32] */ /* ty=Tensor[(64,), float32] */, 1e-05f /* ty=float32 */) /* ty=Tensor[(64,), float32] */;
%82 = fn (%p041: Tensor[(64,), float32], Primitive=1) -> Tensor[(64,), float32] {
sqrt(%p041) /* ty=Tensor[(64,), float32] */
};
%83 = %82(%81) /* ty=Tensor[(64,), float32] */;
%84 = fn (%p042: float32, %p126: Tensor[(64,), float32], Primitive=1) -> Tensor[(64,), float32] {
divide(%p042, %p126) /* ty=Tensor[(64,), float32] */
};
%85 = %84(1f /* ty=float32 */, %83) /* ty=Tensor[(64,), float32] */;
%86 = fn (%p043: Tensor[(64,), float32], %p127: Tensor[(64,), float32], Primitive=1) -> Tensor[(64,), float32] {
multiply(%p043, %p127) /* ty=Tensor[(64,), float32] */
};
%87 = %86(%85, meta[relay.Constant][17] /* ty=Tensor[(64,), float32] */ /* ty=Tensor[(64,), float32] */) /* ty=Tensor[(64,), float32] */;
%88 = fn (%p044: Tensor[(64,), float32], Primitive=1) -> Tensor[(64, 1, 1), float32] {
expand_dims(%p044, axis=1, num_newaxis=2) /* ty=Tensor[(64, 1, 1), float32] */
};
%89 = %88(%87) /* ty=Tensor[(64, 1, 1), float32] */;
%90 = fn (%p045: Tensor[(1, 64, 56, 56), float32], %p128: Tensor[(64, 1, 1), float32], Primitive=1) -> Tensor[(1, 64, 56, 56), float32] {
multiply(%p045, %p128) /* ty=Tensor[(1, 64, 56, 56), float32] */
};
%91 = %90(%79, %89) /* ty=Tensor[(1, 64, 56, 56), float32] */;
%92 = fn (%p046: Tensor[(64,), float32], Primitive=1) -> Tensor[(64,), float32] {
negative(%p046) /* ty=Tensor[(64,), float32] */
};
%93 = %92(meta[relay.Constant][18] /* ty=Tensor[(64,), float32] */ /* ty=Tensor[(64,), float32] */) /* ty=Tensor[(64,), float32] */;
%94 = fn (%p047: Tensor[(64,), float32], %p129: Tensor[(64,), float32], Primitive=1) -> Tensor[(64,), float32] {
multiply(%p047, %p129) /* ty=Tensor[(64,), float32] */
};
%95 = %94(%93, %87) /* ty=Tensor[(64,), float32] */;
%96 = fn (%p048: Tensor[(64,), float32], %p130: Tensor[(64,), float32], Primitive=1) -> Tensor[(64,), float32] {
add(%p048, %p130) /* ty=Tensor[(64,), float32] */
};
%97 = %96(%95, meta[relay.Constant][19] /* ty=Tensor[(64,), float32] */ /* ty=Tensor[(64,), float32] */) /* ty=Tensor[(64,), float32] */;
%98 = fn (%p049: Tensor[(64,), float32], Primitive=1) -> Tensor[(64, 1, 1), float32] {
expand_dims(%p049, axis=1, num_newaxis=2) /* ty=Tensor[(64, 1, 1), float32] */
};
%99 = %98(%97) /* ty=Tensor[(64, 1, 1), float32] */;
%100 = fn (%p050: Tensor[(1, 64, 56, 56), float32], %p131: Tensor[(64, 1, 1), float32], Primitive=1) -> Tensor[(1, 64, 56, 56), float32] {
add(%p050, %p131) /* ty=Tensor[(1, 64, 56, 56), float32] */
};
%101 = %100(%91, %99) /* ty=Tensor[(1, 64, 56, 56), float32] */;
%102 = fn (%p051: Tensor[(1, 64, 56, 56), float32], Primitive=1) -> Tensor[(1, 64, 56, 56), float32] {
nn.relu(%p051) /* ty=Tensor[(1, 64, 56, 56), float32] */
};
%103 = %102(%101) /* ty=Tensor[(1, 64, 56, 56), float32] */;
%104 = fn (%p052: Tensor[(1, 64, 56, 56), float32], %p132: Tensor[(128, 64, 1, 1), float32], Primitive=1) -> Tensor[(1, 128, 56, 56), float32] {
nn.conv2d(%p052, %p132, channels=128, kernel_size=[1, 1]) /* ty=Tensor[(1, 128, 56, 56), float32] */
};
%105 = %104(%103, meta[relay.Constant][20] /* ty=Tensor[(128, 64, 1, 1), float32] */ /* ty=Tensor[(128, 64, 1, 1), float32] */) /* ty=Tensor[(1, 128, 56, 56), float32] */;
%106 = fn (%p053: Tensor[(128,), float32], %p133: float32, Primitive=1) -> Tensor[(128,), float32] {
add(%p053, %p133) /* ty=Tensor[(128,), float32] */
};
%107 = %106(meta[relay.Constant][21] /* ty=Tensor[(128,), float32] */ /* ty=Tensor[(128,), float32] */, 1e-05f /* ty=float32 */) /* ty=Tensor[(128,), float32] */;
%108 = fn (%p054: Tensor[(128,), float32], Primitive=1) -> Tensor[(128,), float32] {
sqrt(%p054) /* ty=Tensor[(128,), float32] */
};
%109 = %108(%107) /* ty=Tensor[(128,), float32] */;
%110 = fn (%p055: float32, %p134: Tensor[(128,), float32], Primitive=1) -> Tensor[(128,), float32] {
divide(%p055, %p134) /* ty=Tensor[(128,), float32] */
};
%111 = %110(1f /* ty=float32 */, %109) /* ty=Tensor[(128,), float32] */;
%112 = fn (%p056: Tensor[(128,), float32], %p135: Tensor[(128,), float32], Primitive=1) -> Tensor[(128,), float32] {
multiply(%p056, %p135) /* ty=Tensor[(128,), float32] */
};
%113 = %112(%111, meta[relay.Constant][22] /* ty=Tensor[(128,), float32] */ /* ty=Tensor[(128,), float32] */) /* ty=Tensor[(128,), float32] */;
%114 = fn (%p057: Tensor[(128,), float32], Primitive=1) -> Tensor[(128, 1, 1), float32] {
expand_dims(%p057, axis=1, num_newaxis=2) /* ty=Tensor[(128, 1, 1), float32] */
};
%115 = %114(%113) /* ty=Tensor[(128, 1, 1), float32] */;
%116 = fn (%p058: Tensor[(1, 128, 56, 56), float32], %p136: Tensor[(128, 1, 1), float32], Primitive=1) -> Tensor[(1, 128, 56, 56), float32] {
multiply(%p058, %p136) /* ty=Tensor[(1, 128, 56, 56), float32] */
};
%117 = %116(%105, %115) /* ty=Tensor[(1, 128, 56, 56), float32] */;
%118 = fn (%p059: Tensor[(128,), float32], Primitive=1) -> Tensor[(128,), float32] {
negative(%p059) /* ty=Tensor[(128,), float32] */
};
%119 = %118(meta[relay.Constant][23] /* ty=Tensor[(128,), float32] */ /* ty=Tensor[(128,), float32] */) /* ty=Tensor[(128,), float32] */;
%120 = fn (%p060: Tensor[(128,), float32], %p137: Tensor[(128,), float32], Primitive=1) -> Tensor[(128,), float32] {
multiply(%p060, %p137) /* ty=Tensor[(128,), float32] */
};
%121 = %120(%119, %113) /* ty=Tensor[(128,), float32] */;
%122 = fn (%p061: Tensor[(128,), float32], %p138: Tensor[(128,), float32], Primitive=1) -> Tensor[(128,), float32] {
add(%p061, %p138) /* ty=Tensor[(128,), float32] */
};
%123 = %122(%121, meta[relay.Constant][24] /* ty=Tensor[(128,), float32] */ /* ty=Tensor[(128,), float32] */) /* ty=Tensor[(128,), float32] */;
%124 = fn (%p062: Tensor[(128,), float32], Primitive=1) -> Tensor[(128, 1, 1), float32] {
expand_dims(%p062, axis=1, num_newaxis=2) /* ty=Tensor[(128, 1, 1), float32] */
};
%125 = %124(%123) /* ty=Tensor[(128, 1, 1), float32] */;
%126 = fn (%p063: Tensor[(1, 128, 56, 56), float32], %p139: Tensor[(128, 1, 1), float32], Primitive=1) -> Tensor[(1, 128, 56, 56), float32] {
add(%p063, %p139) /* ty=Tensor[(1, 128, 56, 56), float32] */
};
%127 = %126(%117, %125) /* ty=Tensor[(1, 128, 56, 56), float32] */;
%128 = fn (%p064: Tensor[(1, 128, 56, 56), float32], Primitive=1) -> Tensor[(1, 128, 56, 56), float32] {
nn.relu(%p064) /* ty=Tensor[(1, 128, 56, 56), float32] */
};
%129 = %128(%127) /* ty=Tensor[(1, 128, 56, 56), float32] */;
%130 = fn (%p065: Tensor[(1, 128, 56, 56), float32], %p140: Tensor[(128, 1, 3, 3), float32], Primitive=1) -> Tensor[(1, 128, 56, 56), float32] {
nn.conv2d(%p065, %p140, padding=[1, 1], groups=128, channels=128, kernel_size=[3, 3]) /* ty=Tensor[(1, 128, 56, 56), float32] */
};
%131 = %130(%129, meta[relay.Constant][25] /* ty=Tensor[(128, 1, 3, 3), float32] */ /* ty=Tensor[(128, 1, 3, 3), float32] */) /* ty=Tensor[(1, 128, 56, 56), float32] */;
%132 = fn (%p066: Tensor[(128,), float32], %p141: float32, Primitive=1) -> Tensor[(128,), float32] {
add(%p066, %p141) /* ty=Tensor[(128,), float32] */
};
%133 = %132(meta[relay.Constant][26] /* ty=Tensor[(128,), float32] */ /* ty=Tensor[(128,), float32] */, 1e-05f /* ty=float32 */) /* ty=Tensor[(128,), float32] */;
%134 = fn (%p067: Tensor[(128,), float32], Primitive=1) -> Tensor[(128,), float32] {
sqrt(%p067) /* ty=Tensor[(128,), float32] */
};
%135 = %134(%133) /* ty=Tensor[(128,), float32] */;
%136 = fn (%p068: float32, %p142: Tensor[(128,), float32], Primitive=1) -> Tensor[(128,), float32] {
divide(%p068, %p142) /* ty=Tensor[(128,), float32] */
};
%137 = %136(1f /* ty=float32 */, %135) /* ty=Tensor[(128,), float32] */;
%138 = fn (%p069: Tensor[(128,), float32], %p143: Tensor[(128,), float32], Primitive=1) -> Tensor[(128,), float32] {
multiply(%p069, %p143) /* ty=Tensor[(128,), float32] */
};
%139 = %138(%137, meta[relay.Constant][27] /* ty=Tensor[(128,), float32] */ /* ty=Tensor[(128,), float32] */) /* ty=Tensor[(128,), float32] */;
%140 = fn (%p070: Tensor[(128,), float32], Primitive=1) -> Tensor[(128, 1, 1), float32] {
expand_dims(%p070, axis=1, num_newaxis=2) /* ty=Tensor[(128, 1, 1), float32] */
};
%141 = %140(%139) /* ty=Tensor[(128, 1, 1), float32] */;
%142 = fn (%p071: Tensor[(1, 128, 56, 56), float32], %p144: Tensor[(128, 1, 1), float32], Primitive=1) -> Tensor[(1, 128, 56, 56), float32] {
multiply(%p071, %p144) /* ty=Tensor[(1, 128, 56, 56), float32] */
};
%143 = %142(%131, %141) /* ty=Tensor[(1, 128, 56, 56), float32] */;
%144 = fn (%p072: Tensor[(128,), float32], Primitive=1) -> Tensor[(128,), float32] {
negative(%p072) /* ty=Tensor[(128,), float32] */
};
%145 = %144(meta[relay.Constant][28] /* ty=Tensor[(128,), float32] */ /* ty=Tensor[(128,), float32] */) /* ty=Tensor[(128,), float32] */;
%146 = fn (%p073: Tensor[(128,), float32], %p145: Tensor[(128,), float32], Primitive=1) -> Tensor[(128,), float32] {
multiply(%p073, %p145) /* ty=Tensor[(128,), float32] */
};
%147 = %146(%145, %139) /* ty=Tensor[(128,), float32] */;
%148 = fn (%p074: Tensor[(128,), float32], %p146: Tensor[(128,), float32], Primitive=1) -> Tensor[(128,), float32] {
add(%p074, %p146) /* ty=Tensor[(128,), float32] */
};
%149 = %148(%147, meta[relay.Constant][29] /* ty=Tensor[(128,), float32] */ /* ty=Tensor[(128,), float32] */) /* ty=Tensor[(128,), float32] */;
%150 = fn (%p075: Tensor[(128,), float32], Primitive=1) -> Tensor[(128, 1, 1), float32] {
expand_dims(%p075, axis=1, num_newaxis=2) /* ty=Tensor[(128, 1, 1), float32] */
};
%151 = %150(%149) /* ty=Tensor[(128, 1, 1), float32] */;
%152 = fn (%p076: Tensor[(1, 128, 56, 56), float32], %p147: Tensor[(128, 1, 1), float32], Primitive=1) -> Tensor[(1, 128, 56, 56), float
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment