code: def get_squeezenext(
      version,
      width_scale,
      model_name=None,
      pretrained=False,
      root=os.path.join("~", ".torch", "models"),
      **kwargs,
  ):
      """
      Create SqueezeNext model with specific parameters.
  
      Parameters:
      ----------
      version : str
          Version of SqueezeNet ('23' or '23v5').
      width_scale : float
          Scale factor for width of layers.
      model_name : str or None, default None
          Model name for loading pretrained model.
      pretrained : bool, default False
          Whether to load the pretrained weights for model.
      ctx : Context, default CPU
          The context in which to load the pretrained weights.
      root : str, default '~/.torch/models'
          Location for keeping the model parameters.
      """
  
      init_block_channels = 64
      final_block_channels = 128
      channels_per_layers = [32, 64, 128, 256]
  
      if version == "23":
          layers = [6, 6, 8, 1]
      elif version == "23v5":
          layers = [2, 4, 14, 1]
      else:
          raise ValueError(
              "Unsupported SqueezeNet version {}".format(version)
          )
  
      channels = [
          [ci] * li for (ci, li) in zip(channels_per_layers, layers)
      ]
  
      if width_scale != 1:
          channels = [
              [int(cij * width_scale) for cij in ci] for ci in channels
          ]
          init_block_channels = int(init_block_channels * width_scale)
          final_block_channels = int(final_block_channels * width_scale)
  
      net = SqueezeNext(
          channels=channels,
          init_block_channels=init_block_channels,
          final_block_channels=final_block_channels,
          **kwargs,
      )
  
      if pretrained:
          if (model_name is None) or (not model_name):
              raise ValueError(
                  "Parameter `model_name` should be properly initialized for loading pretrained model."
              )
          import torch
          from .model_store import get_model_file
  
          net.load_state_dict(
              torch.load(
                  get_model_file(
                      model_name=model_name,
                      local_model_store_dir_path=root,
                  )
              )
          )
  
      return net
  
imports: import numpy
  import torch
  from torch.autograd import Variable
  from pytorch2keras.converter import pytorch_to_keras
  import os
  import torch.nn
  import torch.nn.init
label_desc: Use image node_id 1 for calling a global function with example usage: get_squeezenext(version, width_scale, model_name, pretrained, root) and returns: net