code: def small_nonqnn_to_recording_resnet(
      image,
      config,
      test=False,
      channel_last=False,
      bn_self_folding=False,
      record_layers=(),
      name="bn-graph-ref",
  ):
      recorder = config.recorder_activation
      recorder_weight = config.recorder_weight
      axes = get_channel_axes(image, channel_last)
  
      h = image
      func_id = 0
      with nn.parameter_scope("MulScale-{}".format(func_id)):
          if not record_layers:
              h = recorder()(h, axes=axes)
          h /= 255.0
          func_id += 1
      with nn.parameter_scope("first-conv"):
          h = recorder()(h, axes=axes)
          w, b = create_conv_weight_bias(
              h, 16, kernel=(3, 3), channel_last=channel_last, name=name
          )
          w = recorder_weight()(w, axes=axes, name="w")
          b = recorder_weight()(b, axes=axes, name="b")
          h = F.convolution(
              h,
              w,
              b,
              pad=(1, 1),
              stride=(1, 1),
              channel_last=channel_last,
          )
      if bn_self_folding:
          a, b = create_scale_bias(1, h.shape, axes=axes)
          with nn.parameter_scope("Mul2-{}".format(func_id)):
              if not record_layers:
                  h = recorder()(h, axes=axes)
                  h = recorder()(a, axes=axes) * h
              else:
                  h = a * h
              func_id += 1
          with nn.parameter_scope("Add2-{}".format(func_id)):
              if not record_layers:
                  h = recorder()(h, axes=axes)
                  h = h + recorder()(b, axes=axes)
              else:
                  h = h + b
              func_id += 1
  
      with nn.parameter_scope("ReLU-{}".format(func_id)):
          if not record_layers:
              h = recorder()(h, axes=axes)
          h = F.relu(h)
          func_id += 1
      with nn.parameter_scope("MaxPooling-{}".format(func_id)):
          if not record_layers:
              h = recorder()(h, axes=axes)
          h = F.max_pooling(h, (2, 2), channel_last=channel_last)
          func_id += 1
      h = nonqnn_to_recording_resblock(
          h,
          config,
          maps=16,
          test=test,
          channel_last=channel_last,
          bn_self_folding=bn_self_folding,
          record_layers=record_layers,
          name="cb1",
      )
      h = nonqnn_to_recording_resblock(
          h,
          config,
          maps=16,
          test=test,
          channel_last=channel_last,
          bn_self_folding=bn_self_folding,
          record_layers=record_layers,
          name="cb2",
      )
      h = nonqnn_to_recording_resblock(
          h,
          config,
          maps=16,
          test=test,
          channel_last=channel_last,
          bn_self_folding=bn_self_folding,
          record_layers=record_layers,
          name="cb3",
      )
      h = nonqnn_to_recording_resblock(
          h,
          config,
          maps=16,
          test=test,
          channel_last=channel_last,
          bn_self_folding=bn_self_folding,
          record_layers=record_layers,
          name="cb4",
      )
      with nn.parameter_scope("AveragePooling-16"):
          if not record_layers:
              h = recorder()(h, axes=axes)
          h = F.average_pooling(h, (2, 2), channel_last=channel_last)
      with nn.parameter_scope("fc"):
          h = recorder()(h, axes=axes)
          w, b = create_affine_weight_bias(h, 10, name=name)
          w = recorder_weight()(w, axes=axes, name="w")
          b = recorder_weight()(b, axes=axes, name="b")
          pred = F.affine(h, w, b)
          return pred
  
imports: from __future__ import absolute_import
  import nnabla
  import nnabla.functions
  import nnabla.parametric_functions
  from .helper import create_scale_bias, create_conv_weight_bias, create_affine_weight_bias, get_channel_axes
label_desc: Use image node_id 37 for calling a global function with example usage: small_nonqnn_to_recording_resnet(image, config, test, channel_last, bn__folding, record_layers, name) and returns: pred