class_docstr: interp_type can be 'nearest'/'bilinear'/'bilinear_like'
class_docstr_tok: ["interp_type","can","be","'nearest'\/'bilinear'\/'bilinear_like","'"]
code: def _make_fuse_layers(self, norm_layer=BatchNorm, norm_kwargs=None):
      if self.num_branches == 1:
          return None
  
      num_branches = self.num_branches
      num_inchannels = self.num_inchannels
      fuse_layers = nn.HybridSequential()
      for i in range(num_branches if self.multi_scale_output else 1):
          fuse_layer = nn.HybridSequential()
          for j in range(num_branches):
              if j > i:
                  seq = nn.HybridSequential()
  
                  seq.add(
                      nn.Conv2D(
                          num_inchannels[i], 1, 1, 0, use_bias=False
                      ),
                      norm_layer(
                          **({} if norm_kwargs is None else norm_kwargs)
                      ),
                  )
                  fuse_layer.add(seq)
              elif j == i:
                  fuse_layer.add(contrib.nn.Identity())
              else:
                  conv3x3s = nn.HybridSequential()
                  for k in range(i - j):
                      if k == i - j - 1:
                          num_outchannels_conv3x3 = num_inchannels[i]
                          conv3x3s.add(
                              nn.Conv2D(
                                  num_outchannels_conv3x3,
                                  3,
                                  2,
                                  1,
                                  use_bias=False,
                              ),
                              norm_layer(
                                  **(
                                      {}
                                      if norm_kwargs is None
                                      else norm_kwargs
                                  )
                              ),
                          )
                      else:
                          num_outchannels_conv3x3 = num_inchannels[j]
                          conv3x3s.add(
                              nn.Conv2D(
                                  num_outchannels_conv3x3,
                                  3,
                                  2,
                                  1,
                                  use_bias=False,
                              ),
                              norm_layer(
                                  **(
                                      {}
                                      if norm_kwargs is None
                                      else norm_kwargs
                                  )
                              ),
                              nn.Activation("relu"),
                          )
                  fuse_layer.add(conv3x3s)
          fuse_layers.add(fuse_layer)
  
      return fuse_layers
  
imports: import numpy
  from mxnet.gluon import contrib
  from mxnet.gluon import nn
  from mxnet.gluon.nn import BatchNorm
  from mxnet.context import cpu
  from .resnet import BasicBlockV1, BottleneckV1, _conv3x3
label_desc: Use image node_id 4 for calling the HighResolutionModule obj's underlying member method code with example usage: obj._make_fuse_layers(norm_layer, norm_kwargs) and returns: fuse_layers, None