class_docstr: Ridge regression of data with time delays.
  
  Parameters
  ----------
  tmin : int | float
      The starting lag, in seconds (or samples if ``sfreq`` == 1).
      Negative values correspond to times in the past.
  tmax : int | float
      The ending lag, in seconds (or samples if ``sfreq`` == 1).
      Positive values correspond to times in the future.
      Must be >= tmin.
  sfreq : float
      The sampling frequency used to convert times into samples.
  alpha : float
      The ridge (or laplacian) regularization factor.
  reg_type : str | list
      Can be ``"ridge"`` (default) or ``"laplacian"``.
      Can also be a 2-element list specifying how to regularize in time
      and across adjacent features.
  fit_intercept : bool
      If True (default), the sample mean is removed before fitting.
  n_jobs : int | str
      The number of jobs to use. Can be an int (default 1) or ``'cuda'``.
  
      .. versionadded:: 0.18
  edge_correction : bool
      If True (default), correct the autocorrelation coefficients for
      non-zero delays for the fact that fewer samples are available.
      Disabling this speeds up performance at the cost of accuracy
      depending on the relationship between epoch length and model
      duration. Only used if ``estimator`` is float or None.
  
      .. versionadded:: 0.18
  
  See Also
  --------
  mne.decoding.ReceptiveField
  
  Notes
  -----
  This class is meant to be used with :class:`mne.decoding.ReceptiveField`
  by only implicitly doing the time delaying. For reasonable receptive
  field and input signal sizes, it should be more CPU and memory
  efficient by using frequency-domain methods (FFTs) to compute the
  auto- and cross-correlations.
code: def __init__(
      self,
      tmin,
      tmax,
      sfreq,
      alpha=0.0,
      reg_type="ridge",
      fit_intercept=True,
      n_jobs=None,
      edge_correction=True,
  ):
      if tmin > tmax:
          raise ValueError(
              f"tmin must be <= tmax, got {tmin} and {tmax}"
          )
      self.tmin = float(tmin)
      self.tmax = float(tmax)
      self.sfreq = float(sfreq)
      self.alpha = float(alpha)
      self.reg_type = reg_type
      self.fit_intercept = fit_intercept
      self.edge_correction = edge_correction
      self.n_jobs = n_jobs
  
imports: import numpy
  from scipy import linalg
  from scipy.signal import fftconvolve
  from scipy.sparse.csgraph import laplacian
  from ..cuda import _setup_cuda_fft_multiply_repeated
  from ..filter import next_fast_len
  from ..fixes import jit
  from ..utils import ProgressBar, _check_option, _validate_type, logger, warn
  from .base import BaseEstimator
label_desc: Use image node_id 1 to create a new TimeDelayingRidge object from inherited base classes: BaseEstimator with example: obj = TimeDelayingRidge(tmin, tmax, sfreq, alpha, reg_type, fit_intercept, n_jobs, edge_correction)