Ug dZddlZddlmZddlZddlmZddlm Z ddl m Z m Z m Z mZmZddlmZmZmZmZdd lmZdd lmZmZmZmZmZgd Zd>d ZedgdgddgeddhdgddddddZedgdgddgeedddgeddhdgdddddddZ edgdgddgeddhdgddddddZ!edgdgddgeddhdgeedhdgd ddddd!d"Z"edgdgddgeddhdgdddddd#Z#edgdgddgeddhdgeedhdgd ddddd!d$Z$edgdgddgeddhdgdddddd%Z%edgdgeddhdgddgd&dddd'd(Z&d)Z'edgdgddgehd*dgdgd+ddddd,d-Z(edgdgddgehd*ddgdgd+ddddd,d.Z)edgdgd/dd0Z*d1Z+edgdgddgeeddd2eeddd3gd4dddd5d6Z,edgdgddgd7ddd8d9Z-edgdgddgd7ddd8d:Z.edgdgddgeeddd2eeddd3gd4dddd5d;Z/edgdgddgeedddgeddhdgddddddd<Z0edgdgddgeddhdgdddddd=Z1dS)?zMetrics to assess performance on regression task. Functions named as ``*_score`` return a scalar value to maximize: the higher the better. Function named as ``*_error`` or ``*_loss`` return a scalar value to minimize: the lower the better. N)Real)xlogy)UndefinedMetricWarning)_average_find_matching_floating_dtype get_namespaceget_namespace_and_devicesize)HiddenInterval StrOptionsvalidate_params)_weighted_percentile)_check_sample_weight _num_samples check_arraycheck_consistent_length column_or_1d) max_errormean_absolute_errormean_squared_errormean_squared_log_errormedian_absolute_errormean_absolute_percentage_errormean_pinball_lossr2_scoreroot_mean_squared_log_errorroot_mean_squared_errorexplained_variance_scoremean_tweedie_deviancemean_poisson_deviancemean_gamma_devianced2_tweedie_scored2_pinball_scored2_absolute_error_scorenumericc4t||||\}}t||t|d|}t|d|}|jdkr||d}|jdkr||d}|jd|jdkr9t d|jd|jd|jd}d}t|tr(||vr#t d||n\|Zt|d }|dkrt d |t|kr!t d t||fz|dkrd nd}||||fS)aFCheck that y_true and y_pred belong to the same regression task. Parameters ---------- y_true : array-like y_pred : array-like multioutput : array-like or string in ['raw_values', uniform_average', 'variance_weighted'] or None None is accepted due to backward compatibility of r2_score(). dtype : str or list, default="numeric" the dtype argument passed to check_array. Returns ------- type_true : one of {'continuous', continuous-multioutput'} The type of the true target data, as output by 'utils.multiclass.type_of_target'. y_true : array-like of shape (n_samples, n_outputs) Ground truth (correct) target values. y_pred : array-like of shape (n_samples, n_outputs) Estimated target values. multioutput : array-like of shape (n_outputs) or string in ['raw_values', uniform_average', 'variance_weighted'] or None Custom output weights if ``multioutput`` is array-like or just the corresponding argument if ``multioutput`` is a correct keyword. xpF) ensure_2ddtype)r-z > >F 5 > > >F {aFG,, {aFG,, |A&,q/)) J Q Q Qa      QIT+s## 5 5 5006+[11  6  !+??? >>TUU U #k** * *Q{##Y/0 '!^^\\1IF 66; ..z array-liker/r0r<r= sample_weightr>T)prefer_skip_nested_validationrGr>ct|||\}}}}t|||tjtj||z |d}t |t r|dkr|S|dkrd}tj||S)a*Mean absolute error regression loss. Read more in the :ref:`User Guide `. Parameters ---------- y_true : array-like of shape (n_samples,) or (n_samples, n_outputs) Ground truth (correct) target values. y_pred : array-like of shape (n_samples,) or (n_samples, n_outputs) Estimated target values. sample_weight : array-like of shape (n_samples,), default=None Sample weights. multioutput : {'raw_values', 'uniform_average'} or array-like of shape (n_outputs,), default='uniform_average' Defines aggregating of multiple output values. Array-like value defines weights used to average errors. 'raw_values' : Returns a full set of errors in case of multioutput input. 'uniform_average' : Errors of all outputs are averaged with uniform weight. Returns ------- loss : float or ndarray of floats If multioutput is 'raw_values', then mean absolute error is returned for each output separately. If multioutput is 'uniform_average' or an ndarray of weights, then the weighted average of all output errors is returned. MAE output is non-negative floating point. The best value is 0.0. Examples -------- >>> from sklearn.metrics import mean_absolute_error >>> y_true = [3, -0.5, 2, 7] >>> y_pred = [2.5, 0.0, 2, 8] >>> mean_absolute_error(y_true, y_pred) np.float64(0.5) >>> y_true = [[0.5, 1], [-1, 1], [7, -6]] >>> y_pred = [[0, 2], [-1, 2], [8, -5]] >>> mean_absolute_error(y_true, y_pred) np.float64(0.75) >>> mean_absolute_error(y_true, y_pred, multioutput='raw_values') array([0.5, 1. ]) >>> mean_absolute_error(y_true, y_pred, multioutput=[0.3, 0.7]) np.float64(0.85...) rweightsaxisr/r0NrL)rDrnpaverageabsr9r:)r<r=rGr>rB output_errorss rCrrs@+= ++'FFFKFFM:::Jrvfvo66 TUVVVM+s## , & & - - -K :m[ 9 9 99rEr-both)closed)r<r=rGalphar>?rGrUr>ct|||\}}}}t|||||z }|dk|j}||z|zd|z d|z z|zz }t j||d} t |tr|dkr| St |tr|dkrd}t j| |S)a"Pinball loss for quantile regression. Read more in the :ref:`User Guide `. Parameters ---------- y_true : array-like of shape (n_samples,) or (n_samples, n_outputs) Ground truth (correct) target values. y_pred : array-like of shape (n_samples,) or (n_samples, n_outputs) Estimated target values. sample_weight : array-like of shape (n_samples,), default=None Sample weights. alpha : float, slope of the pinball loss, default=0.5, This loss is equivalent to :ref:`mean_absolute_error` when `alpha=0.5`, `alpha=0.95` is minimized by estimators of the 95th percentile. multioutput : {'raw_values', 'uniform_average'} or array-like of shape (n_outputs,), default='uniform_average' Defines aggregating of multiple output values. Array-like value defines weights used to average errors. 'raw_values' : Returns a full set of errors in case of multioutput input. 'uniform_average' : Errors of all outputs are averaged with uniform weight. Returns ------- loss : float or ndarray of floats If multioutput is 'raw_values', then mean absolute error is returned for each output separately. If multioutput is 'uniform_average' or an ndarray of weights, then the weighted average of all output errors is returned. The pinball loss output is a non-negative floating point. The best value is 0.0. Examples -------- >>> from sklearn.metrics import mean_pinball_loss >>> y_true = [1, 2, 3] >>> mean_pinball_loss(y_true, [0, 2, 3], alpha=0.1) np.float64(0.03...) >>> mean_pinball_loss(y_true, [1, 2, 4], alpha=0.1) np.float64(0.3...) >>> mean_pinball_loss(y_true, [0, 2, 3], alpha=0.9) np.float64(0.3...) >>> mean_pinball_loss(y_true, [1, 2, 4], alpha=0.9) np.float64(0.03...) >>> mean_pinball_loss(y_true, y_true, alpha=0.1) np.float64(0.0) >>> mean_pinball_loss(y_true, y_true, alpha=0.9) np.float64(0.0) rr-rKr/r0NrN)rDrastyper,rOrPr9r:) r<r=rGrUr>rBdiffsignlossrRs rCrrsN+= ++'FFFKFFM::: F?D AI  dj ) )D 4<$ !e)D!9D!@ @DJt]CCCM+s## |(C(C+s## 7H(H(H :m[ 9 9 99rEct|||\}}}}t|||tjtjj}tj||z tjtj||z }tj||d}t|tr|dkr|S|dkrd}tj||S)a Mean absolute percentage error (MAPE) regression loss. Note here that the output is not a percentage in the range [0, 100] and a value of 100 does not mean 100% but 1e2. Furthermore, the output can be arbitrarily high when `y_true` is small (which is specific to the metric) or when `abs(y_true - y_pred)` is large (which is common for most regression metrics). Read more in the :ref:`User Guide `. .. versionadded:: 0.24 Parameters ---------- y_true : array-like of shape (n_samples,) or (n_samples, n_outputs) Ground truth (correct) target values. y_pred : array-like of shape (n_samples,) or (n_samples, n_outputs) Estimated target values. sample_weight : array-like of shape (n_samples,), default=None Sample weights. multioutput : {'raw_values', 'uniform_average'} or array-like Defines aggregating of multiple output values. Array-like value defines weights used to average errors. If input is list then the shape must be (n_outputs,). 'raw_values' : Returns a full set of errors in case of multioutput input. 'uniform_average' : Errors of all outputs are averaged with uniform weight. Returns ------- loss : float or ndarray of floats If multioutput is 'raw_values', then mean absolute percentage error is returned for each output separately. If multioutput is 'uniform_average' or an ndarray of weights, then the weighted average of all output errors is returned. MAPE output is non-negative floating point. The best value is 0.0. But note that bad predictions can lead to arbitrarily large MAPE values, especially if some `y_true` values are very close to zero. Note that we return a large value instead of `inf` when `y_true` is zero. Examples -------- >>> from sklearn.metrics import mean_absolute_percentage_error >>> y_true = [3, -0.5, 2, 7] >>> y_pred = [2.5, 0.0, 2, 8] >>> mean_absolute_percentage_error(y_true, y_pred) np.float64(0.3273...) >>> y_true = [[0.5, 1], [-1, 1], [7, -6]] >>> y_pred = [[0, 2], [-1, 2], [8, -5]] >>> mean_absolute_percentage_error(y_true, y_pred) np.float64(0.5515...) >>> mean_absolute_percentage_error(y_true, y_pred, multioutput=[0.3, 0.7]) np.float64(0.6198...) >>> # the value when some element of the y_true is zero is arbitrarily high because >>> # of the division by epsilon >>> y_true = [1., 0., 2.4, 7.] >>> y_pred = [1.2, 0.1, 2.4, 8.] >>> mean_absolute_percentage_error(y_true, y_pred) np.float64(112589990684262.48) rrKr/r0NrN) rDrrOfinfofloat64epsrQmaximumrPr9r:)r<r=rGr>rBepsilonmaperRs rCrrAs\+= ++'FFFKFFM:::hrz""&G 6&6/ " "RZv%H%H HDJt]CCCM+s## , & & - - -K :m[ 9 9 99rE deprecatedboolean)r<r=rGr>squared)rGr>rfcj|dkr/tjdt|st||||St |||\}}}}t |||t j||z dzd|}t|tr|dkr|S|dkrd }t j|| S) aMean squared error regression loss. Read more in the :ref:`User Guide `. Parameters ---------- y_true : array-like of shape (n_samples,) or (n_samples, n_outputs) Ground truth (correct) target values. y_pred : array-like of shape (n_samples,) or (n_samples, n_outputs) Estimated target values. sample_weight : array-like of shape (n_samples,), default=None Sample weights. multioutput : {'raw_values', 'uniform_average'} or array-like of shape (n_outputs,), default='uniform_average' Defines aggregating of multiple output values. Array-like value defines weights used to average errors. 'raw_values' : Returns a full set of errors in case of multioutput input. 'uniform_average' : Errors of all outputs are averaged with uniform weight. squared : bool, default=True If True returns MSE value, if False returns RMSE value. .. deprecated:: 1.4 `squared` is deprecated in 1.4 and will be removed in 1.6. Use :func:`~sklearn.metrics.root_mean_squared_error` instead to calculate the root mean squared error. Returns ------- loss : float or ndarray of floats A non-negative floating point value (the best value is 0.0), or an array of floating point values, one for each individual target. Examples -------- >>> from sklearn.metrics import mean_squared_error >>> y_true = [3, -0.5, 2, 7] >>> y_pred = [2.5, 0.0, 2, 8] >>> mean_squared_error(y_true, y_pred) np.float64(0.375) >>> y_true = [[0.5, 1],[-1, 1],[7, -6]] >>> y_pred = [[0, 2],[-1, 2],[8, -5]] >>> mean_squared_error(y_true, y_pred) np.float64(0.708...) >>> mean_squared_error(y_true, y_pred, multioutput='raw_values') array([0.41666667, 1. ]) >>> mean_squared_error(y_true, y_pred, multioutput=[0.3, 0.7]) np.float64(0.825...) rdz'squared' is deprecated in version 1.4 and will be removed in 1.6. To calculate the root mean squared error, use the function'root_mean_squared_error'.rIrr)rMrLr/r0NrN) warningswarn FutureWarningrrDrrOrPr9r:)r<r=rGr>rfrBrRs rCrrsV, -     *m += ++'FFFKFFM:::JA5A}UUUM+s## , & & - - -K :m[ 9 9 99rEctjt|||d}t|tr|dkr|S|dkrd}tj||S)aRoot mean squared error regression loss. Read more in the :ref:`User Guide `. .. versionadded:: 1.4 Parameters ---------- y_true : array-like of shape (n_samples,) or (n_samples, n_outputs) Ground truth (correct) target values. y_pred : array-like of shape (n_samples,) or (n_samples, n_outputs) Estimated target values. sample_weight : array-like of shape (n_samples,), default=None Sample weights. multioutput : {'raw_values', 'uniform_average'} or array-like of shape (n_outputs,), default='uniform_average' Defines aggregating of multiple output values. Array-like value defines weights used to average errors. 'raw_values' : Returns a full set of errors in case of multioutput input. 'uniform_average' : Errors of all outputs are averaged with uniform weight. Returns ------- loss : float or ndarray of floats A non-negative floating point value (the best value is 0.0), or an array of floating point values, one for each individual target. Examples -------- >>> from sklearn.metrics import root_mean_squared_error >>> y_true = [3, -0.5, 2, 7] >>> y_pred = [2.5, 0.0, 2, 8] >>> root_mean_squared_error(y_true, y_pred) np.float64(0.612...) >>> y_true = [[0.5, 1],[-1, 1],[7, -6]] >>> y_pred = [[0, 2],[-1, 2],[8, -5]] >>> root_mean_squared_error(y_true, y_pred) np.float64(0.822...) r/rIr0NrN)rOsqrtrr9r:rP)r<r=rGr>rRs rCrr s|tG F-\   M +s## , & & - - -K :m[ 9 9 99rEc|dkr/tjdt|st||||St |||\}}}}t ||||dks|dkrtdttj |tj |||S)aSMean squared logarithmic error regression loss. Read more in the :ref:`User Guide `. Parameters ---------- y_true : array-like of shape (n_samples,) or (n_samples, n_outputs) Ground truth (correct) target values. y_pred : array-like of shape (n_samples,) or (n_samples, n_outputs) Estimated target values. sample_weight : array-like of shape (n_samples,), default=None Sample weights. multioutput : {'raw_values', 'uniform_average'} or array-like of shape (n_outputs,), default='uniform_average' Defines aggregating of multiple output values. Array-like value defines weights used to average errors. 'raw_values' : Returns a full set of errors when the input is of multioutput format. 'uniform_average' : Errors of all outputs are averaged with uniform weight. squared : bool, default=True If True returns MSLE (mean squared log error) value. If False returns RMSLE (root mean squared log error) value. .. deprecated:: 1.4 `squared` is deprecated in 1.4 and will be removed in 1.6. Use :func:`~sklearn.metrics.root_mean_squared_log_error` instead to calculate the root mean squared logarithmic error. Returns ------- loss : float or ndarray of floats A non-negative floating point value (the best value is 0.0), or an array of floating point values, one for each individual target. Examples -------- >>> from sklearn.metrics import mean_squared_log_error >>> y_true = [3, 5, 2.5, 7] >>> y_pred = [2.5, 5, 4, 8] >>> mean_squared_log_error(y_true, y_pred) np.float64(0.039...) >>> y_true = [[0.5, 1], [1, 2], [7, 6]] >>> y_pred = [[0.5, 2], [1, 2.5], [8, 8]] >>> mean_squared_log_error(y_true, y_pred) np.float64(0.044...) >>> mean_squared_log_error(y_true, y_pred, multioutput='raw_values') array([0.00462428, 0.08377444]) >>> mean_squared_log_error(y_true, y_pred, multioutput=[0.3, 0.7]) np.float64(0.060...) rdz'squared' is deprecated in version 1.4 and will be removed in 1.6. To calculate the root mean squared logarithmic error, use the function'root_mean_squared_log_error'.rIrzSMean Squared Logarithmic Error cannot be used when targets contain negative values.) rhrirjrrDranyr7rrOlog1p)r<r=rGr>rfrBs rCrrTs \, 1     .m += ++'FFFKFFM:::  fqj--//  /     #    rEc<t|||\}}}}t||||dks|dkrtdt t j|t j|||S)a{Root mean squared logarithmic error regression loss. Read more in the :ref:`User Guide `. .. versionadded:: 1.4 Parameters ---------- y_true : array-like of shape (n_samples,) or (n_samples, n_outputs) Ground truth (correct) target values. y_pred : array-like of shape (n_samples,) or (n_samples, n_outputs) Estimated target values. sample_weight : array-like of shape (n_samples,), default=None Sample weights. multioutput : {'raw_values', 'uniform_average'} or array-like of shape (n_outputs,), default='uniform_average' Defines aggregating of multiple output values. Array-like value defines weights used to average errors. 'raw_values' : Returns a full set of errors when the input is of multioutput format. 'uniform_average' : Errors of all outputs are averaged with uniform weight. Returns ------- loss : float or ndarray of floats A non-negative floating point value (the best value is 0.0), or an array of floating point values, one for each individual target. Examples -------- >>> from sklearn.metrics import root_mean_squared_log_error >>> y_true = [3, 5, 2.5, 7] >>> y_pred = [2.5, 5, 4, 8] >>> root_mean_squared_log_error(y_true, y_pred) np.float64(0.199...) rzXRoot Mean Squared Logarithmic Error cannot be used when targets contain negative values.rI)rDrrnr7rrOro)r<r=rGr>r?s rCrrsp&8 %T%T"Avv{FFM:::  fqj--//  /   #  #    rE)r<r=r>rG)r>rGclt|||\}}}}|,tjtj||z d}n6t ||}t tj||z |}t |tr|dkr|S|dkrd}tj||S)aaMedian absolute error regression loss. Median absolute error output is non-negative floating point. The best value is 0.0. Read more in the :ref:`User Guide `. Parameters ---------- y_true : array-like of shape (n_samples,) or (n_samples, n_outputs) Ground truth (correct) target values. y_pred : array-like of shape (n_samples,) or (n_samples, n_outputs) Estimated target values. multioutput : {'raw_values', 'uniform_average'} or array-like of shape (n_outputs,), default='uniform_average' Defines aggregating of multiple output values. Array-like value defines weights used to average errors. 'raw_values' : Returns a full set of errors in case of multioutput input. 'uniform_average' : Errors of all outputs are averaged with uniform weight. sample_weight : array-like of shape (n_samples,), default=None Sample weights. .. versionadded:: 0.24 Returns ------- loss : float or ndarray of floats If multioutput is 'raw_values', then mean absolute error is returned for each output separately. If multioutput is 'uniform_average' or an ndarray of weights, then the weighted average of all output errors is returned. Examples -------- >>> from sklearn.metrics import median_absolute_error >>> y_true = [3, -0.5, 2, 7] >>> y_pred = [2.5, 0.0, 2, 8] >>> median_absolute_error(y_true, y_pred) np.float64(0.5) >>> y_true = [[0.5, 1], [-1, 1], [7, -6]] >>> y_pred = [[0, 2], [-1, 2], [8, -5]] >>> median_absolute_error(y_true, y_pred) np.float64(0.75) >>> median_absolute_error(y_true, y_pred, multioutput='raw_values') array([0.5, 1. ]) >>> median_absolute_error(y_true, y_pred, multioutput=[0.3, 0.7]) np.float64(0.85) NrrMrGr/r0rN) rDrOmedianrQrrr9r:rP)r<r=r>rGrBrRs rCrr sB+= ++'FFFK "&&"9"9BBB ,]FCC , F6F? # #=   +s## , & & - - -K :m[ 9 9 99rEc|j}|dk}|s d||z z } nD|dk} ||g||} || z} d|| || z z | | <d| | |z<t|tr1|dkr| S|dkrd} n"|dkr|} ||sd} n|} t | | } t | dkrt| S| S) zCCommon part used by explained variance score and :math:`R^2` score.rr-)devicer,r/r0Nr1rN)r,onesr9r:rnrr float) numerator denominatorr@r> force_finiter*rvr,nonzero_denominator output_scoresnonzero_numerator valid_score avg_weightsresults rC_assemble_r2_explained_variancerbs6 OE%* FY45 %N F%HH ),== %& k "[%= =& k" CF '+>*>>?+s##" , & & - - -KK / / /%K66-.. ## ! m[ 9 9 9F F||qV}} MrE>r/r0r1)r<r=rGr>r|)rGr>r|c t|||\}}}}t|||tj||z |d}tj||z |z dz|d}tj||d}tj||z dz|d} t || |jd||t |ddS)a Explained variance regression score function. Best possible score is 1.0, lower values are worse. In the particular case when ``y_true`` is constant, the explained variance score is not finite: it is either ``NaN`` (perfect predictions) or ``-Inf`` (imperfect predictions). To prevent such non-finite numbers to pollute higher-level experiments such as a grid search cross-validation, by default these cases are replaced with 1.0 (perfect predictions) or 0.0 (imperfect predictions) respectively. If ``force_finite`` is set to ``False``, this score falls back on the original :math:`R^2` definition. .. note:: The Explained Variance score is similar to the :func:`R^2 score `, with the notable difference that it does not account for systematic offsets in the prediction. Most often the :func:`R^2 score ` should be preferred. Read more in the :ref:`User Guide `. Parameters ---------- y_true : array-like of shape (n_samples,) or (n_samples, n_outputs) Ground truth (correct) target values. y_pred : array-like of shape (n_samples,) or (n_samples, n_outputs) Estimated target values. sample_weight : array-like of shape (n_samples,), default=None Sample weights. multioutput : {'raw_values', 'uniform_average', 'variance_weighted'} or array-like of shape (n_outputs,), default='uniform_average' Defines aggregating of multiple output scores. Array-like value defines weights used to average scores. 'raw_values' : Returns a full set of scores in case of multioutput input. 'uniform_average' : Scores of all outputs are averaged with uniform weight. 'variance_weighted' : Scores of all outputs are averaged, weighted by the variances of each individual output. force_finite : bool, default=True Flag indicating if ``NaN`` and ``-Inf`` scores resulting from constant data should be replaced with real numbers (``1.0`` if prediction is perfect, ``0.0`` otherwise). Default is ``True``, a convenient setting for hyperparameters' search procedures (e.g. grid search cross-validation). .. versionadded:: 1.1 Returns ------- score : float or ndarray of floats The explained variance or ndarray if 'multioutput' is 'raw_values'. See Also -------- r2_score : Similar metric, but accounting for systematic offsets in prediction. Notes ----- This is not a symmetric function. Examples -------- >>> from sklearn.metrics import explained_variance_score >>> y_true = [3, -0.5, 2, 7] >>> y_pred = [2.5, 0.0, 2, 8] >>> explained_variance_score(y_true, y_pred) 0.957... >>> y_true = [[0.5, 1], [-1, 1], [7, -6]] >>> y_pred = [[0, 2], [-1, 2], [8, -5]] >>> explained_variance_score(y_true, y_pred, multioutput='uniform_average') 0.983... >>> y_true = [-2, -2, -2] >>> y_pred = [-2, -2, -2] >>> explained_variance_score(y_true, y_pred) 1.0 >>> explained_variance_score(y_true, y_pred, force_finite=False) nan >>> y_true = [-2, -2, -2] >>> y_pred = [-2, -2, -2 + 1e-8] >>> explained_variance_score(y_true, y_pred) 0.0 >>> explained_variance_score(y_true, y_pred, force_finite=False) -inf rrKrr-Nrzr{r@r>r|r*rv)rDrrOrPrr6r ) r<r=rGr>r|rB y_diff_avgrz y_true_avgr{s rCr r sh+= ++'FFFKFFM:::FVO]KKKJ &: %!+]IFMBBBJ*fz1a7UVWWWK *,q/!   #    rEc Lt||||\}}}t||||}t|||||\}}}}t|||t |dkr+d} t j| ttdS|t||}|dddf} nd} | | ||z dzzd } | | |t|d || z dzzd } t| | |j d |||| S)aX:math:`R^2` (coefficient of determination) regression score function. Best possible score is 1.0 and it can be negative (because the model can be arbitrarily worse). In the general case when the true y is non-constant, a constant model that always predicts the average y disregarding the input features would get a :math:`R^2` score of 0.0. In the particular case when ``y_true`` is constant, the :math:`R^2` score is not finite: it is either ``NaN`` (perfect predictions) or ``-Inf`` (imperfect predictions). To prevent such non-finite numbers to pollute higher-level experiments such as a grid search cross-validation, by default these cases are replaced with 1.0 (perfect predictions) or 0.0 (imperfect predictions) respectively. You can set ``force_finite`` to ``False`` to prevent this fix from happening. Note: when the prediction residuals have zero mean, the :math:`R^2` score is identical to the :func:`Explained Variance score `. Read more in the :ref:`User Guide `. Parameters ---------- y_true : array-like of shape (n_samples,) or (n_samples, n_outputs) Ground truth (correct) target values. y_pred : array-like of shape (n_samples,) or (n_samples, n_outputs) Estimated target values. sample_weight : array-like of shape (n_samples,), default=None Sample weights. multioutput : {'raw_values', 'uniform_average', 'variance_weighted'}, array-like of shape (n_outputs,) or None, default='uniform_average' Defines aggregating of multiple output scores. Array-like value defines weights used to average scores. Default is "uniform_average". 'raw_values' : Returns a full set of scores in case of multioutput input. 'uniform_average' : Scores of all outputs are averaged with uniform weight. 'variance_weighted' : Scores of all outputs are averaged, weighted by the variances of each individual output. .. versionchanged:: 0.19 Default value of multioutput is 'uniform_average'. force_finite : bool, default=True Flag indicating if ``NaN`` and ``-Inf`` scores resulting from constant data should be replaced with real numbers (``1.0`` if prediction is perfect, ``0.0`` otherwise). Default is ``True``, a convenient setting for hyperparameters' search procedures (e.g. grid search cross-validation). .. versionadded:: 1.1 Returns ------- z : float or ndarray of floats The :math:`R^2` score or ndarray of scores if 'multioutput' is 'raw_values'. Notes ----- This is not a symmetric function. Unlike most other scores, :math:`R^2` score may be negative (it need not actually be the square of a quantity R). This metric is not well-defined for single samples and will return a NaN value if n_samples is less than two. References ---------- .. [1] `Wikipedia entry on the Coefficient of determination `_ Examples -------- >>> from sklearn.metrics import r2_score >>> y_true = [3, -0.5, 2, 7] >>> y_pred = [2.5, 0.0, 2, 8] >>> r2_score(y_true, y_pred) 0.948... >>> y_true = [[0.5, 1], [-1, 1], [7, -6]] >>> y_pred = [[0, 2], [-1, 2], [8, -5]] >>> r2_score(y_true, y_pred, ... multioutput='variance_weighted') 0.938... >>> y_true = [1, 2, 3] >>> y_pred = [1, 2, 3] >>> r2_score(y_true, y_pred) 1.0 >>> y_true = [1, 2, 3] >>> y_pred = [2, 2, 2] >>> r2_score(y_true, y_pred) 0.0 >>> y_true = [1, 2, 3] >>> y_pred = [3, 2, 1] >>> r2_score(y_true, y_pred) -3.0 >>> y_true = [-2, -2, -2] >>> y_pred = [-2, -2, -2] >>> r2_score(y_true, y_pred) 1.0 >>> r2_score(y_true, y_pred, force_finite=False) nan >>> y_true = [-2, -2, -2] >>> y_pred = [-2, -2, -2 + 1e-8] >>> r2_score(y_true, y_pred) 0.0 >>> r2_score(y_true, y_pred, force_finite=False) -inf r))r,r*rz9R^2 score is not well-defined with less than two samples.nanNr,g?rrr)rMrLr*r-r)r rrDrrrhrirryrsumrrr6) r<r=rGr>r|r*r?device_r,msgweightrzr{s rCrr!suZ. {NB7 *&&-B O O OE%7 5R&&&"Avv{FFM:::FaI c1222U|| $]%@@@ qqq$w'v&Q 66Q??I&&&8FMbQQQQVWWW K +,q/!    rE)r<r=ct||d\}}}}|dkrtdtjtj||z S)al The max_error metric calculates the maximum residual error. Read more in the :ref:`User Guide `. Parameters ---------- y_true : array-like of shape (n_samples,) Ground truth (correct) target values. y_pred : array-like of shape (n_samples,) Estimated target values. Returns ------- max_error : float A positive floating point value (the best value is 0.0). Examples -------- >>> from sklearn.metrics import max_error >>> y_true = [3, 2, 7, 1] >>> y_pred = [4, 2, 7, 1] >>> max_error(y_true, y_pred) np.int64(1) Nr3z&Multioutput not supported in max_error)rDr7rOmaxrQ)r<r=rBr?s rCrrsXD!3664 H HFFFA )))ABBB 6"&&)) * **rEc|}|dkr|dtjtj|dd|z d|z d|z zz |tj|d|z zd|z z z tj|d|z d|z z zz}n|dkr ||z dz}n|dkrdt|||z |z |zz}n|dkr$dtj||z ||z zdz z}nhdtj|d|z d|z d|z zz |tj|d|z zd|z z z tj|d|z d|z z zz}tj||S)z&Mean Tweedie deviance regression loss.rrr-rN)rOpowerrarlogrP)r<r=rGrpdevs rC_mean_tweedie_deviancers A1uu HRZ**AE 2 2q1uQ6G HrxA...!a%8 9hvq1u%%Q/ 0  a1$ a5&11F:VCD a26&6/**Vf_`. Parameters ---------- y_true : array-like of shape (n_samples,) Ground truth (correct) target values. y_pred : array-like of shape (n_samples,) Estimated target values. sample_weight : array-like of shape (n_samples,), default=None Sample weights. power : float, default=0 Tweedie power parameter. Either power <= 0 or power >= 1. The higher `p` the less weight is given to extreme deviations between true and predicted targets. - power < 0: Extreme stable distribution. Requires: y_pred > 0. - power = 0 : Normal distribution, output corresponds to mean_squared_error. y_true and y_pred can be any real numbers. - power = 1 : Poisson distribution. Requires: y_true >= 0 and y_pred > 0. - 1 < p < 2 : Compound Poisson distribution. Requires: y_true >= 0 and y_pred > 0. - power = 2 : Gamma distribution. Requires: y_true > 0 and y_pred > 0. - power = 3 : Inverse Gaussian distribution. Requires: y_true > 0 and y_pred > 0. - otherwise : Positive stable distribution. Requires: y_true > 0 and y_pred > 0. Returns ------- loss : float A non-negative floating point value (the best value is 0.0). Examples -------- >>> from sklearn.metrics import mean_tweedie_deviance >>> y_true = [2, 0, 1, 4] >>> y_pred = [0.5, 0.5, 2., 2.] >>> mean_tweedie_deviance(y_true, y_pred, power=1) np.float64(1.4260...) Nrr3z2Multioutput not supported in mean_tweedie_deviancez'Mean Tweedie deviance error with power=z can only be used on rzstrictly positive y_pred.r-rz,non-negative y and strictly positive y_pred.zstrictly positive y and y_pred.r) rDrOr_float32r7rrnewaxisrnr)r<r=rGrrBr?messages rCr!r!sx!3RZ$<!!!FFFA)))MNNNFFM::: $]33 %aaam4 TTTTG qyy aK     DW'BBCC C D ! ea QJ     W&A+!2!2!4!4 WW'UUVV V W ! aK     J6Q;"3"3"5"5 JW'HHII I J !m5   rEr<r=rGrsc(t|||dS)apMean Poisson deviance regression loss. Poisson deviance is equivalent to the Tweedie deviance with the power parameter `power=1`. Read more in the :ref:`User Guide `. Parameters ---------- y_true : array-like of shape (n_samples,) Ground truth (correct) target values. Requires y_true >= 0. y_pred : array-like of shape (n_samples,) Estimated target values. Requires y_pred > 0. sample_weight : array-like of shape (n_samples,), default=None Sample weights. Returns ------- loss : float A non-negative floating point value (the best value is 0.0). Examples -------- >>> from sklearn.metrics import mean_poisson_deviance >>> y_true = [2, 0, 1, 4] >>> y_pred = [0.5, 0.5, 2., 2.] >>> mean_poisson_deviance(y_true, y_pred) np.float64(1.4260...) r-rr!rs rCr"r"zsP !}TU V V VVrEc(t|||dS)aMean Gamma deviance regression loss. Gamma deviance is equivalent to the Tweedie deviance with the power parameter `power=2`. It is invariant to scaling of the target variable, and measures relative errors. Read more in the :ref:`User Guide `. Parameters ---------- y_true : array-like of shape (n_samples,) Ground truth (correct) target values. Requires y_true > 0. y_pred : array-like of shape (n_samples,) Estimated target values. Requires y_pred > 0. sample_weight : array-like of shape (n_samples,), default=None Sample weights. Returns ------- loss : float A non-negative floating point value (the best value is 0.0). Examples -------- >>> from sklearn.metrics import mean_gamma_deviance >>> y_true = [2, 0.5, 1, 4] >>> y_pred = [0.5, 0.5, 2., 2.] >>> mean_gamma_deviance(y_true, y_pred) np.float64(1.0568...) rrrrs rCr#r#sR !}TU V V VVrEct||dtjtjg\}}}}|dkrt dt |dkr+d}t j|ttdStj |tj |}}t||||}tj || }t||||} d || z z S) aW :math:`D^2` regression score function, fraction of Tweedie deviance explained. Best possible score is 1.0 and it can be negative (because the model can be arbitrarily worse). A model that always uses the empirical mean of `y_true` as constant prediction, disregarding the input features, gets a D^2 score of 0.0. Read more in the :ref:`User Guide `. .. versionadded:: 1.0 Parameters ---------- y_true : array-like of shape (n_samples,) Ground truth (correct) target values. y_pred : array-like of shape (n_samples,) Estimated target values. sample_weight : array-like of shape (n_samples,), default=None Sample weights. power : float, default=0 Tweedie power parameter. Either power <= 0 or power >= 1. The higher `p` the less weight is given to extreme deviations between true and predicted targets. - power < 0: Extreme stable distribution. Requires: y_pred > 0. - power = 0 : Normal distribution, output corresponds to r2_score. y_true and y_pred can be any real numbers. - power = 1 : Poisson distribution. Requires: y_true >= 0 and y_pred > 0. - 1 < p < 2 : Compound Poisson distribution. Requires: y_true >= 0 and y_pred > 0. - power = 2 : Gamma distribution. Requires: y_true > 0 and y_pred > 0. - power = 3 : Inverse Gaussian distribution. Requires: y_true > 0 and y_pred > 0. - otherwise : Positive stable distribution. Requires: y_true > 0 and y_pred > 0. Returns ------- z : float or ndarray of floats The D^2 score. Notes ----- This is not a symmetric function. Like R^2, D^2 score may be negative (it need not actually be the square of a quantity D). This metric is not well-defined for single samples and will return a NaN value if n_samples is less than two. References ---------- .. [1] Eq. (3.11) of Hastie, Trevor J., Robert Tibshirani and Martin J. Wainwright. "Statistical Learning with Sparsity: The Lasso and Generalizations." (2015). https://hastie.su.domains/StatLearnSparsity/ Examples -------- >>> from sklearn.metrics import d2_tweedie_score >>> y_true = [0.5, 1, 2.5, 7] >>> y_pred = [1, 1, 5, 3.5] >>> d2_tweedie_score(y_true, y_pred) np.float64(0.285...) >>> d2_tweedie_score(y_true, y_pred, power=1) np.float64(0.487...) >>> d2_tweedie_score(y_true, y_pred, power=2) np.float64(0.630...) >>> d2_tweedie_score(y_true, y_true, power=2) np.float64(1.0) Nrr3z-Multioutput not supported in d2_tweedie_scorer9D^2 score is not well-defined with less than two samples.rrrNr-)rDrOr_rr7rrhrirrysqueezer!rPr) r<r=rGrrBr?rrzy_avgr{s rCr$r$sr!3RZ$<!!!FFFA)))HIIIFaI c1222U||Z''F););FF%m5I Jv} 5 5 5E(]%K y;& &&rEc8t|||\}}}}t|||t|dkr+d}tj|t t dSt||||d}|=tj tj ||dzd t|d f}nGt||}tj t|||dz t|d f}t||||d} |dk} | dk} | | z} tj|jd } d || | | z z | | <d | | | z<t!|t"r |dkr| Sd}n|}tj| | S)u :math:`D^2` regression score function, fraction of pinball loss explained. Best possible score is 1.0 and it can be negative (because the model can be arbitrarily worse). A model that always uses the empirical alpha-quantile of `y_true` as constant prediction, disregarding the input features, gets a :math:`D^2` score of 0.0. Read more in the :ref:`User Guide `. .. versionadded:: 1.1 Parameters ---------- y_true : array-like of shape (n_samples,) or (n_samples, n_outputs) Ground truth (correct) target values. y_pred : array-like of shape (n_samples,) or (n_samples, n_outputs) Estimated target values. sample_weight : array-like of shape (n_samples,), default=None Sample weights. alpha : float, default=0.5 Slope of the pinball deviance. It determines the quantile level alpha for which the pinball deviance and also D2 are optimal. The default `alpha=0.5` is equivalent to `d2_absolute_error_score`. multioutput : {'raw_values', 'uniform_average'} or array-like of shape (n_outputs,), default='uniform_average' Defines aggregating of multiple output values. Array-like value defines weights used to average scores. 'raw_values' : Returns a full set of errors in case of multioutput input. 'uniform_average' : Scores of all outputs are averaged with uniform weight. Returns ------- score : float or ndarray of floats The :math:`D^2` score with a pinball deviance or ndarray of scores if `multioutput='raw_values'`. Notes ----- Like :math:`R^2`, :math:`D^2` score may be negative (it need not actually be the square of a quantity D). This metric is not well-defined for a single point and will return a NaN value if n_samples is less than two. References ---------- .. [1] Eq. (7) of `Koenker, Roger; Machado, José A. F. (1999). "Goodness of Fit and Related Inference Processes for Quantile Regression" `_ .. [2] Eq. (3.11) of Hastie, Trevor J., Robert Tibshirani and Martin J. Wainwright. "Statistical Learning with Sparsity: The Lasso and Generalizations." (2015). https://hastie.su.domains/StatLearnSparsity/ Examples -------- >>> from sklearn.metrics import d2_pinball_score >>> y_true = [1, 2, 3] >>> y_pred = [1, 3, 3] >>> d2_pinball_score(y_true, y_pred) np.float64(0.5) >>> d2_pinball_score(y_true, y_pred, alpha=0.9) np.float64(0.772...) >>> d2_pinball_score(y_true, y_pred, alpha=0.1) np.float64(-1.045...) >>> d2_pinball_score(y_true, y_true, alpha=0.1) np.float64(1.0) rrrr/rWNdr)qrMr-)rG percentilerwrN)rDrrrhrirryrrOtilerr;rrrxr6r9r:rP)r<r=rGrUr>rBrrz y_quantiler{rr}rr~rs rCr%r%Bsx+= ++'FFFKFFM:::FaI c1222U||!# IW M&ECKa 8 8 83v;;:J  -]FCC W m    [[!    $# K"Q%*#&99KGFLO,,M!"i &<{;?W&W!XM+>AM#':&::;+s##" , & & KK! :m[ 9 9 99rEc*t|||d|S)a :math:`D^2` regression score function, fraction of absolute error explained. Best possible score is 1.0 and it can be negative (because the model can be arbitrarily worse). A model that always uses the empirical median of `y_true` as constant prediction, disregarding the input features, gets a :math:`D^2` score of 0.0. Read more in the :ref:`User Guide `. .. versionadded:: 1.1 Parameters ---------- y_true : array-like of shape (n_samples,) or (n_samples, n_outputs) Ground truth (correct) target values. y_pred : array-like of shape (n_samples,) or (n_samples, n_outputs) Estimated target values. sample_weight : array-like of shape (n_samples,), default=None Sample weights. multioutput : {'raw_values', 'uniform_average'} or array-like of shape (n_outputs,), default='uniform_average' Defines aggregating of multiple output values. Array-like value defines weights used to average scores. 'raw_values' : Returns a full set of errors in case of multioutput input. 'uniform_average' : Scores of all outputs are averaged with uniform weight. Returns ------- score : float or ndarray of floats The :math:`D^2` score with an absolute error deviance or ndarray of scores if 'multioutput' is 'raw_values'. Notes ----- Like :math:`R^2`, :math:`D^2` score may be negative (it need not actually be the square of a quantity D). This metric is not well-defined for single samples and will return a NaN value if n_samples is less than two. References ---------- .. [1] Eq. (3.11) of Hastie, Trevor J., Robert Tibshirani and Martin J. Wainwright. "Statistical Learning with Sparsity: The Lasso and Generalizations." (2015). https://hastie.su.domains/StatLearnSparsity/ Examples -------- >>> from sklearn.metrics import d2_absolute_error_score >>> y_true = [3, -0.5, 2, 7] >>> y_pred = [2.5, 0.0, 2, 8] >>> d2_absolute_error_score(y_true, y_pred) np.float64(0.764...) >>> y_true = [[0.5, 1], [-1, 1], [7, -6]] >>> y_pred = [[0, 2], [-1, 2], [8, -5]] >>> d2_absolute_error_score(y_true, y_pred, multioutput='uniform_average') np.float64(0.691...) >>> d2_absolute_error_score(y_true, y_pred, multioutput='raw_values') array([0.8125 , 0.57142857]) >>> y_true = [1, 2, 3] >>> y_pred = [1, 2, 3] >>> d2_absolute_error_score(y_true, y_pred) np.float64(1.0) >>> y_true = [1, 2, 3] >>> y_pred = [2, 2, 2] >>> d2_absolute_error_score(y_true, y_pred) np.float64(0.0) >>> y_true = [1, 2, 3] >>> y_pred = [3, 2, 1] >>> d2_absolute_error_score(y_true, y_pred) np.float64(-1.0) rVrW)r%rFs rCr&r&s'~ m3K   rE)r'N)2__doc__rhnumbersrnumpyrO scipy.specialr exceptionsrutils._array_apirrr r r utils._param_validationr r rr utils.statsrutils.validationrrrrr__ALL__rDrrrrrrrrrr rrrr!r"r#r$r%r&rErCrsL ://////TSSSSSSSSSSS......   *J/J/J/J/Z..&-" L2C#DEE|T  #'&*7HC:C:C:C:C:L..&-(4Af5556" L2C#DEE|T #'   &*BSM:M:M:M:  M:`..&-" L2C#DEE|T  #'&*7HS:S:S:S:S:l..&-" L2C#DEE|TF::|n5566 B #'   !  ]:]:]:]:  ]:@..&-" L2C#DEE|T  #'&*7H>:>:>:>:>:B..&-" L2C#DEE|TF::|n5566 B #'   !  cccc  cL..&-" L2C#DEE|T  #'&*7H=====@.." L2C#DEE|T&-  #'$5DI:I:I:I:I:X///d..&- JMMM N N  #   #'   "! }}}}  }@..&- JMMM N N   #   #'   $! cccc  cL..#' +++B222:..&- HT47 3 3 3 HT1d6 2 2 2 #'   <@qQQQQ  Qh..&- #' <@ W W W W WF..&- #' :>!W!W!W!W!WH..&- HT47 3 3 3 HT1d6 2 2 2 #'   7;!b'b'b'b'  b'J..&-(4Af5556 J &78 9 9   #'   &*BSH:H:H:H:  H:V..&- J &78 9 9  #'   &*7HUUUU  UUUrE