code: def __init__(
      self,
      number=0,
      classes=1000,
      has_se=True,
      track_running_stats=True,
      input_channels=3,
      has_fc_output=True,
  ):
      self.number = number
      global_params = [
          # width, depth
          (1.0, 1.0),  # b0
          (1.0, 1.1),  # b1
          (1.1, 1.2),  # b2
          (1.2, 1.4),  # b3
          (1.4, 1.8),  # b4
          (1.6, 2.2),  # b5
          (1.8, 2.6),  # b6
          (2.0, 3.1),  # b7
          (2.2, 3.6),  # b8
          (4.3, 5.3),  # l2
      ][max(number, 0)]
  
      def round_filters(filters):
          multiplier = global_params[0]
          divisor = 8
          filters *= multiplier
          new_filters = max(
              divisor, int(filters + divisor / 2) // divisor * divisor
          )
          if (
              new_filters < 0.9 * filters
          ):  # prevent rounding by more than 10%
              new_filters += divisor
          return int(new_filters)
  
      def round_repeats(repeats):
          return int(math.ceil(global_params[1] * repeats))
  
      out_channels = round_filters(32)
      self._conv_stem = Tensor.glorot_uniform(
          out_channels, input_channels, 3, 3
      )
      self._bn0 = BatchNorm2d(
          out_channels, track_running_stats=track_running_stats
      )
      blocks_args = [
          [1, 3, (1, 1), 1, 32, 16, 0.25],
          [2, 3, (2, 2), 6, 16, 24, 0.25],
          [2, 5, (2, 2), 6, 24, 40, 0.25],
          [3, 3, (2, 2), 6, 40, 80, 0.25],
          [3, 5, (1, 1), 6, 80, 112, 0.25],
          [4, 5, (2, 2), 6, 112, 192, 0.25],
          [1, 3, (1, 1), 6, 192, 320, 0.25],
      ]
  
      if self.number == -1:
          blocks_args = [
              [1, 3, (2, 2), 1, 32, 40, 0.25],
              [1, 3, (2, 2), 1, 40, 80, 0.25],
              [1, 3, (2, 2), 1, 80, 192, 0.25],
              [1, 3, (2, 2), 1, 192, 320, 0.25],
          ]
      elif self.number == -2:
          blocks_args = [
              [1, 9, (8, 8), 1, 32, 320, 0.25],
          ]
  
      self._blocks = []
      for (
          num_repeats,
          kernel_size,
          strides,
          expand_ratio,
          input_filters,
          output_filters,
          se_ratio,
      ) in blocks_args:
          input_filters, output_filters = round_filters(
              input_filters
          ), round_filters(output_filters)
          for n in range(round_repeats(num_repeats)):
              self._blocks.append(
                  MBConvBlock(
                      kernel_size,
                      strides,
                      expand_ratio,
                      input_filters,
                      output_filters,
                      se_ratio,
                      has_se=has_se,
                      track_running_stats=track_running_stats,
                  )
              )
              input_filters = output_filters
              strides = (1, 1)
  
      in_channels = round_filters(320)
      out_channels = round_filters(1280)
      self._conv_head = Tensor.glorot_uniform(
          out_channels, in_channels, 1, 1
      )
      self._bn1 = BatchNorm2d(
          out_channels, track_running_stats=track_running_stats
      )
      if has_fc_output:
          self._fc = Tensor.glorot_uniform(out_channels, classes)
          self._fc_bias = Tensor.zeros(classes)
      else:
          self._fc = None
  
file_path: tinygrad/extra/models/efficientnet.py
imports: import math
  from tinygrad.tensor import Tensor
  from tinygrad.nn import BatchNorm2d
  from tinygrad.helpers import get_child, fetch
  from tinygrad.nn.state import torch_load
label_desc: Use image node_id 1 to create a new EfficientNet object  with example: obj = EfficientNet(number, classes, has_se, track_running_stats, input_channels, has_fc_output)