def decision_function(self, X):
"""Predict confidence scores for samples
The confidence score for a sample is the signed distance of that
sample to the hyperplane.
Parameters
----------
X : {array-like, 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.
"""
# handle regression (least-squared loss)
if not self.is_classif:
return LinearModel.decision_function(self, X)
X = atleast2d_or_csr(X)
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 = safe_sparse_dot(X, self.coef_.T,
dense_output=True) + self.intercept_
return scores.ravel() if scores.shape[1] == 1 else scores
def predict(self, X):
"""Predict class labels for samples in X.
Parameters
----------
X : list of Niimg-like objects
See http://nilearn.github.io/manipulating_visualizing/manipulating_images.html#niimg
Data on prediction is to be made. If this is a list,
the affine is considered the same for all.
Returns
-------
y_pred : ndarray, shape (n_samples,)
Predicted class label per sample.
"""
# cast X into usual 2D array
if not hasattr(self, "masker_"):
raise RuntimeError("This %s instance is not fitted yet!" % (
self.__class__.__name__))
X = self.masker_.transform(X)
# handle regression (least-squared loss)
if not self.is_classif:
return LinearModel.predict(self, X)
# prediction proper
scores = self.decision_function(X)
if len(scores.shape) == 1:
indices = (scores > 0).astype(np.int)
else:
indices = scores.argmax(axis=1)
return self.classes_[indices]
def predict(self, X):
"""Predict class labels for samples in X.
Parameters
----------
X : list of Niimg-like objects
See http://nilearn.github.io/manipulating_images/input_output.html
Data on prediction is to be made. If this is a list,
the affine is considered the same for all.
Returns
-------
y_pred : ndarray, shape (n_samples,)
Predicted class label per sample.
"""
# cast X into usual 2D array
if not hasattr(self, "masker_"):
raise RuntimeError("This %s instance is not fitted yet!" % (
self.__class__.__name__))
X = self.masker_.transform(X)
# handle regression (least-squared loss)
if not self.is_classif:
return LinearModel.predict(self, X)
# prediction proper
scores = self.decision_function(X)
if len(scores.shape) == 1:
indices = (scores > 0).astype(np.int)
else:
indices = scores.argmax(axis=1)
return self.classes_[indices]
def predict(self, X):
"""Predict class labels for samples in X.
Parameters
----------
X : list of Niimg-like objects
See http://nilearn.github.io/building_blocks/
manipulating_mr_images.html#niimg.
Data on prediction is to be made. If this is a list,
the affine is considered the same for all.
Returns
-------
y_pred : ndarray, shape (n_samples,)
Predicted class label per sample.
"""
# cast X into usual 2D array
X = self.masker_.transform(X)
# handle regression (least-squared loss)
if not self.is_classif:
return LinearModel.predict(self, X)
# prediction proper
scores = self.decision_function(X)
if len(scores.shape) == 1:
indices = (scores > 0).astype(np.int)
else:
indices = scores.argmax(axis=1)
return self.classes_[indices]
def decision_function(self, X):
"""Predict confidence scores for samples
The confidence score for a sample is the signed distance of that
sample to the hyperplane.
Parameters
----------
X : {array-like, 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.
"""
# handle regression (least-squared loss)
if not self.is_classif:
return LinearModel.decision_function(self, X)
X = atleast2d_or_csr(X)
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 = safe_sparse_dot(X, self.coef_.T,
dense_output=True) + self.intercept_
return scores.ravel() if scores.shape[1] == 1 else scores
def predict_benefit(reg_model: LinearModel, trunk_diam: float) -> float:
trunk_diam_sqrt = math.sqrt(trunk_diam)
return reg_model.predict([[trunk_diam, trunk_diam_sqrt]])[0]
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 array-like of shape [n_samples]
Sample weight
Returns
-------
self : Returns self.
"""
X, y = check_X_y(X,
y, ['csr', 'csc', 'coo'],
dtype=np.float64,
multi_output=True,
y_numeric=True)
n_samples, n_features = X.shape
if hasattr(LinearModel, '_preprocess_data'):
# Scikit-learn 0.18 and up
X, y, X_offset, y_offset, X_scale = LinearModel._preprocess_data(
X,
y,
self.fit_intercept,
self.normalize,
self.copy_X,
sample_weight=sample_weight)
else:
X, y, X_offset, y_offset, X_scale = LinearModel._center_data(
X,
y,
self.fit_intercept,
self.normalize,
self.copy_X,
sample_weight=sample_weight)
gcv_mode = self.gcv_mode
with_sw = len(np.shape(sample_weight))
if gcv_mode is None or gcv_mode == 'auto':
if sparse.issparse(X) or n_features > n_samples or with_sw:
gcv_mode = 'eigen'
else:
gcv_mode = 'svd'
elif gcv_mode == "svd" and with_sw:
# FIXME non-uniform sample weights not yet supported
warnings.warn("non-uniform sample weights unsupported for svd, "
"forcing usage of eigen")
gcv_mode = 'eigen'
if gcv_mode == 'eigen':
_pre_compute = self._pre_compute
_errors = self._errors
_values = self._values
elif gcv_mode == 'svd':
# assert n_samples >= n_features
_pre_compute = self._pre_compute_svd
_errors = self._errors_svd
_values = self._values_svd
else:
raise ValueError('bad gcv_mode "%s"' % gcv_mode)
if sample_weight is not None:
X, y = _rescale_data(X, y, sample_weight)
# Ensure that y is a 2D array: n_samples x n_targets
flat_y = y.ndim == 1
if flat_y:
y = np.atleast_2d(y).T
n_targets = y.shape[1]
centered_kernel = not sparse.issparse(X) and self.fit_intercept
v, Q, QT_y = _pre_compute(X, y, centered_kernel)
cv_values = np.zeros((n_samples, n_targets, len(self.alphas)))
C = []
scorer = check_scoring(self, scoring=self.scoring, allow_none=True)
error = scorer is None
for i, alpha in enumerate(self.alphas):
if error:
out, c = _errors(alpha, y, v, Q, QT_y)
else:
out, c = _values(alpha, y, v, Q, QT_y)
cv_values[:, :, i] = out
C.append(c)
if self.store_cv_values:
self.cv_values_ = cv_values
if error:
if self.alpha_per_target:
# Find the best alpha for each target
best = cv_values.mean(axis=0).argmin(axis=1)
else:
# Find the best alpha overall
best = np.mean(cv_values.reshape(-1, len(self.alphas)),
axis=0).argmin()
else:
# The scorer wants an object that will make the predictions, but
# they are already computed efficiently by RidgeGCV. This
# identity_estimator will just return them
def identity_estimator():
pass
identity_estimator.decision_function = lambda y_predict: y_predict
identity_estimator.predict = lambda y_predict: y_predict
if self.alpha_per_target:
out = [
scorer(identity_estimator, target, cv_values[:, i, j])
for j in range(len(self.alphas))
for i, target in enumerate(y.T)
]
best = np.argmax(out, axis=1)
else:
out = [
scorer(identity_estimator, y.ravel(), cv_values[:, :,
i].ravel())
for i in range(len(self.alphas))
]
best = np.argmax(out)
self.alpha_ = self.alphas[best]
if self.alpha_per_target:
self.dual_coef_ = np.vstack(
[C[j][:, i] for i, j in enumerate(best)]).T
else:
self.dual_coef_ = C[best]
self.coef_ = safe_sparse_dot(self.dual_coef_.T, X)
# If the original y was flat, remove some dimensions to match
if flat_y:
if self.store_cv_values:
self.cv_values_ = cv_values.reshape(n_samples,
len(self.alphas))
self.coef_ = self.coef_.ravel()
self._set_intercept(X_offset, y_offset, X_scale)
return self
def fit(self, X, y, sample_weight=1.0):
"""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_responses]
Target values
sample_weight : float or array-like of shape [n_samples]
Sample weight
Returns
-------
self : Returns self.
"""
X = safe_asarray(X, dtype=np.float)
y = np.asarray(y, dtype=np.float)
n_samples, n_features = X.shape
X, y, X_mean, y_mean, X_std = LinearModel._center_data(
X, y, self.fit_intercept, self.normalize, self.copy_X)
gcv_mode = self.gcv_mode
with_sw = len(np.shape(sample_weight))
if gcv_mode is None or gcv_mode == 'auto':
if n_features > n_samples or with_sw:
gcv_mode = 'eigen'
else:
gcv_mode = 'svd'
elif gcv_mode == "svd" and with_sw:
# FIXME non-uniform sample weights not yet supported
warnings.warn("non-uniform sample weights unsupported for svd, "
"forcing usage of eigen")
gcv_mode = 'eigen'
if gcv_mode == 'eigen':
_pre_compute = self._pre_compute
_errors = self._errors
_values = self._values
elif gcv_mode == 'svd':
# assert n_samples >= n_features
_pre_compute = self._pre_compute_svd
_errors = self._errors_svd
_values = self._values_svd
else:
raise ValueError('bad gcv_mode "%s"' % gcv_mode)
v, Q, QT_y = _pre_compute(X, y)
n_y = 1 if len(y.shape) == 1 else y.shape[1]
cv_values = np.zeros((n_samples * n_y, len(self.alphas)))
C = []
error = self.score_func is None and self.loss_func is None
for i, alpha in enumerate(self.alphas):
if error:
out, c = _errors(sample_weight * alpha, y, v, Q, QT_y)
else:
out, c = _values(sample_weight * alpha, y, v, Q, QT_y)
cv_values[:, i] = out.ravel()
C.append(c)
if error:
best = cv_values.mean(axis=0).argmin()
else:
func = self.score_func if self.score_func else self.loss_func
out = [
func(y.ravel(), cv_values[:, i])
for i in range(len(self.alphas))
]
best = np.argmax(out) if self.score_func else np.argmin(out)
self.best_alpha = self.alphas[best]
self.dual_coef_ = C[best]
self.coef_ = safe_sparse_dot(self.dual_coef_.T, X)
self._set_intercept(X_mean, y_mean, X_std)
if self.store_cv_values:
if len(y.shape) == 1:
cv_values_shape = n_samples, len(self.alphas)
else:
cv_values_shape = n_samples, n_y, len(self.alphas)
self.cv_values_ = cv_values.reshape(cv_values_shape)
return self
def fit(self, X, y, sample_weight=1.0):
"""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_responses]
Target values
sample_weight : float or array-like of shape [n_samples]
Sample weight
Returns
-------
self : Returns self.
"""
X = safe_asarray(X, dtype=np.float)
y = np.asarray(y, dtype=np.float)
n_samples, n_features = X.shape
X, y, X_mean, y_mean, X_std = LinearModel._center_data(X, y,
self.fit_intercept, self.normalize, self.copy_X)
gcv_mode = self.gcv_mode
with_sw = len(np.shape(sample_weight))
if gcv_mode is None or gcv_mode == 'auto':
if n_features > n_samples or with_sw:
gcv_mode = 'eigen'
else:
gcv_mode = 'svd'
elif gcv_mode == "svd" and with_sw:
# FIXME non-uniform sample weights not yet supported
warnings.warn("non-uniform sample weights unsupported for svd, "
"forcing usage of eigen")
gcv_mode = 'eigen'
if gcv_mode == 'eigen':
_pre_compute = self._pre_compute
_errors = self._errors
_values = self._values
elif gcv_mode == 'svd':
# assert n_samples >= n_features
_pre_compute = self._pre_compute_svd
_errors = self._errors_svd
_values = self._values_svd
else:
raise ValueError('bad gcv_mode "%s"' % gcv_mode)
v, Q, QT_y = _pre_compute(X, y)
n_y = 1 if len(y.shape) == 1 else y.shape[1]
cv_values = np.zeros((n_samples * n_y, len(self.alphas)))
C = []
error = self.score_func is None and self.loss_func is None
for i, alpha in enumerate(self.alphas):
if error:
out, c = _errors(sample_weight * alpha, y, v, Q, QT_y)
else:
out, c = _values(sample_weight * alpha, y, v, Q, QT_y)
cv_values[:, i] = out.ravel()
C.append(c)
if error:
best = cv_values.mean(axis=0).argmin()
else:
func = self.score_func if self.score_func else self.loss_func
out = [func(y.ravel(), cv_values[:, i])
for i in range(len(self.alphas))]
best = np.argmax(out) if self.score_func else np.argmin(out)
self.alpha_ = self.alphas[best]
self.dual_coef_ = C[best]
self.coef_ = safe_sparse_dot(self.dual_coef_.T, X)
self._set_intercept(X_mean, y_mean, X_std)
if self.store_cv_values:
if len(y.shape) == 1:
cv_values_shape = n_samples, len(self.alphas)
else:
cv_values_shape = n_samples, n_y, len(self.alphas)
self.cv_values_ = cv_values.reshape(cv_values_shape)
return self
