code: def linear_regression_raw(
      raw,
      events,
      event_id=None,
      tmin=-0.1,
      tmax=1,
      covariates=None,
      reject=None,
      flat=None,
      tstep=1.0,
      decim=1,
      picks=None,
      solver="cholesky",
  ):
      """Estimate regression-based evoked potentials/fields by linear modeling.
  
      This models the full M/EEG time course, including correction for
      overlapping potentials and allowing for continuous/scalar predictors.
      Internally, this constructs a predictor matrix X of size
      n_samples * (n_conds * window length), solving the linear system
      ``Y = bX`` and returning ``b`` as evoked-like time series split by
      condition. See :footcite:`SmithKutas2015`.
  
      Parameters
      ----------
      raw : instance of Raw
          A raw object. Note: be very careful about data that is not
          downsampled, as the resulting matrices can be enormous and easily
          overload your computer. Typically, 100 Hz sampling rate is
          appropriate - or using the decim keyword (see below).
      events : ndarray of int, shape (n_events, 3)
          An array where the first column corresponds to samples in raw
          and the last to integer codes in event_id.
      event_id : dict | None
          As in Epochs; a dictionary where the values may be integers or
          iterables of integers, corresponding to the 3rd column of
          events, and the keys are condition names.
          If None, uses all events in the events array.
      tmin : float | dict
          If float, gives the lower limit (in seconds) for the time window for
          which all event types' effects are estimated. If a dict, can be used to
          specify time windows for specific event types: keys correspond to keys
          in event_id and/or covariates; for missing values, the default (-.1) is
          used.
      tmax : float | dict
          If float, gives the upper limit (in seconds) for the time window for
          which all event types' effects are estimated. If a dict, can be used to
          specify time windows for specific event types: keys correspond to keys
          in event_id and/or covariates; for missing values, the default (1.) is
          used.
      covariates : dict-like | None
          If dict-like (e.g., a pandas DataFrame), values have to be array-like
          and of the same length as the rows in ``events``. Keys correspond
          to additional event types/conditions to be estimated and are matched
          with the time points given by the first column of ``events``. If
          None, only binary events (from event_id) are used.
      reject : None | dict
          For cleaning raw data before the regression is performed: set up
          rejection parameters based on peak-to-peak amplitude in continuously
          selected subepochs. If None, no rejection is done.
          If dict, keys are types ('grad' | 'mag' | 'eeg' | 'eog' | 'ecg')
          and values are the maximal peak-to-peak values to select rejected
          epochs, e.g.::
  
              reject = dict(grad=4000e-12, # T / m (gradiometers)
                            mag=4e-11, # T (magnetometers)
                            eeg=40e-5, # V (EEG channels)
                            eog=250e-5 # V (EOG channels))
  
      flat : None | dict
          For cleaning raw data before the regression is performed: set up
          rejection parameters based on flatness of the signal. If None, no
          rejection is done. If a dict, keys are ('grad' | 'mag' |
          'eeg' | 'eog' | 'ecg') and values are minimal peak-to-peak values to
          select rejected epochs.
      tstep : float
          Length of windows for peak-to-peak detection for raw data cleaning.
      decim : int
          Decimate by choosing only a subsample of data points. Highly
          recommended for data recorded at high sampling frequencies, as
          otherwise huge intermediate matrices have to be created and inverted.
      %(picks_good_data)s
      solver : str | callable
          Either a function which takes as its inputs the sparse predictor
          matrix X and the observation matrix Y, and returns the coefficient
          matrix b; or a string.
          X is of shape (n_times, n_predictors * time_window_length).
          y is of shape (n_channels, n_times).
          If str, must be ``'cholesky'``, in which case the solver used is
          ``linalg.solve(dot(X.T, X), dot(X.T, y))``.
  
      Returns
      -------
      evokeds : dict
          A dict where the keys correspond to conditions and the values are
          Evoked objects with the ER[F/P]s. These can be used exactly like any
          other Evoked object, including e.g. plotting or statistics.
  
      References
      ----------
      .. footbibliography::
      """
      if isinstance(solver, str):
          if solver not in {"cholesky"}:
              raise ValueError(f"No such solver: {solver}")
          if solver == "cholesky":
  
              def solver(X, y):
                  a = (
                      X.T * X
                  ).toarray()  # dot product of sparse matrices
                  return linalg.solve(
                      a,
                      X.T * y,
                      assume_a="pos",
                      overwrite_a=True,
                      overwrite_b=True,
                  ).T
  
      elif callable(solver):
          pass
      else:
          raise TypeError("The solver must be a str or a callable.")
  
      # build data
      data, info, events = _prepare_rerp_data(
          raw, events, picks=picks, decim=decim
      )
  
      if event_id is None:
          event_id = {str(v): v for v in set(events[:, 2])}
  
      # build predictors
      X, conds, cond_length, tmin_s, tmax_s = _prepare_rerp_preds(
          n_samples=data.shape[1],
          sfreq=info["sfreq"],
          events=events,
          event_id=event_id,
          tmin=tmin,
          tmax=tmax,
          covariates=covariates,
      )
  
      # remove "empty" and contaminated data points
      X, data = _clean_rerp_input(
          X, data, reject, flat, decim, info, tstep
      )
  
      # solve linear system
      coefs = solver(X, data.T)
      if coefs.shape[0] != data.shape[0]:
          raise ValueError(
              "solver output has unexcepted shape. Supply a "
              "function that returns coefficients in the form "
              "(n_targets, n_features), where targets == channels."
          )
  
      # construct Evoked objects to be returned from output
      evokeds = _make_evokeds(
          coefs, conds, cond_length, tmin_s, tmax_s, info
      )
  
      return evokeds
  
file_path: mne-python/mne/stats/regression.py
imports: from collections import namedtuple
  from inspect import isgenerator
  import numpy
  from scipy import linalg, sparse, stats
  from .._fiff.pick import _picks_to_idx, pick_info, pick_types
  from ..epochs import BaseEpochs
  from ..evoked import Evoked, EvokedArray
  from ..source_estimate import SourceEstimate
  from ..utils import _reject_data_segments, fill_doc, logger, warn
label_desc: Use image node_id 3 for calling a global function with example usage: linear_regression_raw(raw, events, event_id, tmin, tmax, covariates, reject, flat, tstep, decim, picks, solver) and returns: evokeds, linalg