U 2dp@sdZddlmZddlZddlmZddlmZddlm Z ddl Z ddl m Z ddl mZdd lmZd d lmZmZmZmZmZmZd d lmZmZd d lmZmZmZd dlm Z d dl!m"Z"m#Z#d dl$m%Z%m&Z&m'Z'd dl(m)Z)m*Z*m+Z+m,Z,m-Z-d dlm.Z.d dl/m0Z0d dl1m2Z2d dl3m4Z4m5Z5d dl6m7Z7d dl8m9Z9GdddeeeZ:d0ddZ;ddZGd"d#d#Z?d2d$d%Z@Gd&d'd'eeZAdd(d)d*d+d,d-ZBGd.d/d/ZCdS)3z'Calibration of predicted probabilities.)IntegralN) signature)partial)log)expit)xlogy) fmin_bfgs) BaseEstimatorClassifierMixinRegressorMixincloneMetaEstimatorMixin is_classifier)label_binarize LabelEncoder) column_or_1d indexablecheck_matplotlib_support)check_classification_targets)delayedParallel) StrOptions HasMethodsHidden)_check_fit_params_check_sample_weight _num_samplescheck_consistent_lengthcheck_is_fitted)_safe_indexing)IsotonicRegression) LinearSVC)check_cvcross_val_predict)_check_pos_label_consistency) _get_responsec @seZdZUdZeddgeddgdgeddhgded hgedgd geddgeddgdeed hgd Ze e d <dddddd dddZ dddZ ddZ ddZddZdS)CalibratedClassifierCVa7Probability calibration with isotonic regression or logistic regression. This class uses cross-validation to both estimate the parameters of a classifier and subsequently calibrate a classifier. With default `ensemble=True`, for each cv split it fits a copy of the base estimator to the training subset, and calibrates it using the testing subset. For prediction, predicted probabilities are averaged across these individual calibrated classifiers. When `ensemble=False`, cross-validation is used to obtain unbiased predictions, via :func:`~sklearn.model_selection.cross_val_predict`, which are then used for calibration. For prediction, the base estimator, trained using all the data, is used. This is the method implemented when `probabilities=True` for :mod:`sklearn.svm` estimators. Already fitted classifiers can be calibrated via the parameter `cv="prefit"`. In this case, no cross-validation is used and all provided data is used for calibration. The user has to take care manually that data for model fitting and calibration are disjoint. The calibration is based on the :term:`decision_function` method of the `estimator` if it exists, else on :term:`predict_proba`. Read more in the :ref:`User Guide `. Parameters ---------- estimator : estimator instance, default=None The classifier whose output need to be calibrated to provide more accurate `predict_proba` outputs. The default classifier is a :class:`~sklearn.svm.LinearSVC`. .. versionadded:: 1.2 method : {'sigmoid', 'isotonic'}, default='sigmoid' The method to use for calibration. Can be 'sigmoid' which corresponds to Platt's method (i.e. a logistic regression model) or 'isotonic' which is a non-parametric approach. It is not advised to use isotonic calibration with too few calibration samples ``(<<1000)`` since it tends to overfit. cv : int, cross-validation generator, iterable or "prefit", default=None Determines the cross-validation splitting strategy. Possible inputs for cv are: - None, to use the default 5-fold cross-validation, - integer, to specify the number of folds. - :term:`CV splitter`, - An iterable yielding (train, test) splits as arrays of indices. For integer/None inputs, if ``y`` is binary or multiclass, :class:`~sklearn.model_selection.StratifiedKFold` is used. If ``y`` is neither binary nor multiclass, :class:`~sklearn.model_selection.KFold` is used. Refer to the :ref:`User Guide ` for the various cross-validation strategies that can be used here. If "prefit" is passed, it is assumed that `estimator` has been fitted already and all data is used for calibration. .. versionchanged:: 0.22 ``cv`` default value if None changed from 3-fold to 5-fold. n_jobs : int, default=None Number of jobs to run in parallel. ``None`` means 1 unless in a :obj:`joblib.parallel_backend` context. ``-1`` means using all processors. Base estimator clones are fitted in parallel across cross-validation iterations. Therefore parallelism happens only when `cv != "prefit"`. See :term:`Glossary ` for more details. .. versionadded:: 0.24 ensemble : bool, default=True Determines how the calibrator is fitted when `cv` is not `'prefit'`. Ignored if `cv='prefit'`. If `True`, the `estimator` is fitted using training data, and calibrated using testing data, for each `cv` fold. The final estimator is an ensemble of `n_cv` fitted classifier and calibrator pairs, where `n_cv` is the number of cross-validation folds. The output is the average predicted probabilities of all pairs. If `False`, `cv` is used to compute unbiased predictions, via :func:`~sklearn.model_selection.cross_val_predict`, which are then used for calibration. At prediction time, the classifier used is the `estimator` trained on all the data. Note that this method is also internally implemented in :mod:`sklearn.svm` estimators with the `probabilities=True` parameter. .. versionadded:: 0.24 base_estimator : estimator instance This parameter is deprecated. Use `estimator` instead. .. deprecated:: 1.2 The parameter `base_estimator` is deprecated in 1.2 and will be removed in 1.4. Use `estimator` instead. Attributes ---------- classes_ : ndarray of shape (n_classes,) The class labels. n_features_in_ : int Number of features seen during :term:`fit`. Only defined if the underlying estimator exposes such an attribute when fit. .. versionadded:: 0.24 feature_names_in_ : ndarray of shape (`n_features_in_`,) Names of features seen during :term:`fit`. Only defined if the underlying estimator exposes such an attribute when fit. .. versionadded:: 1.0 calibrated_classifiers_ : list (len() equal to cv or 1 if `cv="prefit"` or `ensemble=False`) The list of classifier and calibrator pairs. - When `cv="prefit"`, the fitted `estimator` and fitted calibrator. - When `cv` is not "prefit" and `ensemble=True`, `n_cv` fitted `estimator` and calibrator pairs. `n_cv` is the number of cross-validation folds. - When `cv` is not "prefit" and `ensemble=False`, the `estimator`, fitted on all the data, and fitted calibrator. .. versionchanged:: 0.24 Single calibrated classifier case when `ensemble=False`. See Also -------- calibration_curve : Compute true and predicted probabilities for a calibration curve. References ---------- .. [1] Obtaining calibrated probability estimates from decision trees and naive Bayesian classifiers, B. Zadrozny & C. Elkan, ICML 2001 .. [2] Transforming Classifier Scores into Accurate Multiclass Probability Estimates, B. Zadrozny & C. Elkan, (KDD 2002) .. [3] Probabilistic Outputs for Support Vector Machines and Comparisons to Regularized Likelihood Methods, J. Platt, (1999) .. [4] Predicting Good Probabilities with Supervised Learning, A. Niculescu-Mizil & R. Caruana, ICML 2005 Examples -------- >>> from sklearn.datasets import make_classification >>> from sklearn.naive_bayes import GaussianNB >>> from sklearn.calibration import CalibratedClassifierCV >>> X, y = make_classification(n_samples=100, n_features=2, ... n_redundant=0, random_state=42) >>> base_clf = GaussianNB() >>> calibrated_clf = CalibratedClassifierCV(base_clf, cv=3) >>> calibrated_clf.fit(X, y) CalibratedClassifierCV(...) >>> len(calibrated_clf.calibrated_classifiers_) 3 >>> calibrated_clf.predict_proba(X)[:5, :] array([[0.110..., 0.889...], [0.072..., 0.927...], [0.928..., 0.071...], [0.928..., 0.071...], [0.071..., 0.928...]]) >>> from sklearn.model_selection import train_test_split >>> X, y = make_classification(n_samples=100, n_features=2, ... n_redundant=0, random_state=42) >>> X_train, X_calib, y_train, y_calib = train_test_split( ... X, y, random_state=42 ... ) >>> base_clf = GaussianNB() >>> base_clf.fit(X_train, y_train) GaussianNB() >>> calibrated_clf = CalibratedClassifierCV(base_clf, cv="prefit") >>> calibrated_clf.fit(X_calib, y_calib) CalibratedClassifierCV(...) >>> len(calibrated_clf.calibrated_classifiers_) 1 >>> calibrated_clf.predict_proba([[-0.5, 0.5]]) array([[0.936..., 0.063...]]) fit predict_probadecision_functionNisotonicsigmoidZ cv_objectprefitboolean deprecated estimatormethodcvn_jobsensemblebase_estimator_parameter_constraintsT)r2r3r4r5r6cCs(||_||_||_||_||_||_dSNr0)selfr1r2r3r4r5r6r:7/tmp/pip-unpacked-wheel-zrfo1fqw/sklearn/calibration.py__init__s zCalibratedClassifierCV.__init__c stt\dk r0tD]}t|q8jdkrxjdk rdtdt dt jnjdkrt ddg_ jdkrtjdgd jj_t\}}tj}t|||} t| jj} j | nt} | j_tj}tjj} d | kdk rdsdtj} t d | d tjtrzjntjd rjj ndrt!"fddjDrtdddt#jdd}j$r"t%j&d}|fdd|'D_ nt(}t|\}}dk rNrNd indt)t*|||j&d}t|||} dk rr|jdn |t|| jj} j | j dj}t|dr|j+_+t|dr|j,_,S)aOFit the calibrated model. Parameters ---------- X : array-like of shape (n_samples, n_features) Training data. y : array-like of shape (n_samples,) Target values. sample_weight : array-like of shape (n_samples,), default=None Sample weights. If None, then samples are equally weighted. **fit_params : dict Parameters to pass to the `fit` method of the underlying classifier. Returns ------- self : object Returns an instance of self. Nr/ziBoth `base_estimator` and `estimator` are set. Only set `estimator` since `base_estimator` is deprecated.zV`base_estimator` was renamed to `estimator` in version 1.2 and will be removed in 1.4.r)Z random_stater-classes_) attributes sample_weightzSince aW does not appear to accept sample_weight, sample weights will only be used for the calibration itself. This can be caused by a limitation of the current scikit-learn API. See the following issue for more details: https://github.com/scikit-learn/scikit-learn/issues/21134. Be warned that the result of the calibration is likely to be incorrect.n_splitscsg|]}t|kkqSr:)npsum).0class_)n_foldsyr:r; sz.CalibratedClassifierCV.fit..z Requesting z.-fold cross-validation but provided less than z! examples for at least one class.T) classifier)r4c 3s@|]8\}}tttf||jjdVqdS))traintestr2classes supports_swr?N)r_fit_classifier_calibrator_pairr r2r=)rCrIrJ)Xr1 fit_paramsr?r9rLrFr:r; s  z-CalibratedClassifierCV.fit..)r1rNrFr3r2r4rOr?n_features_in_feature_names_in_)-Z_validate_paramsrrrvaluesrr6r1 ValueErrorwarningswarn FutureWarningr"calibrated_classifiers_r3rr=_get_prediction_methodlen_compute_predictions_fit_calibratorr2appendrr(r parameterstype__name__ isinstanceinthasattrr@rAanyr#r5rr4splitr rr$rRrS)r9rNrFr?rOZsample_aligned_params pred_method method_name n_classes predictionscalibrated_classifierZlabel_encoder_Zfit_parametersestimator_namer3parallelZthis_estimator_Z first_clfr:)rNr1rOrEr?r9rLrFr;r(s                            zCalibratedClassifierCV.fitcCsPt|tt|t|jf}|jD]}||}||7}q&|t|j}|S)aCalibrated probabilities of classification. This function returns calibrated probabilities of classification according to each class on an array of test vectors X. Parameters ---------- X : array-like of shape (n_samples, n_features) The samples, as accepted by `estimator.predict_proba`. Returns ------- C : ndarray of shape (n_samples, n_classes) The predicted probas. )rrAzerosrr[r=rYr))r9rNZ mean_probarkprobar:r:r;r)s   z$CalibratedClassifierCV.predict_probacCs"t||jtj||ddS)aPredict the target of new samples. The predicted class is the class that has the highest probability, and can thus be different from the prediction of the uncalibrated classifier. Parameters ---------- X : array-like of shape (n_samples, n_features) The samples, as accepted by `estimator.predict`. Returns ------- C : ndarray of shape (n_samples,) The predicted class. r Zaxis)rr=rAZargmaxr))r9rNr:r:r;predictszCalibratedClassifierCV.predictcCs dddiiS)NZ _xfail_checksZcheck_sample_weights_invariancezDue to the cross-validation and sample ordering, removing a sample is not strictly equal to putting is weight to zero. Specific unit tests are added for CalibratedClassifierCV specifically.r:)r9r:r:r; _more_tagss z!CalibratedClassifierCV._more_tags)N)N)ra __module__ __qualname____doc__rrrrr7dict__annotations__r<r(r)rrrsr:r:r:r;r'7s: A         /r'c Kst|| |} t||t||} } t||t||} }|dk rh|rht||}|j| | fd|i| n|j| | f| t|}t|\}}t||| |}|dkrdnt||}t||||||d}|S)ayFit a classifier/calibration pair on a given train/test split. Fit the classifier on the train set, compute its predictions on the test set and use the predictions as input to fit the calibrator along with the test labels. Parameters ---------- estimator : estimator instance Cloned base estimator. X : array-like, shape (n_samples, n_features) Sample data. y : array-like, shape (n_samples,) Targets. train : ndarray, shape (n_train_indices,) Indices of the training subset. test : ndarray, shape (n_test_indices,) Indices of the testing subset. supports_sw : bool Whether or not the `estimator` supports sample weights. method : {'sigmoid', 'isotonic'} Method to use for calibration. classes : ndarray, shape (n_classes,) The target classes. sample_weight : array-like, default=None Sample weights for `X`. **fit_params : dict Parameters to pass to the `fit` method of the underlying classifier. Returns ------- calibrated_classifier : _CalibratedClassifier instance Nr?rQ)rr r(r[rZr\r])r1rNrFrIrJrLr2rKr?rOZfit_params_trainZX_trainZy_trainZX_testZy_testZsw_trainrirgrhrjZsw_testrkr:r:r;rMs(7    rMcCs<t|drt|d}|dfSt|dr8t|d}|dfSdS)aReturn prediction method. `decision_function` method of `clf` returned, if it exists, otherwise `predict_proba` method returned. Parameters ---------- clf : Estimator instance Fitted classifier to obtain the prediction method from. Returns ------- prediction_method : callable The prediction method. method_name : str The name of the prediction method. r*r)N)rdgetattr)clfr2r:r:r;rZNs     rZcCsh||d}|dkr0|jdkrd|ddtjf}n4|dkrV|dkrd|ddddf}ntd||S)a#Return predictions for `X` and reshape binary outputs to shape (n_samples, 1). Parameters ---------- pred_method : callable Prediction method. method_name: str Name of the prediction method X : array-like or None Data used to obtain predictions. n_classes : int Number of classes present. Returns ------- predictions : array-like, shape (X.shape[0], len(clf.classes_)) The predictions. Note if there are 2 classes, array is of shape (X.shape[0], 1). )rNr*r Nr)zInvalid prediction method: )ndimrAnewaxisrU)rgrhrNrirjr:r:r;r\is  r\cCst||d}t|}||j}g} t||jD]F\} } |dkrPtdd} nt} | | |dd| f|| | q4t || ||d} | S)aFit calibrator(s) and return a `_CalibratedClassifier` instance. `n_classes` (i.e. `len(clf.classes_)`) calibrators are fitted. However, if `n_classes` equals 2, one calibrator is fitted. Parameters ---------- clf : estimator instance Fitted classifier. predictions : array-like, shape (n_samples, n_classes) or (n_samples, 1) when binary. Raw predictions returned by the un-calibrated base classifier. y : array-like, shape (n_samples,) The targets. classes : ndarray, shape (n_classes,) All the prediction classes. method : {'sigmoid', 'isotonic'} The method to use for calibration. sample_weight : ndarray, shape (n_samples,), default=None Sample weights. If None, then samples are equally weighted. Returns ------- pipeline : _CalibratedClassifier instance )rKr+Zclip)Z out_of_boundsN)r2rK) rrr( transformr=zipTr!_SigmoidCalibrationr^_CalibratedClassifier)rzrjrFrKr2r?Y label_encoderpos_class_indices calibrators class_idx this_pred calibratorZpipeliner:r:r;r]s     r]c@s&eZdZdZddddZddZdS) ra$Pipeline-like chaining a fitted classifier and its fitted calibrators. Parameters ---------- estimator : estimator instance Fitted classifier. calibrators : list of fitted estimator instances List of fitted calibrators (either 'IsotonicRegression' or '_SigmoidCalibration'). The number of calibrators equals the number of classes. However, if there are 2 classes, the list contains only one fitted calibrator. classes : array-like of shape (n_classes,) All the prediction classes. method : {'sigmoid', 'isotonic'}, default='sigmoid' The method to use for calibration. Can be 'sigmoid' which corresponds to Platt's method or 'isotonic' which is a non-parametric approach based on isotonic regression. r,)r2cCs||_||_||_||_dSr8)r1rrKr2)r9r1rrKr2r:r:r;r<sz_CalibratedClassifier.__init__cCst|j}t|j\}}t||||}t|j}||jj}t t ||f}t ||j |jD]0\} } } |dkr~| d7} | | |dd| f<qd|dkrd|dddf|dddf<nBt j|ddddt jf} t |d|} t j|| | | dkd}d|d|k|dk@<|S) aCalculate calibrated probabilities. Calculates classification calibrated probabilities for each class, in a one-vs-all manner, for `X`. Parameters ---------- X : ndarray of shape (n_samples, n_features) The sample data. Returns ------- proba : array, shape (n_samples, n_classes) The predicted probabilities. Can be exact zeros. r{r N?rrq)outwheregrZ| ?)r[rKrZr1r\rr(r~r=rArorrrrrrrBr}Z full_likedivide)r9rNrirgrhrjrrrprrr denominatorZ uniform_probar:r:r;r)s4 "z#_CalibratedClassifier.predict_probaN)rartrurvr<r)r:r:r:r;rsrc st|}t|}||dk}dk r@|}|}ntt|}|jd|}tj|tjd|d|d|dk<d|d|dk<dfdd}fdd }td t|d|dg}t |||d d } | d| d fS)aNProbability Calibration with sigmoid method (Platt 2000) Parameters ---------- predictions : ndarray of shape (n_samples,) The decision function or predict proba for the samples. y : ndarray of shape (n_samples,) The targets. sample_weight : array-like of shape (n_samples,), default=None Sample weights. If None, then samples are equally weighted. Returns ------- a : float The slope. b : float The intercept. References ---------- Platt, "Probabilistic Outputs for Support Vector Machines" rN)Zdtyperg@csTt|d|d }t|td| }dk rH|S|SdS)Nrr r)rrrB)ABPZlossFrZT1r?r:r; objective>s  z'_sigmoid_calibration..objectivecsVt|d|d }|}dk r2|9}t|}t|}t||gS)Nrr )rrAdotrBarray)rrZ TEP_minus_T1PZdAZdB)rrr?r:r;gradGs  z"_sigmoid_calibration..gradF)Zfprimedispr ) rrBfloatrAshapeZ zeros_likeZfloat64rrr) rjrFr?Zmask_negative_samplesZprior0Zprior1rrZAB0ZAB_r:rr;_sigmoid_calibrations$   rc@s"eZdZdZdddZddZdS)rzSigmoid regression model. Attributes ---------- a_ : float The slope. b_ : float The intercept. NcCs6t|}t|}t||\}}t|||\|_|_|S)aFit the model using X, y as training data. Parameters ---------- X : array-like of shape (n_samples,) Training data. y : array-like of shape (n_samples,) Training target. sample_weight : array-like of shape (n_samples,), default=None Sample weights. If None, then samples are equally weighted. Returns ------- self : object Returns an instance of self. )rrra_b_)r9rNrFr?r:r:r;r(bs z_SigmoidCalibration.fitcCst|}t|j||j S)aPredict new data by linear interpolation. Parameters ---------- T : array-like of shape (n_samples,) Data to predict from. Returns ------- T_ : ndarray of shape (n_samples,) The predicted data. )rrrr)r9rr:r:r;rr|s z_SigmoidCalibration.predict)N)rartrurvr(rrr:r:r:r;rVs rr/uniform) pos_label normalizen_binsstrategycCstt|}t|}t||t||}|dkrXtdt|rX||||}|dksp|dkrxtdt |}t |dkrtd|d||k}|d krt dd|d}t ||d }n$|d krt d d |d}ntdt |dd|} t j| |t |d} t j| |t |d} t j| t |d} | dk} | | | | }| | | | }||fS)a Compute true and predicted probabilities for a calibration curve. The method assumes the inputs come from a binary classifier, and discretize the [0, 1] interval into bins. Calibration curves may also be referred to as reliability diagrams. Read more in the :ref:`User Guide `. Parameters ---------- y_true : array-like of shape (n_samples,) True targets. y_prob : array-like of shape (n_samples,) Probabilities of the positive class. pos_label : int or str, default=None The label of the positive class. .. versionadded:: 1.1 normalize : bool, default="deprecated" Whether y_prob needs to be normalized into the [0, 1] interval, i.e. is not a proper probability. If True, the smallest value in y_prob is linearly mapped onto 0 and the largest one onto 1. .. deprecated:: 1.1 The normalize argument is deprecated in v1.1 and will be removed in v1.3. Explicitly normalizing `y_prob` will reproduce this behavior, but it is recommended that a proper probability is used (i.e. a classifier's `predict_proba` positive class). n_bins : int, default=5 Number of bins to discretize the [0, 1] interval. A bigger number requires more data. Bins with no samples (i.e. without corresponding values in `y_prob`) will not be returned, thus the returned arrays may have less than `n_bins` values. strategy : {'uniform', 'quantile'}, default='uniform' Strategy used to define the widths of the bins. uniform The bins have identical widths. quantile The bins have the same number of samples and depend on `y_prob`. Returns ------- prob_true : ndarray of shape (n_bins,) or smaller The proportion of samples whose class is the positive class, in each bin (fraction of positives). prob_pred : ndarray of shape (n_bins,) or smaller The mean predicted probability in each bin. References ---------- Alexandru Niculescu-Mizil and Rich Caruana (2005) Predicting Good Probabilities With Supervised Learning, in Proceedings of the 22nd International Conference on Machine Learning (ICML). See section 4 (Qualitative Analysis of Predictions). Examples -------- >>> import numpy as np >>> from sklearn.calibration import calibration_curve >>> y_true = np.array([0, 0, 0, 0, 1, 1, 1, 1, 1]) >>> y_pred = np.array([0.1, 0.2, 0.3, 0.4, 0.65, 0.7, 0.8, 0.9, 1.]) >>> prob_true, prob_pred = calibration_curve(y_true, y_pred, n_bins=3) >>> prob_true array([0. , 0.5, 1. ]) >>> prob_pred array([0.2 , 0.525, 0.85 ]) r/a:The normalize argument is deprecated in v1.1 and will be removed in v1.3. Explicitly normalizing y_prob will reproduce this behavior, but it is recommended that a proper probability is used (i.e. a classifier's `predict_proba` positive class or `decision_function` output calibrated with `CalibratedClassifierCV`).rr z!y_prob has values outside [0, 1].r{z9Only binary classification is supported. Provided labels .ZquantiledrrrzSInvalid entry to 'strategy' input. Strategy must be either 'quantile' or 'uniform'.)weights minlength)r)rrr%rVrWrXminmaxrUrAuniquer[ZlinspaceZ percentileZ searchsortedZbincount)y_truey_probrrrrlabelsZ quantilesZbinsZbinidsZbin_sumsZbin_trueZ bin_totalZnonzero prob_true prob_predr:r:r;calibration_curvesFT     rc@sjeZdZdZdddddZdddddd Zed d ddddd d dZed d ddddd ddZdS)CalibrationDisplaya Calibration curve (also known as reliability diagram) visualization. It is recommended to use :func:`~sklearn.calibration.CalibrationDisplay.from_estimator` or :func:`~sklearn.calibration.CalibrationDisplay.from_predictions` to create a `CalibrationDisplay`. All parameters are stored as attributes. Read more about calibration in the :ref:`User Guide ` and more about the scikit-learn visualization API in :ref:`visualizations`. .. versionadded:: 1.0 Parameters ---------- prob_true : ndarray of shape (n_bins,) The proportion of samples whose class is the positive class (fraction of positives), in each bin. prob_pred : ndarray of shape (n_bins,) The mean predicted probability in each bin. y_prob : ndarray of shape (n_samples,) Probability estimates for the positive class, for each sample. estimator_name : str, default=None Name of estimator. If None, the estimator name is not shown. pos_label : str or int, default=None The positive class when computing the calibration curve. By default, `estimators.classes_[1]` is considered as the positive class. .. versionadded:: 1.1 Attributes ---------- line_ : matplotlib Artist Calibration curve. ax_ : matplotlib Axes Axes with calibration curve. figure_ : matplotlib Figure Figure containing the curve. See Also -------- calibration_curve : Compute true and predicted probabilities for a calibration curve. CalibrationDisplay.from_predictions : Plot calibration curve using true and predicted labels. CalibrationDisplay.from_estimator : Plot calibration curve using an estimator and data. Examples -------- >>> from sklearn.datasets import make_classification >>> from sklearn.model_selection import train_test_split >>> from sklearn.linear_model import LogisticRegression >>> from sklearn.calibration import calibration_curve, CalibrationDisplay >>> X, y = make_classification(random_state=0) >>> X_train, X_test, y_train, y_test = train_test_split( ... X, y, random_state=0) >>> clf = LogisticRegression(random_state=0) >>> clf.fit(X_train, y_train) LogisticRegression(random_state=0) >>> y_prob = clf.predict_proba(X_test)[:, 1] >>> prob_true, prob_pred = calibration_curve(y_test, y_prob, n_bins=10) >>> disp = CalibrationDisplay(prob_true, prob_pred, y_prob) >>> disp.plot() <...> N)rlrcCs"||_||_||_||_||_dSr8rrrrlr)r9rrrrlrr:r:r;r<_s zCalibrationDisplay.__init__T)axnameref_linec Kstdddlm}|dkr(|\}}|dkr6|jn|}|jdk rRd|jdnd}i}|dk rj||d<|jf|d} | |d k} |r| s|jdd gdd gd | d |j|j |j d f|d|_ |j d dd|} d|} |j | | d||_|j|_|S)aTPlot visualization. Extra keyword arguments will be passed to :func:`matplotlib.pyplot.plot`. Parameters ---------- ax : Matplotlib Axes, default=None Axes object to plot on. If `None`, a new figure and axes is created. name : str, default=None Name for labeling curve. If `None`, use `estimator_name` if not `None`, otherwise no labeling is shown. ref_line : bool, default=True If `True`, plots a reference line representing a perfectly calibrated classifier. **kwargs : dict Keyword arguments to be passed to :func:`matplotlib.pyplot.plot`. Returns ------- display : :class:`~sklearn.calibration.CalibrationDisplay` Object that stores computed values. CalibrationDisplay.plotrNz(Positive class: )labelzPerfectly calibratedr zk:)rzs-z lower right)loczMean predicted probability zFraction of positives )xlabelylabel)rZmatplotlib.pyplotZpyplotZsubplotsrlrupdateZget_legend_handles_labelsplotrrZline_ZlegendsetZax_figureZfigure_) r9rrrkwargsZpltZfigZinfo_pos_labelZ line_kwargsZref_line_labelZexisting_ref_linerrr:r:r;rhs.      rrrrrrrrrc Ksn|jd} t| t|s$tdt||d|d\} }|dk rD|n|jj}|j|| f|||||| d| S)a Plot calibration curve using a binary classifier and data. A calibration curve, also known as a reliability diagram, uses inputs from a binary classifier and plots the average predicted probability for each bin against the fraction of positive classes, on the y-axis. Extra keyword arguments will be passed to :func:`matplotlib.pyplot.plot`. Read more about calibration in the :ref:`User Guide ` and more about the scikit-learn visualization API in :ref:`visualizations`. .. versionadded:: 1.0 Parameters ---------- estimator : estimator instance Fitted classifier or a fitted :class:`~sklearn.pipeline.Pipeline` in which the last estimator is a classifier. The classifier must have a :term:`predict_proba` method. X : {array-like, sparse matrix} of shape (n_samples, n_features) Input values. y : array-like of shape (n_samples,) Binary target values. n_bins : int, default=5 Number of bins to discretize the [0, 1] interval into when calculating the calibration curve. A bigger number requires more data. strategy : {'uniform', 'quantile'}, default='uniform' Strategy used to define the widths of the bins. - `'uniform'`: The bins have identical widths. - `'quantile'`: The bins have the same number of samples and depend on predicted probabilities. pos_label : str or int, default=None The positive class when computing the calibration curve. By default, `estimators.classes_[1]` is considered as the positive class. .. versionadded:: 1.1 name : str, default=None Name for labeling curve. If `None`, the name of the estimator is used. ref_line : bool, default=True If `True`, plots a reference line representing a perfectly calibrated classifier. ax : matplotlib axes, default=None Axes object to plot on. If `None`, a new figure and axes is created. **kwargs : dict Keyword arguments to be passed to :func:`matplotlib.pyplot.plot`. Returns ------- display : :class:`~sklearn.calibration.CalibrationDisplay`. Object that stores computed values. See Also -------- CalibrationDisplay.from_predictions : Plot calibration curve using true and predicted labels. Examples -------- >>> import matplotlib.pyplot as plt >>> from sklearn.datasets import make_classification >>> from sklearn.model_selection import train_test_split >>> from sklearn.linear_model import LogisticRegression >>> from sklearn.calibration import CalibrationDisplay >>> X, y = make_classification(random_state=0) >>> X_train, X_test, y_train, y_test = train_test_split( ... X, y, random_state=0) >>> clf = LogisticRegression(random_state=0) >>> clf.fit(X_train, y_train) LogisticRegression(random_state=0) >>> disp = CalibrationDisplay.from_estimator(clf, X_test, y_test) >>> plt.show() .from_estimatorz*'estimator' should be a fitted classifier.r))Zresponse_methodrNr)rarrrUr& __class__from_predictions) clsr1rNrFrrrrrrrrhrr:r:r;from_estimators0g   z!CalibrationDisplay.from_estimatorcKsl|jd} t| t|||||d\} } |dkr6dn|}t||}|| | |||d} | jf||d| S)a Plot calibration curve using true labels and predicted probabilities. Calibration curve, also known as reliability diagram, uses inputs from a binary classifier and plots the average predicted probability for each bin against the fraction of positive classes, on the y-axis. Extra keyword arguments will be passed to :func:`matplotlib.pyplot.plot`. Read more about calibration in the :ref:`User Guide ` and more about the scikit-learn visualization API in :ref:`visualizations`. .. versionadded:: 1.0 Parameters ---------- y_true : array-like of shape (n_samples,) True labels. y_prob : array-like of shape (n_samples,) The predicted probabilities of the positive class. n_bins : int, default=5 Number of bins to discretize the [0, 1] interval into when calculating the calibration curve. A bigger number requires more data. strategy : {'uniform', 'quantile'}, default='uniform' Strategy used to define the widths of the bins. - `'uniform'`: The bins have identical widths. - `'quantile'`: The bins have the same number of samples and depend on predicted probabilities. pos_label : str or int, default=None The positive class when computing the calibration curve. By default, `estimators.classes_[1]` is considered as the positive class. .. versionadded:: 1.1 name : str, default=None Name for labeling curve. ref_line : bool, default=True If `True`, plots a reference line representing a perfectly calibrated classifier. ax : matplotlib axes, default=None Axes object to plot on. If `None`, a new figure and axes is created. **kwargs : dict Keyword arguments to be passed to :func:`matplotlib.pyplot.plot`. Returns ------- display : :class:`~sklearn.calibration.CalibrationDisplay`. Object that stores computed values. See Also -------- CalibrationDisplay.from_estimator : Plot calibration curve using an estimator and data. Examples -------- >>> import matplotlib.pyplot as plt >>> from sklearn.datasets import make_classification >>> from sklearn.model_selection import train_test_split >>> from sklearn.linear_model import LogisticRegression >>> from sklearn.calibration import CalibrationDisplay >>> X, y = make_classification(random_state=0) >>> X_train, X_test, y_train, y_test = train_test_split( ... X, y, random_state=0) >>> clf = LogisticRegression(random_state=0) >>> clf.fit(X_train, y_train) LogisticRegression(random_state=0) >>> y_prob = clf.predict_proba(X_test)[:, 1] >>> disp = CalibrationDisplay.from_predictions(y_test, y_prob) >>> plt.show() r)rrrN Classifierr)rr)rarrr%r)rrrrrrrrrrrhrrrr:r:r;r#s&a   z#CalibrationDisplay.from_predictions) rartrurvr<r classmethodrrr:r:r:r;rs*J =}r)N)N)N)DrvZnumbersrrVinspectr functoolsrmathrZnumpyrAZ scipy.specialrrZscipy.optimizerbaser r r r rrZ preprocessingrrutilsrrrZutils.multiclassrZutils.parallelrrZutils._param_validationrrrZutils.validationrrrrrr r+r!Zsvmr"Zmodel_selectionr#r$Z metrics._baser%Zmetrics._plot.baser&r'rMrZr\r]rrrrrr:r:r:r;sR              W L& 0Q F;