metrics.mean_poisson_deviance

metrics.mean_gamma_deviance

metrics.mean_tweedie_deviance

Multilabel ranking metrics

functions to measure regression performance. Some of those have been enhanced

to handle the multioutput case: :func:`mean_squared_error`,

:func:`mean_absolute_error`, :func:`explained_variance_score`,

These functions have an ``multioutput`` keyword argument which specifies the

Pinball loss

\text{pinball}(y, \hat{y}) = \frac{1}{n_{\text{samples}}} \sum_{i=0}^{n_{\text{samples}}-1} \alpha \max(y_i - \hat{y}_i, 0) + (1 - \alpha) \max(\hat{y}_i - y_i, 0)

It is possible to build a scorer object with a specific choice of alpha to

perform, for instance to evaluate a regressor of the 95th percentile::

Such a scorer can be used in a cross-validation loop:

... alpha=0.95,

... random_state=0,

... )

array([11.1..., 10.4... , 24.4..., 9.2..., 12.9...])

It is also possible to build scorer objects for hyper-parameter tuning, in

class methods and will be removed in 1.2.

:pr:`18543` by `Guillaume Lemaitre`_.

:mod:`sklearn.naive_bayes`

from sklearn.ensemble import GradientBoostingRegressor

all_models = {}

import pandas as pd

metrics = {'model': name}

y_pred = gbr.predict(X_train)

for alpha in [0.05, 0.5, 0.95]:

y_train, y_pred, alpha=alpha)

metrics['MSE'] = mean_squared_error(y_train, y_pred)

results.append(metrics)

metrics = {'model': name}

y_pred = gbr.predict(X_test)

for alpha in [0.05, 0.5, 0.95]:

y_test, y_pred, alpha=alpha)

metrics['MSE'] = mean_squared_error(y_test, y_pred)

results.append(metrics)

min_samples_split=[2, 5, 10, 20, 30, 50],

)

alpha = 0.05

alpha=alpha,

greater_is_better=False, # maximize the negative loss

)

gbr,

param_grid,

n_iter=10, # increase this if computational budget allows

n_jobs=2,

random_state=0,

).fit(X_train, y_train)

from sklearn.base import clone

alpha = 0.95

alpha=alpha,

greater_is_better=False, # maximize the negative loss

)

search_95p = clone(search_05p).set_params(

estimator__alpha=alpha,

)

search_95p.fit(X_train, y_train)

pprint(search_95p.best_params_)

from pytest import approx

from sklearn.utils import check_random_state

from sklearn.ensemble._gb_losses import RegressionLossFunction

from sklearn.ensemble._gb_losses import LeastSquaresError

from sklearn.ensemble._gb_losses import LeastAbsoluteError

y_found = QuantileLossFunction(0.9)(x, np.zeros_like(x))

y_expected = np.asarray([0.1, 0.0, 0.9]).mean()

np.testing.assert_allclose(y_found, y_expected)

np.testing.assert_allclose(y_found, y_found_p)

def test_sample_weight_deviance():

# Test if deviance supports sample weights.

rng = check_random_state(13)

ql_weighted_loss = ql(y_true, raw_predictions, sample_weight=weights)

if alpha == 0.5:

assert lad_weighted_loss == approx(2 * ql_weighted_loss)

assert pbl_weighted_loss == approx(ql_weighted_loss)

from ._regression import mean_squared_log_error

from ._regression import median_absolute_error

from ._regression import mean_absolute_percentage_error

from ._regression import r2_score

from ._regression import mean_tweedie_deviance

from ._regression import mean_poisson_deviance

'mean_absolute_error',

'mean_squared_error',

'mean_squared_log_error',

'mean_poisson_deviance',

'mean_gamma_deviance',

'mean_tweedie_deviance',

'plot_det_curve',

'plot_precision_recall_curve',

'plot_roc_curve',

'PrecisionRecallDisplay',

'precision_recall_curve',

'precision_recall_fscore_support',

"mean_squared_log_error",

"median_absolute_error",

"mean_absolute_percentage_error",

"r2_score",

"explained_variance_score",

"mean_tweedie_deviance",

return np.average(output_errors, weights=multioutput)

"""Pinball loss for quantile regression.

y_type, y_true, y_pred, multioutput = _check_reg_targets(

from sklearn.metrics import mean_gamma_deviance

from sklearn.metrics import median_absolute_error

from sklearn.metrics import multilabel_confusion_matrix

from sklearn.metrics import precision_recall_curve

from sklearn.metrics import precision_score

from sklearn.metrics import r2_score

"max_error": max_error,

"mean_absolute_error": mean_absolute_error,

"mean_squared_error": mean_squared_error,

"median_absolute_error": median_absolute_error,

"mean_absolute_percentage_error": mean_absolute_percentage_error,

"explained_variance_score": explained_variance_score,

MULTIOUTPUT_METRICS = {

"mean_absolute_error", "median_absolute_error", "mean_squared_error",

"r2_score", "explained_variance_score", "mean_absolute_percentage_error",

}

"micro_precision_score", "micro_recall_score",

"matthews_corrcoef_score", "mean_absolute_error", "mean_squared_error",

"cohen_kappa_score", "mean_normal_deviance"

}