class_docstr: Base class for classification and segmentation
      
class_docstr_tok: ["Base","class","for","classification","and","segmentation"]
code: def _make_transition_layer(
      self,
      num_channels_pre_layer,
      num_channels_cur_layer,
      norm_layer=BatchNorm,
      norm_kwargs=None,
  ):
      num_branches_cur = len(num_channels_cur_layer)
      num_branches_pre = len(num_channels_pre_layer)
  
      transition_layers = nn.HybridSequential()
  
      for i in range(num_branches_cur):
          if i < num_branches_pre:
              if num_channels_cur_layer[i] != num_channels_pre_layer[i]:
                  transition_layer = nn.HybridSequential()
                  transition_layer.add(
                      nn.Conv2D(
                          num_channels_cur_layer[i],
                          3,
                          1,
                          1,
                          use_bias=False,
                          in_channels=num_channels_pre_layer[i],
                      ),
                      norm_layer(
                          **({} if norm_kwargs is None else norm_kwargs)
                      ),
                      nn.Activation("relu"),
                  )
                  transition_layers.add(transition_layer)
              else:
                  transition_layers.add(contrib.nn.Identity())
          else:
              conv3x3s = nn.HybridSequential()
              for j in range(i + 1 - num_branches_pre):
                  inchannels = num_channels_pre_layer[-1]
                  outchannels = (
                      num_channels_cur_layer[i]
                      if j == i - num_branches_pre
                      else inchannels
                  )
                  cba = nn.HybridSequential()
                  cba.add(
                      nn.Conv2D(
                          outchannels,
                          3,
                          2,
                          1,
                          use_bias=False,
                          in_channels=inchannels,
                      ),
                      norm_layer(
                          **({} if norm_kwargs is None else norm_kwargs)
                      ),
                      nn.Activation("relu"),
                  )
                  conv3x3s.add(cba)
              transition_layers.add(conv3x3s)
  
      return transition_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 2 for calling the HighResolutionBaseNet obj's underlying member method code with example usage: obj._make_transition_layer(num_channels_pre_layer, num_channels_cur_layer, norm_layer, norm_kwargs) and returns: transition_layers