class_docstr: Linear regression learner, with many choices of penalization and
  solvers.
  
  Parameters
  ----------
  C : `float`, default=1e3
      Level of penalization
  
  penalty : {'none', 'l1', 'l2', 'elasticnet', 'tv'}, default='l2'
      The penalization to use. Default is ridge penalization
  
  solver : {'gd', 'agd', 'svrg'}, default='svrg'
      The name of the solver to use
  
  fit_intercept : `bool`, default=True
      If `True`, include an intercept in the model
  
  warm_start : `bool`, default=False
      If true, learning will start from the last reached solution
  
  step : `float`, default=None
      Initial step size used for learning. Used in fista, sgd and svrg
      solvers
  
  tol : `float`, default=1e-5
      The tolerance of the solver (iterations stop when the stopping
      criterion is below it). By default the solver does ``max_iter``
      iterations
  
  max_iter : `int`, default=100
      Maximum number of iterations of the solver
  
  verbose : `bool`, default=False
      If `True`, we verbose things, otherwise the solver does not
      print anything (but records information in history anyway)
  
  print_every : `int`, default=10
      Print history information when ``n_iter`` (iteration number) is
      a multiple of ``print_every``
  
  record_every : `int`, default=1
      Record history information when ``n_iter`` (iteration number) is
      a multiple of ``record_every``
  
  Other Parameters
  ----------------
  elastic_net_ratio : `float`, default=0.95
      Ratio of elastic net mixing parameter with 0 <= ratio <= 1.
      For ratio = 0 this is ridge (L2 squared) regularization
      For ratio = 1 this is lasso (L1) regularization
      For 0 < ratio < 1, the regularization is a linear combination
      of L1 and L2.
      Used in 'elasticnet' penalty
  
  random_state : `int` seed, `RandomState` instance, or `None` (default)
      The seed that will be used by stochastic solvers. Used in 'sgd',
      'svrg', and 'sdca' solvers
  
  blocks_start : `numpy.array`, shape=(n_features,), default=None
      The indices of the first column of each binarized feature blocks. It
      corresponds to the ``feature_indices`` property of the
      ``FeaturesBinarizer`` preprocessing.
      Used in 'binarsity' penalty
  
  blocks_length : `numpy.array`, shape=(n_features,), default=None
      The length of each binarized feature blocks. It corresponds to the
      ``n_values`` property of the ``FeaturesBinarizer`` preprocessing.
      Used in 'binarsity' penalty
  
  Attributes
  ----------
  weights : `np.array`, shape=(n_features,)
      The learned weights of the model (not including the intercept)
  
  intercept : `float` or `None`
      The intercept, if ``fit_intercept=True``, otherwise `None`
docstr: Predict class for given samples
  
  Parameters
  ----------
  X : `np.ndarray` or `scipy.sparse.csr_matrix`, shape=(n_samples, n_features)
      Features matrix to predict for.
  
  Returns
  -------
  output : `np.array`, shape=(n_samples,)
      Returns predicted values.
code: def predict(self, X):
      """Predict class for given samples
  
      Parameters
      ----------
      X : `np.ndarray` or `scipy.sparse.csr_matrix`, shape=(n_samples, n_features)
          Features matrix to predict for.
  
      Returns
      -------
      output : `np.array`, shape=(n_samples,)
          Returns predicted values.
      """
      if not self._fitted:
          raise ValueError("You must call ``fit`` before")
      else:
          X = self._safe_array(X, dtype=X.dtype)
          z = X.dot(self.weights)
          if self.intercept:
              z += self.intercept
          return z
  
file_path: tick/tick/linear_model/linear_regression.py
imports: from tick.base import actual_kwargs
  from tick.base.learner import LearnerGLM
  from .model_linreg import ModelLinReg
label_desc: Use image node_id 3 for calling the LinearRegression obj's underlying member method code with example usage: obj.predict(X) and returns: z