code: def __init__(
      self,
      in_index=[0, 1, 2, 3],
      in_channels=[256, 256, 256, 256],
      channels=128,
      feature_strides=[4, 8, 16, 32],
      dropout_ratio=0.1,
      num_classes=150,
      align_corners=False,
  ):
      super().__init__()
  
      self.in_channels = in_channels
  
      assert len(feature_strides) == len(self.in_channels)
      assert min(feature_strides) == feature_strides[0]
  
      self.in_index = in_index
  
      self.channels = channels
      self.feature_strides = feature_strides
      self.align_corners = align_corners
      self.dropout_ratio = dropout_ratio
      self.num_classes = num_classes
      if self.dropout_ratio > 0:
          self.dropout = nn.Dropout2D(self.dropout_ratio)
  
      self.scale_heads = nn.LayerList()
      for i in range(len(feature_strides)):
          head_length = max(
              1,
              int(
                  np.log2(feature_strides[i])
                  - np.log2(feature_strides[0])
              ),
          )
          scale_head = []
          for k in range(head_length):
              scale_head.append(
                  nn.Sequential(
                      nn.Conv2D(
                          self.in_channels[i]
                          if k == 0
                          else self.channels,
                          self.channels,
                          3,
                          padding=1,
                          bias_attr=False,
                      ),
                      nn.BatchNorm2D(self.channels),
                      nn.ReLU(),
                  )
              )
  
              if feature_strides[i] != feature_strides[0]:
                  scale_head.append(
                      nn.Upsample(
                          scale_factor=2,
                          mode="bilinear",
                          align_corners=self.align_corners,
                      )
                  )
  
          self.scale_heads.append(nn.Sequential(*scale_head))
      self.cls_seg = nn.Conv2D(
          self.channels, self.num_classes, kernel_size=1
      )
      self.init_weight()
  
imports: import numpy
  import paddle.nn
  import paddle.nn.functional
  from paddleseg.cvlibs import manager, param_init
  from paddleseg.utils import utils
label_desc: Use image node_id 1 to create a new EfficientFormerFPN object from inherited base classes: nn with example: obj = EfficientFormerFPN(in_index, in_channels, channels, feature_strides, dropout_ratio, num_classes, align_corners)