class_docstr: Multi RandOm Convolutional KErnel Transform (MultiRocket).
  
  MultiRocket [1]_ is uses the same set of kernels as MiniRocket on both the raw
  series and the first order differenced series representation. It uses a different
  set of dilations and used for each representation. In addition to percentage of
  positive values (PPV) MultiRocket adds 3 pooling operators: Mean of Positive
  Values (MPV); Mean of Indices of Positive Values (MIPV); and Longest Stretch of
  Positive Values (LSPV). This version is the multivariate version.
  
  This transformer fits one set of paramereters per individual series,
  and applies the transform with fitted parameter i to the i-th series in transform.
  Vanilla use requires same number of series in fit and transform.
  
  To fit and transform series at the same time,
  without an identification of fit/transform instances,
  wrap this transformer in ``FitInTransform``,
  from ``sktime.transformations.compose``.
  
  Parameters
  ----------
  num_kernels : int, default=6,250
     number of random convolutional kernels. The calculated number of features is the
     nearest multiple of n_features_per_kernel(default 4)*84=336 < 50,000
     (2*n_features_per_kernel(default 4)*num_kernels(default 6,250)).
  max_dilations_per_kernel : int, default=32
      maximum number of dilations per kernel.
  n_features_per_kernel : int, default =4
      number of features per kernel.
  normalise : bool, default False
  n_jobs : int, default=1
      The number of jobs to run in parallel for `transform`. ``-1`` means using all
      processors.
  random_state : None or int, default = None
  
  Attributes
  ----------
  parameter : tuple
      parameter (dilations, num_features_per_dilation, biases) for
      transformation of input X
  parameter1 : tuple
      parameter (dilations, num_features_per_dilation, biases) for
      transformation of input X1 = np.diff(X, 1)
  
  See Also
  --------
  MultiRocketMultivariate, MiniRocket, MiniRocketMultivariate, Rocket
  
  References
  ----------
  .. [1] Tan, Chang Wei and Dempster, Angus and Bergmeir, Christoph and
  Webb, Geoffrey I, "MultiRocket: Multiple pooling operators and transformations
  for fast and effective time series classification",2022,
  https://link.springer.com/article/10.1007/s10618-022-00844-1
  https://arxiv.org/abs/2102.00457
  
  Examples
  --------
   >>> from sktime.transformations.panel.rocket import Rocket
   >>> from sktime.datasets import load_basic_motions
   >>> X_train, y_train = load_basic_motions(split="train") # doctest: +SKIP
   >>> X_test, y_test = load_basic_motions(split="test") # doctest: +SKIP
   >>> trf = MultiRocketMultivariate(num_kernels=512) # doctest: +SKIP
   >>> trf.fit(X_train) # doctest: +SKIP
   MultiRocketMultivariate(...)
   >>> X_train = trf.transform(X_train) # doctest: +SKIP
   >>> X_test = trf.transform(X_test) # doctest: +SKIP
code: def _get_parameter(self, X):
      from sktime.transformations.panel.rocket._multirocket_multi_numba import (
          _fit_biases,
          _fit_dilations,
          _quantiles,
      )
  
      if self.random_state is not None:
          np.random.seed(self.random_state)
  
      _, num_channels, input_length = X.shape
  
      num_kernels = 84
  
      dilations, num_features_per_dilation = _fit_dilations(
          input_length, self.num_kernels, self.max_dilations_per_kernel
      )
  
      num_features_per_kernel = np.sum(num_features_per_dilation)
  
      quantiles = _quantiles(num_kernels * num_features_per_kernel)
  
      num_dilations = len(dilations)
      num_combinations = num_kernels * num_dilations
  
      max_num_channels = min(num_channels, 9)
      max_exponent = np.log2(max_num_channels + 1)
  
      num_channels_per_combination = (
          2 ** np.random.uniform(0, max_exponent, num_combinations)
      ).astype(np.int32)
  
      channel_indices = np.zeros(
          num_channels_per_combination.sum(), dtype=np.int32
      )
  
      num_channels_start = 0
      for combination_index in range(num_combinations):
          num_channels_this_combination = num_channels_per_combination[
              combination_index
          ]
          num_channels_end = (
              num_channels_start + num_channels_this_combination
          )
          channel_indices[
              num_channels_start:num_channels_end
          ] = np.random.choice(
              num_channels, num_channels_this_combination, replace=False
          )
  
          num_channels_start = num_channels_end
  
      biases = _fit_biases(
          X,
          num_channels_per_combination,
          channel_indices,
          dilations,
          num_features_per_dilation,
          quantiles,
          self.random_state,
      )
  
      return (
          num_channels_per_combination,
          channel_indices,
          dilations,
          num_features_per_dilation,
          biases,
      )
  
file_path: sktime/sktime/transformations/panel/rocket/_multirocket_multivariate.py
imports: import multiprocessing
  import numpy
  import pandas
  from sktime.transformations.base import BaseTransformer
label_desc: Use image node_id 4 for calling the MultiRocketMultivariate obj's underlying member method code with example usage: obj._get_parameter(X) and returns: num_channels_per_combination,  channel_indices,  dilations,  num_features_per_dilation,  biases