code: def load_driftbif(
      n, length, m=2, classification=True, kappa_3=0.3, seed=False
  ):
      """
      Simulates n time-series with length time steps each for the m-dimensional velocity of a dissipative soliton
  
      classification=True:
      target 0 means tau<=1/0.3, Dissipative Soliton with Brownian motion (purely noise driven)
      target 1 means tau> 1/0.3, Dissipative Soliton with Active Brownian motion (intrinsiv velocity with overlaid noise)
  
      classification=False:
      target is bifurcation parameter tau
  
      :param n: number of samples
      :type n: int
      :param length: length of the time series
      :type length: int
      :param m: number of spatial dimensions (default m=2) the dissipative soliton is propagating in
      :type m: int
      :param classification: distinguish between classification (default True) and regression target
      :type classification: bool
      :param kappa_3: inverse bifurcation parameter (default 0.3)
      :type kappa_3: float
      :param seed: random seed (default False)
      :type seed: float
      :return: X, y. Time series container and target vector
      :rtype X: pandas.DataFrame
      :rtype y: pandas.DataFrame
      """
  
      # todo: add ratio of classes
  
      if m > 2:
          logging.warning(
              "You set the dimension parameter for the dissipative soliton to m={}, however it is only"
              "properly defined for m=1 or m=2.".format(m)
          )
  
      id = np.repeat(range(n), length * m)
      dimensions = list(np.repeat(range(m), length)) * n
  
      labels = list()
      values = list()
  
      ls_tau = sample_tau(n, kappa_3=kappa_3)
  
      for i, tau in enumerate(ls_tau):
          ds = velocity(tau=tau, kappa_3=kappa_3, seed=seed)
          if classification:
              labels.append(ds.label)
          else:
              labels.append(ds.tau)
          values.append(
              ds.simulate(length, v0=np.zeros(m)).transpose().flatten()
          )
      time = np.stack(
          [ds.delta_t * np.arange(length)] * n * m
      ).flatten()
  
      df = pd.DataFrame(
          {
              "id": id,
              "time": time,
              "value": np.stack(values).flatten(),
              "dimension": dimensions,
          }
      )
      y = pd.Series(labels)
      y.index = range(n)
  
      return df, y
  
file_path: tsfresh/tsfresh/examples/driftbif_simulation.py
imports: import logging
  import numpy
  import pandas
label_desc: Use image node_id 2 for calling a global function with example usage: load_driftbif(n, length, m, classification, kappa_3, seed) and returns: df,  y