code: def __init__(self, version="1_0", num_classes=1000):
      super(SqueezeNet, self).__init__()
      self.num_classes = num_classes
      if version == "1_0":
          self.features = nn.Sequential(
              nn.Conv2d(3, 96, kernel_size=7, stride=2),
              nn.ReLU(inplace=True),
              nn.MaxPool2d(kernel_size=3, stride=2, ceil_mode=True),
              Fire(96, 16, 64, 64),
              Fire(128, 16, 64, 64),
              Fire(128, 32, 128, 128),
              nn.MaxPool2d(kernel_size=3, stride=2, ceil_mode=True),
              Fire(256, 32, 128, 128),
              Fire(256, 48, 192, 192),
              Fire(384, 48, 192, 192),
              Fire(384, 64, 256, 256),
              nn.MaxPool2d(kernel_size=3, stride=2, ceil_mode=True),
              Fire(512, 64, 256, 256),
          )
      elif version == "1_1":
          self.features = nn.Sequential(
              nn.Conv2d(3, 64, kernel_size=3, stride=2),
              nn.ReLU(inplace=True),
              nn.MaxPool2d(kernel_size=3, stride=2, ceil_mode=True),
              Fire(64, 16, 64, 64),
              Fire(128, 16, 64, 64),
              nn.MaxPool2d(kernel_size=3, stride=2, ceil_mode=True),
              Fire(128, 32, 128, 128),
              Fire(256, 32, 128, 128),
              nn.MaxPool2d(kernel_size=3, stride=2, ceil_mode=True),
              Fire(256, 48, 192, 192),
              Fire(384, 48, 192, 192),
              Fire(384, 64, 256, 256),
              Fire(512, 64, 256, 256),
          )
      else:
          raise ValueError(
              "Unsupported SqueezeNet version {version}:"
              "1_0 or 1_1 expected".format(version=version)
          )
  
      # Final convolution is initialized differently from the rest
      final_conv = nn.Conv2d(512, self.num_classes, kernel_size=1)
      self.classifier = nn.Sequential(
          nn.Dropout(p=0.5),
          final_conv,
          nn.ReLU(inplace=True),
          nn.AdaptiveAvgPool2d((1, 1)),
      )
      self.last_relu = nn.ReLU(inplace=True)
      self.last_relu_fake = FakeReLUM()
  
      for m in self.modules():
          if isinstance(m, nn.Conv2d):
              if m is final_conv:
                  init.normal_(m.weight, mean=0.0, std=0.01)
              else:
                  init.kaiming_uniform_(m.weight)
              if m.bias is not None:
                  init.constant_(m.bias, 0)
  
file_path: robustness/robustness/imagenet_models/squeezenet.py
imports: import torch
  import torch.nn
  import torch.nn.init
  from torch.hub import load_state_dict_from_url
  from ..tools.custom_modules import FakeReLUM
label_desc: Use image node_id 1 to create a new SqueezeNet object from inherited base classes: nn with example: obj = SqueezeNet(version, num_classes)