class_docstr: Ridge extends LinearRegression by providing L2 regularization on the
  coefficients when predicting response y with a linear combination of the
  predictors in X. It can reduce the variance of the predictors, and improves
  the conditioning of the problem.
  
  cuML's dask Ridge (multi-node multi-gpu) expects dask cuDF
  DataFrame and provides an algorithms, Eig, to fit a linear model.
  And provides an eigendecomposition-based algorithm to fit a linear model.
  (SVD, which is more stable than eig, will be added in an upcoming version)
  Eig algorithm is usually preferred when the X is a tall and skinny matrix.
  As the number of features in X increases, the accuracy of Eig algorithm
  drops.
  
  This is an experimental implementation of dask Ridge Regression. It
  supports input X that has more than one column. Single column input
  X will be supported after SVD algorithm is added in an upcoming version.
  
  Parameters
  ----------
  alpha : float (default = 1.0)
      Regularization strength - must be a positive float. Larger values
      specify stronger regularization. Array input will be supported later.
  solver : {'eig'}
      Eig uses a eigendecomposition of the covariance matrix, and is much
      faster.
      Other solvers will be supported in the future.
  fit_intercept : boolean (default = True)
      If True, Ridge adds an additional term c to correct for the global
      mean of y, modeling the response as "x * beta + c".
      If False, the model expects that you have centered the data.
  normalize : boolean (default = False)
      If True, the predictors in X will be normalized by dividing by it's L2
      norm.
      If False, no scaling will be done.
  
  Attributes
  ----------
  coef_ : array, shape (n_features)
      The estimated coefficients for the linear regression model.
  intercept_ : array
      The independent term. If `fit_intercept` is False, will be 0.
docstr: Fit the model with X and y.
  
  Parameters
  ----------
  X : Dask cuDF dataframe  or CuPy backed Dask Array (n_rows, n_features)
      Features for regression
  y : Dask cuDF dataframe  or CuPy backed Dask Array (n_rows, 1)
      Labels (outcome values)
docstr_tok: ["Fit","the","model","with","X","and","y.","Parameters","--","--","--","--","--","X",":","Dask","cuDF","dataframe","or","CuPy","backed","Dask","Array","(","n_rows",",","n_features",")","Features","for","regression","y",":","Dask","cuDF","dataframe","or","CuPy","backed","Dask","Array","(","n_rows",",","1",")","Labels","(","outcome","values",")"]
code: def fit(self, X, y):
      """
      Fit the model with X and y.
  
      Parameters
      ----------
      X : Dask cuDF dataframe  or CuPy backed Dask Array (n_rows, n_features)
          Features for regression
      y : Dask cuDF dataframe  or CuPy backed Dask Array (n_rows, 1)
          Labels (outcome values)
      """
  
      models = self._fit(model_func=Ridge._create_model, data=(X, y))
  
      self._set_internal_model(models[0])
  
      return self
  
file_path: cuml/python/cuml/dask/linear_model/ridge.py
imports: from cuml.dask.common.base import BaseEstimator
  from cuml.dask.common.base import DelayedPredictionMixin
  from cuml.dask.common.base import mnmg_import
  from cuml.dask.common.base import SyncFitMixinLinearModel
  from raft_dask.common.comms import get_raft_comm_state
  from dask.distributed import get_worker
label_desc: Use image node_id 2 for calling the Ridge obj's underlying member method code with example usage: obj.fit(X, y) and returns: self