code: def test_resnet(self):
      def conv1x1(in_planes, out_planes, stride=1):
          """1x1 convolution"""
          return nn.Conv2d(
              in_planes,
              out_planes,
              kernel_size=1,
              stride=stride,
              bias=False,
          )
  
      def conv3x3(in_planes, out_planes, stride=1):
          """3x3 convolution with padding"""
          return nn.Conv2d(
              in_planes,
              out_planes,
              kernel_size=3,
              stride=stride,
              padding=1,
              bias=False,
          )
  
      class BasicBlock(nn.Module):  # torch.jit.ScriptModule
          expansion = 1
          __constants__ = ["downsample"]
  
          def __init__(
              self, inplanes, planes, stride=1, downsample=None
          ):
              super(BasicBlock, self).__init__()
              self.conv1 = conv3x3(inplanes, planes, stride)
              self.bn1 = nn.BatchNorm2d(planes)
              self.relu = nn.ReLU(inplace=True)
              self.conv2 = conv3x3(planes, planes)
              self.bn2 = nn.BatchNorm2d(planes)
              self.downsample = downsample
              self.stride = stride
  
          # NOTE: jit cannot be annotated, otherwise, module id is not matched for recorded arguments
          # @torch.jit.script_method
          def forward(self, x):
              residual = x
  
              out = self.conv1(x)
              out = self.bn1(out)
              out = self.relu(out)
  
              out = self.conv2(out)
              out = self.bn2(out)
  
              if self.downsample is not None:
                  residual = self.downsample(x)
  
              out += residual
              out = self.relu(out)
  
              return out
  
      # NOTE: cannot inherit torch.jit.ScriptModule, otherwise, there would be error: 'RecursiveScriptModule' object has no attribute 'graph'
      class ResNet(nn.Module):  # torch.jit.ScriptModule
          __constants__ = ["layer1", "layer2", "layer3", "layer4"]
  
          def __init__(self, block, layers, num_classes=1000):
              super(ResNet, self).__init__()
              self.inplanes = 64
              self.conv1 = nn.Conv2d(
                  3, 64, kernel_size=7, stride=2, padding=3, bias=False
              )
              self.bn1 = nn.BatchNorm2d(64)
              self.relu = nn.ReLU(inplace=True)
              self.maxpool = nn.MaxPool2d(
                  kernel_size=3, stride=2, padding=1
              )
              self.layer1 = self._make_layer(block, 64, layers[0])
              self.layer2 = self._make_layer(
                  block, 128, layers[1], stride=2
              )
              self.layer3 = self._make_layer(
                  block, 256, layers[2], stride=2
              )
              self.layer4 = self._make_layer(
                  block, 512, layers[3], stride=2
              )
              self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
              self.fc = nn.Linear(512 * block.expansion, num_classes)
  
              for m in self.modules():
                  if isinstance(m, nn.Conv2d):
                      torch.nn.init.kaiming_normal_(
                          m.weight, mode="fan_out", nonlinearity="relu"
                      )
                  elif isinstance(m, nn.BatchNorm2d):
                      torch.nn.init.constant_(m.weight, 1)
                      torch.nn.init.constant_(m.bias, 0)
  
          def _make_layer(self, block, planes, blocks, stride=1):
              downsample = None
              if (
                  stride != 1
                  or self.inplanes != planes * block.expansion
              ):
                  downsample = nn.Sequential(
                      conv1x1(
                          self.inplanes,
                          planes * block.expansion,
                          stride,
                      ),
                      nn.BatchNorm2d(planes * block.expansion),
                  )
  
              layers = []
              layers.append(
                  block(self.inplanes, planes, stride, downsample)
              )
              self.inplanes = planes * block.expansion
              for _ in range(1, blocks):
                  layers.append(block(self.inplanes, planes))
  
              return nn.Sequential(*layers)
  
          # NOTE: jit cannot be annotated, otherwise, module id is not matched for recorded arguments
          # @torch.jit.script_method
          def forward(self, x):
              x = self.conv1(x)
              x = self.bn1(x)
              x = self.relu(x)
              x = self.maxpool(x)
  
              x = self.layer1(x)
              x = self.layer2(x)
              x = self.layer3(x)
              x = self.layer4(x)
  
              x = self.avgpool(x)
              x = x.view(x.size(0), -1)
              x = self.fc(x)
  
              return x
  
      resnet18 = ResNet(BasicBlock, [2, 2, 2, 2])
  
      self.checkExportImport(resnet18, (torch.randn(1, 3, 224, 224),))
  
imports: import unittest
  import torch
  import torch.nn.functional
  import torchvision
  import nni.nas.nn.pytorch.layers
  from nni.nas.nn.pytorch import ParametrizedModule
  from .convert_mixin import ConvertMixin, ConvertWithShapeMixin
label_desc: Use image node_id 10 for calling the TestConvert obj's underlying member method code with example usage: obj.test_resnet() and returns: nn, nn, out, nn, x