# Copyright 1999-2021 Alibaba Group Holding Ltd.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import numbers
from abc import ABCMeta, abstractmethod
from numpy.linalg import LinAlgError
from sklearn.utils.validation import check_is_fitted, _deprecate_positional_args
from sklearn.base import MultiOutputMixin
from ... import execute
from ... import tensor as mt
from ...tensor.datasource import tensor as astensor
from ..base import BaseEstimator, RegressorMixin, ClassifierMixin
from ..preprocessing import normalize as f_normalize
from ..utils.validation import _check_sample_weight, check_array, FLOAT_DTYPES
def _preprocess_data(
X,
y,
fit_intercept,
normalize=False,
copy=True,
sample_weight=None,
return_mean=False,
check_input=True,
):
"""Center and scale data.
Centers data to have mean zero along axis 0. If fit_intercept=False or if
the X is a sparse matrix, no centering is done, but normalization can still
be applied. The function returns the statistics necessary to reconstruct
the input data, which are X_offset, y_offset, X_scale, such that the output
X = (X - X_offset) / X_scale
X_scale is the L2 norm of X - X_offset. If sample_weight is not None,
then the weighted mean of X and y is zero, and not the mean itself. If
return_mean=True, the mean, eventually weighted, is returned, independently
of whether X was centered (option used for optimization with sparse data in
coordinate_descend).
This is here because nearly all linear models will want their data to be
centered. This function also systematically makes y consistent with X.dtype
"""
if isinstance(sample_weight, numbers.Number):
sample_weight = None
if sample_weight is not None:
sample_weight = astensor(sample_weight)
X = astensor(X)
y = astensor(y, dtype=X.dtype)
if check_input:
X = check_array(X, copy=copy, accept_sparse=["csr", "csc"], dtype=FLOAT_DTYPES)
elif copy:
if X.issparse():
X = X.copy()
else:
X = X.copy(order="K")
if fit_intercept:
if X.issparse():
raise NotImplementedError("Does not support sparse input!")
else:
X_offset = mt.average(X, axis=0, weights=sample_weight)
X = X - X_offset
if normalize:
X, X_scale = f_normalize(X, axis=0, copy=False, return_norm=True)
else:
X_scale = mt.ones(X.shape[1], dtype=X.dtype)
y_offset = mt.average(y, axis=0, weights=sample_weight)
y = y - y_offset
else:
if X.issparse():
raise NotImplementedError("Does not support sparse input!")
X_offset = mt.zeros(X.shape[1], dtype=X.dtype)
X_scale = mt.ones(X.shape[1], dtype=X.dtype)
if y.ndim == 1:
y_offset = X.dtype.type(0)
else:
y_offset = mt.zeros(y.shape[1], dtype=X.dtype)
return X, y, X_offset, y_offset, X_scale
def _rescale_data(X, y, sample_weight):
"""Rescale data sample-wise by square root of sample_weight.
For many linear models, this enables easy support for sample_weight.
Returns
-------
X_rescaled : {array-like, sparse matrix}
y_rescaled : {array-like, sparse matrix}
"""
n_samples = X.shape[0]
sample_weight = mt.asarray(sample_weight)
if sample_weight.ndim == 0:
sample_weight = mt.full(n_samples, sample_weight, dtype=sample_weight.dtype)
sample_weight = mt.sqrt(sample_weight)
sw_matrix = mt.diag(sample_weight, sparse=True)
X = mt.dot(sw_matrix, X)
y = mt.dot(sw_matrix, y)
return X, y
class LinearModel(BaseEstimator, metaclass=ABCMeta):
"""Base class for Linear Models"""
@abstractmethod
def fit(self, X, y, sample_weight=None):
"""Fit model."""
def _decision_function(self, X):
check_is_fitted(self)
X = self._validate_data(
X, y="no_validation", accept_sparse=["csr", "csc", "coo"], reset=False
)
return mt.dot(X, self.coef_.T) + self.intercept_
def predict(self, X):
"""
Predict using the linear model.
Parameters
----------
X : array-like or sparse matrix, shape (n_samples, n_features)
Samples.
Returns
-------
C : array, shape (n_samples,)
Returns predicted values.
"""
return self._decision_function(X)
_preprocess_data = staticmethod(_preprocess_data)
def _set_intercept(self, X_offset, y_offset, X_scale):
"""Set the intercept_"""
if self.fit_intercept:
self.coef_ = self.coef_ / X_scale
self.intercept_ = y_offset - mt.dot(X_offset, self.coef_.T)
execute(self.coef_, self.intercept_)
else:
self.intercept_ = mt.tensor(0.0)
self.intercept_.execute()
def _more_tags(self): # noqa: R0201 # pylint: disable=no-self-use
return {"requires_y": True}
[docs]class LinearRegression(MultiOutputMixin, RegressorMixin, LinearModel):
"""
Ordinary least squares Linear Regression.
LinearRegression fits a linear model with coefficients w = (w1, ..., wp)
to minimize the residual sum of squares between the observed targets in
the dataset, and the targets predicted by the linear approximation.
Parameters
----------
fit_intercept : bool, default=True
Whether to calculate the intercept for this model. If set
to False, no intercept will be used in calculations
(i.e. data is expected to be centered).
normalize : bool, default=False
This parameter is ignored when ``fit_intercept`` is set to False.
If True, the regressors X will be normalized before regression by
subtracting the mean and dividing by the l2-norm.
If you wish to standardize, please use
:class:`~sklearn.preprocessing.StandardScaler` before calling ``fit``
on an estimator with ``normalize=False``.
copy_X : bool, default=True
If True, X will be copied; else, it may be overwritten.
positive : bool, default=False
When set to ``True``, forces the coefficients to be positive. This
option is only supported for dense arrays.
Attributes
----------
coef_ : array of shape (n_features, ) or (n_targets, n_features)
Estimated coefficients for the linear regression problem.
If multiple targets are passed during the fit (y 2D), this
is a 2D array of shape (n_targets, n_features), while if only
one target is passed, this is a 1D array of length n_features.
rank_ : int
Rank of matrix `X`. Only available when `X` is dense.
singular_ : array of shape (min(X, y),)
Singular values of `X`. Only available when `X` is dense.
intercept_ : float or array of shape (n_targets,)
Independent term in the linear model. Set to 0.0 if
`fit_intercept = False`.
n_features_in_ : int
Number of features seen during :term:`fit`.
See Also
--------
Ridge : Ridge regression addresses some of the
problems of Ordinary Least Squares by imposing a penalty on the
size of the coefficients with l2 regularization.
Lasso : The Lasso is a linear model that estimates
sparse coefficients with l1 regularization.
ElasticNet : Elastic-Net is a linear regression
model trained with both l1 and l2 -norm regularization of the
coefficients.
"""
[docs] @_deprecate_positional_args
def __init__(
self,
*,
fit_intercept=True,
normalize=False,
copy_X=True,
positive=False,
):
self.fit_intercept = fit_intercept
self.normalize = normalize
self.copy_X = copy_X
self.positive = positive
def fit(self, X, y, sample_weight=None):
"""
Fit linear model.
Parameters
----------
X : {array-like, sparse matrix} of shape (n_samples, n_features)
Training data.
y : array-like of shape (n_samples,) or (n_samples, n_targets)
Target values. Will be cast to X's dtype if necessary.
sample_weight : array-like of shape (n_samples,), default=None
Individual weights for each sample.
Returns
-------
self : object
Fitted Estimator.
"""
accept_sparse = False if self.positive else ["csr", "csc", "coo"]
X, y = self._validate_data(
X, y, accept_sparse=accept_sparse, y_numeric=True, multi_output=True
)
if sample_weight is not None:
sample_weight = _check_sample_weight(sample_weight, X, dtype=X.dtype)
X, y, X_offset, y_offset, X_scale = self._preprocess_data(
X,
y,
fit_intercept=self.fit_intercept,
normalize=self.normalize,
copy=self.copy_X,
sample_weight=sample_weight,
return_mean=True,
)
if sample_weight is not None:
# Sample weight can be implemented via a simple rescaling.
X, y = _rescale_data(X, y, sample_weight)
if self.positive:
# TODO: implement optimize.nnls first
raise NotImplementedError("Does not support positive coefficients!")
elif X.issparse():
# TODO: implement sparse.linalg.lsqr first
raise NotImplementedError("Does not support sparse input!")
else:
try:
# In numpy:
# Mat mul does NOT always satisfy associative law
# Tyipical mistake:
# (mt.linalg.inv(X.T @ X) @ (X.T @ y)).T
self.coef_ = (mt.linalg.inv(X.T @ X) @ X.T @ y).T
self.coef_.execute()
except LinAlgError:
# TODO: implement linalg.lstsq first
raise NotImplementedError("Does not support sigular matrix!")
if y.ndim == 1:
self.coef_ = mt.ravel(self.coef_)
self.coef_.execute()
self._set_intercept(X_offset, y_offset, X_scale)
return self
class LinearClassifierMixin(ClassifierMixin):
"""Mixin for linear classifiers.
Handles prediction for sparse and dense X.
"""
def decision_function(self, X):
"""
Predict confidence scores for samples.
The confidence score for a sample is proportional to the signed
distance of that sample to the hyperplane.
Parameters
----------
X : array-like or sparse matrix, shape (n_samples, n_features)
Samples.
Returns
-------
array, shape=(n_samples,) if n_classes == 2 else (n_samples, n_classes)
Confidence scores per (sample, class) combination. In the binary
case, confidence score for self.classes_[1] where >0 means this
class would be predicted.
"""
check_is_fitted(self)
X = check_array(X, accept_sparse="csr")
n_features = self.coef_.shape[1]
if X.shape[1] != n_features:
raise ValueError(
"X has %d features per sample; expecting %d" % (X.shape[1], n_features)
)
scores = mt.dot(X, self.coef_.T) + self.intercept_
return scores
def predict(self, X):
"""
Predict class labels for samples in X.
Parameters
----------
X : array-like or sparse matrix, shape (n_samples, n_features)
Samples.
Returns
-------
C : array, shape [n_samples]
Predicted class label per sample.
"""
scores = self.decision_function(X)
indices = scores.argmax(axis=1)
return self.classes_[indices].execute()