code: def generate_kernels(n_kernels, n_timestamps, kernel_sizes, seed):
      """Generate the kernels.
  
      Parameters
      ----------
      n_kernels : int
          Number of kernels
  
      n_timestamps : int
          Number of timestamps
  
      kernel_sizes : array
          Possible sizes for the kernels.
  
      seed : int
          Seed for the random number generator.
  
      Returns
      -------
      weights : array, shape = (n_kernels, max(kernel_sizes))
          Weights of the kernels. Zero padding values are added.
  
      lengths : array, shape = (n_kernels,)
          Length of each kernel.
  
      biases : array, shape = (n_kernels,)
          Bias of each kernel.
  
      dilations : array, shape = (n_kernels,)
          Dilation of each kernel.
  
      paddings : array, shape = (n_kernels,)
          Padding of each kernel.
  
      """
      # Fix the random see
      np.random.seed(seed)
  
      # Lengths of the kernels
      lengths = np.random.choice(kernel_sizes, size=n_kernels)
  
      # Weights of the kernels
      cumsum_lengths = np.concatenate(
          (np.array([0]), np.cumsum(lengths))
      )
      weights_all = np.random.randn(cumsum_lengths[-1])
      weights = np.zeros((n_kernels, np.int64(np.max(kernel_sizes))))
      for i in prange(n_kernels):
          weights[i, : lengths[i]] = weights_all[
              cumsum_lengths[i] : cumsum_lengths[i + 1]
          ] - np.mean(
              weights_all[cumsum_lengths[i] : cumsum_lengths[i + 1]]
          )
  
      # Biases
      biases = np.random.uniform(-1, 1, size=n_kernels)
  
      # Dilations
      upper_bounds = np.log2(
          np.floor_divide(n_timestamps - 1, lengths - 1)
      )
      powers = np.empty(n_kernels)
      for i in prange(n_kernels):
          powers[i] = np.random.uniform(0, upper_bounds[i])
      dilations = np.floor(np.power(2, powers))
  
      # Paddings
      paddings = np.zeros(n_kernels)
      padding_cond = np.random.randint(0, 2, n_kernels).astype(np.bool_)
      paddings[padding_cond] = np.floor_divide(
          (lengths - 1) * dilations, 2
      )[padding_cond]
  
      return weights, lengths, biases, dilations, paddings
  
file_path: pyts/pyts/transformation/rocket.py
imports: from numba import njit, prange
  import numpy
  from sklearn.base import BaseEstimator
  from sklearn.utils.validation import check_array, check_is_fitted, check_random_state
  from ..base import UnivariateTransformerMixin
label_desc: Use image node_id 1 for calling a global function with example usage: generate_kernels(n_kernels, n_timestamps, kernel_sizes, seed) and returns: weights,  lengths,  biases,  dilations,  paddings