code: def _fit_biases_multi_var(
      X,
      L,
      num_channels_per_combination,
      channel_indices,
      dilations,
      num_features_per_dilation,
      quantiles,
      seed,
  ):
      if seed is not None:
          np.random.seed(seed)
      n_instances = len(L)
  
      num_channels, _ = X.shape
  
      # equivalent to:
      # >>> from itertools import combinations
      # >>> indices = np.array(
      # >>>    [_ for _ in combinations(np.arange(9), 3)], dtype = np.int32
      # >>> )
      indices = np.array(
          (
              0,
              1,
              2,
              0,
              1,
              3,
              0,
              1,
              4,
              0,
              1,
              5,
              0,
              1,
              6,
              0,
              1,
              7,
              0,
              1,
              8,
              0,
              2,
              3,
              0,
              2,
              4,
              0,
              2,
              5,
              0,
              2,
              6,
              0,
              2,
              7,
              0,
              2,
              8,
              0,
              3,
              4,
              0,
              3,
              5,
              0,
              3,
              6,
              0,
              3,
              7,
              0,
              3,
              8,
              0,
              4,
              5,
              0,
              4,
              6,
              0,
              4,
              7,
              0,
              4,
              8,
              0,
              5,
              6,
              0,
              5,
              7,
              0,
              5,
              8,
              0,
              6,
              7,
              0,
              6,
              8,
              0,
              7,
              8,
              1,
              2,
              3,
              1,
              2,
              4,
              1,
              2,
              5,
              1,
              2,
              6,
              1,
              2,
              7,
              1,
              2,
              8,
              1,
              3,
              4,
              1,
              3,
              5,
              1,
              3,
              6,
              1,
              3,
              7,
              1,
              3,
              8,
              1,
              4,
              5,
              1,
              4,
              6,
              1,
              4,
              7,
              1,
              4,
              8,
              1,
              5,
              6,
              1,
              5,
              7,
              1,
              5,
              8,
              1,
              6,
              7,
              1,
              6,
              8,
              1,
              7,
              8,
              2,
              3,
              4,
              2,
              3,
              5,
              2,
              3,
              6,
              2,
              3,
              7,
              2,
              3,
              8,
              2,
              4,
              5,
              2,
              4,
              6,
              2,
              4,
              7,
              2,
              4,
              8,
              2,
              5,
              6,
              2,
              5,
              7,
              2,
              5,
              8,
              2,
              6,
              7,
              2,
              6,
              8,
              2,
              7,
              8,
              3,
              4,
              5,
              3,
              4,
              6,
              3,
              4,
              7,
              3,
              4,
              8,
              3,
              5,
              6,
              3,
              5,
              7,
              3,
              5,
              8,
              3,
              6,
              7,
              3,
              6,
              8,
              3,
              7,
              8,
              4,
              5,
              6,
              4,
              5,
              7,
              4,
              5,
              8,
              4,
              6,
              7,
              4,
              6,
              8,
              4,
              7,
              8,
              5,
              6,
              7,
              5,
              6,
              8,
              5,
              7,
              8,
              6,
              7,
              8,
          ),
          dtype=np.int32,
      ).reshape(84, 3)
  
      num_kernels = len(indices)
      num_dilations = len(dilations)
  
      num_features = num_kernels * np.sum(num_features_per_dilation)
  
      biases = np.zeros(num_features, dtype=np.float32)
  
      feature_index_start = 0
  
      combination_index = 0
      num_channels_start = 0
  
      for dilation_index in range(num_dilations):
          dilation = dilations[dilation_index]
          padding = ((9 - 1) * dilation) // 2
  
          num_features_this_dilation = num_features_per_dilation[
              dilation_index
          ]
  
          for kernel_index in range(num_kernels):
              feature_index_end = (
                  feature_index_start + num_features_this_dilation
              )
  
              num_channels_this_combination = (
                  num_channels_per_combination[combination_index]
              )
  
              num_channels_end = (
                  num_channels_start + num_channels_this_combination
              )
  
              channels_this_combination = channel_indices[
                  num_channels_start:num_channels_end
              ]
  
              example_index = np.random.randint(n_instances)
  
              input_length = np.int64(L[example_index])
  
              b = np.sum(L[0 : example_index + 1])
              a = b - input_length
  
              _X = X[channels_this_combination, a:b]
  
              A = -_X  # A = alpha * X = -X
              G = _X + _X + _X  # G = gamma * X = 3X
  
              C_alpha = np.zeros(
                  (num_channels_this_combination, input_length),
                  dtype=np.float32,
              )
              C_alpha[:] = A
  
              C_gamma = np.zeros(
                  (9, num_channels_this_combination, input_length),
                  dtype=np.float32,
              )
              C_gamma[9 // 2] = G
  
              start = dilation
              end = input_length - padding
  
              for gamma_index in range(9 // 2):
                  # thanks to Murtaza Jafferji @murtazajafferji for suggesting this fix
                  if end > 0:
                      C_alpha[:, -end:] = C_alpha[:, -end:] + A[:, :end]
                      C_gamma[gamma_index, :, -end:] = G[:, :end]
  
                  end += dilation
  
              for gamma_index in range(9 // 2 + 1, 9):
                  if start < input_length:
                      C_alpha[:, :-start] = (
                          C_alpha[:, :-start] + A[:, start:]
                      )
                      C_gamma[gamma_index, :, :-start] = G[:, start:]
  
                  start += dilation
  
              index_0, index_1, index_2 = indices[kernel_index]
  
              C = (
                  C_alpha
                  + C_gamma[index_0]
                  + C_gamma[index_1]
                  + C_gamma[index_2]
              )
              C = np.sum(C, axis=0)
  
              biases[
                  feature_index_start:feature_index_end
              ] = np.quantile(
                  C, quantiles[feature_index_start:feature_index_end]
              )
  
              feature_index_start = feature_index_end
  
              combination_index += 1
              num_channels_start = num_channels_end
  
      return biases
  
imports: import numpy
  from sktime.utils.numba.njit import njit
  from sktime.utils.validation._dependencies import _check_soft_dependencies
label_desc: Use image node_id 1 for calling a global function with example usage: _fit_biases_multi_var(X, L, num_channels_per_combination, channel_indices, dilations, num_features_per_dilation, quantiles, seed) and returns: biases