# #******************************************************************************* # Copyright 2014-2020 Intel Corporation # # 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 numpy as np from scipy import sparse as sp from sklearn.utils import check_array, check_X_y from sklearn.base import RegressorMixin from sklearn.linear_model.ridge import _BaseRidge from sklearn.linear_model.ridge import Ridge as Ridge_original import daal4py from .._utils import (make2d, getFPType, method_uses_sklearn, method_uses_daal) import logging def _daal4py_fit(self, X, y_): X = make2d(X) y = make2d(y_) _fptype = getFPType(X) ridge_params = np.asarray(self.alpha, dtype=X.dtype) if ridge_params.size != 1 and ridge_params.size != y.shape[1]: raise ValueError("alpha length is wrong") ridge_params = ridge_params.reshape((1,-1)) ridge_alg = daal4py.ridge_regression_training( fptype=_fptype, method='defaultDense', interceptFlag=(self.fit_intercept is True), ridgeParameters=ridge_params ) ridge_res = ridge_alg.compute(X, y) ridge_model = ridge_res.model self.daal_model_ = ridge_model coefs = ridge_model.Beta self.intercept_ = coefs[:,0].copy(order='C') self.coef_ = coefs[:,1:].copy(order='C') if self.coef_.shape[0] == 1 and y_.ndim == 1: self.coef_ = np.ravel(self.coef_) self.intercept_ = self.intercept_[0] return self def _daal4py_predict(self, X): X = make2d(X) _fptype = getFPType(self.coef_) ridge_palg = daal4py.ridge_regression_prediction( fptype=_fptype, method='defaultDense' ) ridge_res = ridge_palg.compute(X, self.daal_model_) res = ridge_res.prediction if res.shape[1] == 1 and self.coef_.ndim == 1: res = np.ravel(res) return res def fit(self, X, y, sample_weight=None): """Fit Ridge regression model Parameters ---------- X : {array-like, sparse matrix}, shape = [n_samples, n_features] Training data y : array-like, shape = [n_samples] or [n_samples, n_targets] Target values sample_weight : float or numpy array of shape [n_samples] Individual weights for each sample Returns ------- self : returns an instance of self. """ X, y = check_X_y(X, y, ['csr', 'csc', 'coo'], dtype=[np.float64, np.float32], multi_output=True, y_numeric=True) self.sample_weight_ = sample_weight self.fit_shape_good_for_daal_ = True if X.shape[0] >= X.shape[1] else False if (not self.solver == 'auto' or sp.issparse(X) or not self.fit_shape_good_for_daal_ or not (X.dtype == np.float64 or X.dtype == np.float32) or sample_weight is not None): if hasattr(self, 'daal_model_'): del self.daal_model_ logging.info("sklearn.linear_model.Ridge.fit: " + method_uses_sklearn) return super(Ridge, self).fit(X, y, sample_weight=sample_weight) else: logging.info("sklearn.linear_model.Ridge.fit: " + method_uses_daal) self.n_iter_ = None return _daal4py_fit(self, X, y) def predict(self, X): """Predict using the linear model Parameters ---------- X : {array-like, sparse matrix}, shape = (n_samples, n_features) Samples. Returns ------- C : array, shape = (n_samples,) Returns predicted values. """ X = check_array(X, accept_sparse=['csr', 'csc', 'coo']) good_shape_for_daal = True if X.ndim <= 1 else True if X.shape[0] >= X.shape[1] else False if (not self.solver == 'auto' or not hasattr(self, 'daal_model_') or sp.issparse(X) or not good_shape_for_daal or not (X.dtype == np.float64 or X.dtype == np.float32) or (hasattr(self, 'sample_weight_') and self.sample_weight_ is not None)): logging.info("sklearn.linear_model.Ridge.predict: " + method_uses_sklearn) return self._decision_function(X) else: logging.info("sklearn.linear_model.Ridge.predict: " + method_uses_daal) return _daal4py_predict(self, X) _fit_copy = fit _predict_copy = predict class Ridge(Ridge_original, _BaseRidge): __doc__ = Ridge_original.__doc__ def __init__(self, alpha=1.0, fit_intercept=True, normalize=False, copy_X=True, max_iter=None, tol=1e-3, solver="auto", random_state=None): self.alpha = alpha self.fit_intercept = fit_intercept self.normalize = normalize self.copy_X = copy_X self.max_iter = max_iter self.tol = tol self.solver = solver self.random_state = random_state def fit(self, X, y, sample_weight=None): return _fit_copy(self, X, y, sample_weight=sample_weight) def predict(self, X): return _predict_copy(self, X)