1# Program 01: Run linear regression.
2import numpy as np
3from sklearn.linear_model import LinearRegression

1type(LinearRegression)
2abc.ABCMeta

 1dir(LinearRegression)
 2['__abstractmethods__',
 3 '__class__',
 4 '__delattr__',
 5 '__dict__',
 6 '__dir__',
 7 '__doc__',
 8 '__eq__',
 9 '__format__',
10 '__ge__',
11 '__getattribute__',
12 '__getstate__',
13 '__gt__',
14 '__hash__',
15 '__init__',
16 '__init_subclass__',
17 '__le__',
18 '__lt__',
19 '__module__',
20 '__ne__',
21 '__new__',
22 '__reduce__',
23 '__reduce_ex__',
24 '__repr__',
25 '__setattr__',
26 '__setstate__',
27 '__sizeof__',
28 '__str__',
29 '__subclasshook__',
30 '__weakref__',
31 '_abc_impl',
32 '_check_feature_names',
33 '_check_n_features',
34 '_decision_function',
35 '_estimator_type',
36 '_get_param_names',
37 '_get_tags',
38 '_more_tags',
39 '_preprocess_data',
40 '_repr_html_',
41 '_repr_html_inner',
42 '_repr_mimebundle_',
43 '_set_intercept',
44 '_validate_data',
45 'fit',
46 'get_params',
47 'predict',
48 'score',
49 'set_params']

1 'fit',
2 'get_params',
3 'predict',
4 'score',
5 'set_params'

  1Help on class LinearRegression in module sklearn.linear_model._base:
  2
  3class LinearRegression(sklearn.base.MultiOutputMixin, sklearn.base.RegressorMixin, LinearModel)
  4 |  LinearRegression(*, fit_intercept=True, normalize='deprecated', copy_X=True, n_jobs=None, positive=False)
  5 |  
  6 |  Ordinary least squares Linear Regression.
  7 |  
  8 |  LinearRegression fits a linear model with coefficients w = (w1, ..., wp)
  9 |  to minimize the residual sum of squares between the observed targets in
 10 |  the dataset, and the targets predicted by the linear approximation.
 11 |  
 12 |  Parameters
 13 |  ----------
 14 |  fit_intercept : bool, default=True
 15 |      Whether to calculate the intercept for this model. If set
 16 |      to False, no intercept will be used in calculations
 17 |      (i.e. data is expected to be centered).
 18 |  
 19 |  normalize : bool, default=False
 20 |      This parameter is ignored when ``fit_intercept`` is set to False.
 21 |      If True, the regressors X will be normalized before regression by
 22 |      subtracting the mean and dividing by the l2-norm.
 23 |      If you wish to standardize, please use
 24 |      :class:`~sklearn.preprocessing.StandardScaler` before calling ``fit``
 25 |      on an estimator with ``normalize=False``.
 26 |  
 27 |      .. deprecated:: 1.0
 28 |         `normalize` was deprecated in version 1.0 and will be
 29 |         removed in 1.2.
 30 |  
 31 |  copy_X : bool, default=True
 32 |      If True, X will be copied; else, it may be overwritten.
 33 |  
 34 |  n_jobs : int, default=None
 35 |      The number of jobs to use for the computation. This will only provide
 36 |      speedup in case of sufficiently large problems, that is if firstly
 37 |      `n_targets > 1` and secondly `X` is sparse or if `positive` is set
 38 |      to `True`. ``None`` means 1 unless in a
 39 |      :obj:`joblib.parallel_backend` context. ``-1`` means using all
 40 |      processors. See :term:`Glossary <n_jobs>` for more details.
 41 |  
 42 |  positive : bool, default=False
 43 |      When set to ``True``, forces the coefficients to be positive. This
 44 |      option is only supported for dense arrays.
 45 |  
 46 |      .. versionadded:: 0.24
 47 |  
 48 |  Attributes
 49 |  ----------
 50 |  coef_ : array of shape (n_features, ) or (n_targets, n_features)
 51 |      Estimated coefficients for the linear regression problem.
 52 |      If multiple targets are passed during the fit (y 2D), this
 53 |      is a 2D array of shape (n_targets, n_features), while if only
 54 |      one target is passed, this is a 1D array of length n_features.
 55 |  
 56 |  rank_ : int
 57 |      Rank of matrix `X`. Only available when `X` is dense.
 58 |  
 59 |  singular_ : array of shape (min(X, y),)
 60 |      Singular values of `X`. Only available when `X` is dense.
 61 |  
 62 |  intercept_ : float or array of shape (n_targets,)
 63 |      Independent term in the linear model. Set to 0.0 if
 64 |      `fit_intercept = False`.
 65 |  
 66 |  n_features_in_ : int
 67 |      Number of features seen during :term:`fit`.
 68 |  
 69 |      .. versionadded:: 0.24
 70 |  
 71 |  feature_names_in_ : ndarray of shape (`n_features_in_`,)
 72 |      Names of features seen during :term:`fit`. Defined only when `X`
 73 |      has feature names that are all strings.
 74 |  
 75 |      .. versionadded:: 1.0
 76 |  
 77 |  See Also
 78 |  --------
 79 |  Ridge : Ridge regression addresses some of the
 80 |      problems of Ordinary Least Squares by imposing a penalty on the
 81 |      size of the coefficients with l2 regularization.
 82 |  Lasso : The Lasso is a linear model that estimates
 83 |      sparse coefficients with l1 regularization.
 84 |  ElasticNet : Elastic-Net is a linear regression
 85 |      model trained with both l1 and l2 -norm regularization of the
 86 |      coefficients.
 87 |  
 88 |  Notes
 89 |  -----
 90 |  From the implementation point of view, this is just plain Ordinary
 91 |  Least Squares (scipy.linalg.lstsq) or Non Negative Least Squares
 92 |  (scipy.optimize.nnls) wrapped as a predictor object.
 93 |  
 94 |  Examples
 95 |  --------
 96 |  >>> import numpy as np
 97 |  >>> from sklearn.linear_model import LinearRegression
 98 |  >>> X = np.array([[1, 1], [1, 2], [2, 2], [2, 3]])
 99 |  >>> # y = 1 * x_0 + 2 * x_1 + 3
100 |  >>> y = np.dot(X, np.array([1, 2])) + 3
101 |  >>> reg = LinearRegression().fit(X, y)
102 |  >>> reg.score(X, y)
103 |  1.0
104 |  >>> reg.coef_
105 |  array([1., 2.])
106 |  >>> reg.intercept_
107 |  3.0...
108 |  >>> reg.predict(np.array([[3, 5]]))
109 |  array([16.])
110 |  
111 |  Method resolution order:
112 |      LinearRegression
113 |      sklearn.base.MultiOutputMixin
114 |      sklearn.base.RegressorMixin
115 |      LinearModel
116 |      sklearn.base.BaseEstimator
117 |      builtins.object
118 |  
119 |  Methods defined here:
120 |  
121 |  __init__(self, *, fit_intercept=True, normalize='deprecated', copy_X=True, n_jobs=None, positive=False)
122 |      Initialize self.  See help(type(self)) for accurate signature.
123 |  
124 |  fit(self, X, y, sample_weight=None)
125 |      Fit linear model.
126 |      
127 |      Parameters
128 |      ----------
129 |      X : {array-like, sparse matrix} of shape (n_samples, n_features)
130 |          Training data.
131 |      
132 |      y : array-like of shape (n_samples,) or (n_samples, n_targets)
133 |          Target values. Will be cast to X's dtype if necessary.
134 |      
135 |      sample_weight : array-like of shape (n_samples,), default=None
136 |          Individual weights for each sample.
137 |      
138 |          .. versionadded:: 0.17
139 |             parameter *sample_weight* support to LinearRegression.
140 |      
141 |      Returns
142 |      -------
143 |      self : object
144 |          Fitted Estimator.
145 |  
146 |  ----------------------------------------------------------------------
147 |  Data and other attributes defined here:
148 |  
149 |  __abstractmethods__ = frozenset()
150 |  
151 |  ----------------------------------------------------------------------
152 |  Data descriptors inherited from sklearn.base.MultiOutputMixin:
153 |  
154 |  __dict__
155 |      dictionary for instance variables (if defined)
156 |  
157 |  __weakref__
158 |      list of weak references to the object (if defined)
159 |  
160 |  ----------------------------------------------------------------------
161 |  Methods inherited from sklearn.base.RegressorMixin:
162 |  
163 |  score(self, X, y, sample_weight=None)
164 |      Return the coefficient of determination of the prediction.
165 |      
166 |      The coefficient of determination :math:`R^2` is defined as
167 |      :math:`(1 - \frac{u}{v})`, where :math:`u` is the residual
168 |      sum of squares ``((y_true - y_pred)** 2).sum()`` and :math:`v`
169 |      is the total sum of squares ``((y_true - y_true.mean()) ** 2).sum()``.
170 |      The best possible score is 1.0 and it can be negative (because the
171 |      model can be arbitrarily worse). A constant model that always predicts
172 |      the expected value of `y`, disregarding the input features, would get
173 |      a :math:`R^2` score of 0.0.
174 |      
175 |      Parameters
176 |      ----------
177 |      X : array-like of shape (n_samples, n_features)
178 |          Test samples. For some estimators this may be a precomputed
179 |          kernel matrix or a list of generic objects instead with shape
180 |          ``(n_samples, n_samples_fitted)``, where ``n_samples_fitted``
181 |          is the number of samples used in the fitting for the estimator.
182 |      
183 |      y : array-like of shape (n_samples,) or (n_samples, n_outputs)
184 |          True values for `X`.
185 |      
186 |      sample_weight : array-like of shape (n_samples,), default=None
187 |          Sample weights.
188 |      
189 |      Returns
190 |      -------
191 |      score : float
192 |          :math:`R^2` of ``self.predict(X)`` wrt. `y`.
193 |      
194 |      Notes
195 |      -----
196 |      The :math:`R^2` score used when calling ``score`` on a regressor uses
197 |      ``multioutput='uniform_average'`` from version 0.23 to keep consistent
198 |      with default value of :func:`~sklearn.metrics.r2_score`.
199 |      This influences the ``score`` method of all the multioutput
200 |      regressors (except for
201 |      :class:`~sklearn.multioutput.MultiOutputRegressor`).
202 |  
203 |  ----------------------------------------------------------------------
204 |  Methods inherited from LinearModel:
205 |  
206 |  predict(self, X)
207 |      Predict using the linear model.
208 |      
209 |      Parameters
210 |      ----------
211 |      X : array-like or sparse matrix, shape (n_samples, n_features)
212 |          Samples.
213 |      
214 |      Returns
215 |      -------
216 |      C : array, shape (n_samples,)
217 |          Returns predicted values.
218 |  
219 |  ----------------------------------------------------------------------
220 |  Methods inherited from sklearn.base.BaseEstimator:
221 |  
222 |  __getstate__(self)
223 |  
224 |  __repr__(self, N_CHAR_MAX=700)
225 |      Return repr(self).
226 |  
227 |  __setstate__(self, state)
228 |  
229 |  get_params(self, deep=True)
230 |      Get parameters for this estimator.
231 |      
232 |      Parameters
233 |      ----------
234 |      deep : bool, default=True
235 |          If True, will return the parameters for this estimator and
236 |          contained subobjects that are estimators.
237 |      
238 |      Returns
239 |      -------
240 |      params : dict
241 |          Parameter names mapped to their values.
242 |  
243 |  set_params(self, **params)
244 |      Set the parameters of this estimator.
245 |      
246 |      The method works on simple estimators as well as on nested objects
247 |      (such as :class:`~sklearn.pipeline.Pipeline`). The latter have
248 |      parameters of the form ``<component>__<parameter>`` so that it's
249 |      possible to update each component of a nested object.
250 |      
251 |      Parameters
252 |      ----------
253 |      **params : dict
254 |          Estimator parameters.
255 |      
256 |      Returns
257 |      -------
258 |      self : estimator instance
259 |          Estimator instance.