code: def _make_fuse_layers(self):
      if self.num_branches == 1:
          return None
      num_branches = self.num_branches
      num_inchannels = self.num_inchannels
      fuse_layers = []
      for i in range(num_branches if self.multi_scale_output else 1):
          fuse_layer = []
          for j in range(num_branches):
              if j > i:
                  fuse_layer.append(
                      nn.Sequential(
                          layers.ConvBN(
                              num_inchannels[j],
                              num_inchannels[i],
                              kernel_size=1,
                              stride=1,
                              bias_attr=False,
                          ),
                          nn.Upsample(
                              scale_factor=2 ** (j - i), mode="nearest"
                          ),
                      )
                  )
              elif j == i:
                  fuse_layer.append(None)
              else:
                  conv3x3s = []
                  for k in range(i - j):
                      if k == i - j - 1:
                          num_outchannels_conv3x3 = num_inchannels[i]
                          conv3x3s.append(
                              nn.Sequential(
                                  layers.ConvBN(
                                      num_inchannels[j],
                                      num_inchannels[j],
                                      kernel_size=3,
                                      stride=2,
                                      padding=1,
                                      groups=num_inchannels[j],
                                      bias_attr=False,
                                  ),
                                  layers.ConvBN(
                                      num_inchannels[j],
                                      num_outchannels_conv3x3,
                                      kernel_size=1,
                                      stride=1,
                                      bias_attr=False,
                                  ),
                              )
                          )
                      else:
                          num_outchannels_conv3x3 = num_inchannels[j]
                          conv3x3s.append(
                              nn.Sequential(
                                  layers.ConvBN(
                                      num_inchannels[j],
                                      num_inchannels[j],
                                      kernel_size=3,
                                      stride=2,
                                      padding=1,
                                      groups=num_inchannels[j],
                                      bias_attr=False,
                                  ),
                                  layers.ConvBNReLU(
                                      num_inchannels[j],
                                      num_outchannels_conv3x3,
                                      kernel_size=1,
                                      stride=1,
                                      bias_attr=False,
                                  ),
                              )
                          )
                  fuse_layer.append(nn.Sequential(*conv3x3s))
          fuse_layers.append(nn.LayerList(fuse_layer))
  
      return nn.LayerList(fuse_layers)
  
imports: import paddle
  import paddle.nn
  import paddle.nn.functional
  from paddleseg.cvlibs import manager, param_init
  from paddleseg.models import layers
  from paddleseg.utils import utils, logger
  from paddleseg.models.backbones.transformer_utils import *
label_desc: Use image node_id 5 for calling the HighResolutionTransformerModule obj's underlying member method code with example usage: obj._make_fuse_layers() and returns: nn, None