:iSrSSKrSSKrSSKrSSKJr SSKrSSKr SSK J r J r SSK JrJr SSKJr SSKJr SSKJrJr S S KJrJrJr \"S /S /S S/\\R8S/S\"1S k5/S /S S/S .SS9SSSSSS.Sj5r\"S /S /S S/\\R8S/S\"1S k5/S S/S.SS9SSSSS.Sj5r\"S /S /S S/\\R8S/S\"1S k5/S S/S.SS9SSSSS.Sj5r\"S /S /S S/\\R8S/S\"1Sk5/S S/\"\R@SSSS9/S.SS9SSSSSS.S j5r!\"\R@/S!/S".SS9S#SS".S$j5r"\"S /S /S S/S S/S S/\"\R8SSSS9/\R@/S!/\"S%15\"\R8SSS&S9/S'. SS9SSSS S#S(S%S).S*j5r#\"S /S /S S/S+.SS9SS,.S-j5r$g).abMetrics to assess performance on a classification task given class predictions. The available metrics are complementary from the metrics available in scikit-learn. 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) signature)mean_absolute_errorprecision_recall_fscore_support)_check_targets _prf_divide) LabelEncoder) unique_labels)check_consistent_length column_or_1d)Interval StrOptionsvalidate_paramsz array-like>macromicrobinarysamplesweighted)y_truey_predlabels pos_labelaveragewarn_for sample_weightT)prefer_skip_nested_validation) sensitivity specificityrrrrrc SnXG;aUS:wa[S[U5-5e[X5upn[X5n US:Xa@US:Xa,X9;a#[ U 5S:ag[SU<SU <35eU/nO8[SU-5eUS ;a$[ R "S U<S U<S 3[5 UcU nS n O6[ U5n [R"U[R"XSS9/5nURS5(a [S5eUS:Xa [S5e[5n U RU5 U RU5nU RU5nU Rn X:Hn X nUb[R "U5U nOS n[ U5(a[R""X[ U5S9nO#[R$"[ U55=n=nn[ U5(a[R""X[ U5S9n[ U5(a[R""X[ U5S9nUR&WW-U- - n[R("XS U 5nUUnUUnUUnUUnUS:Xa[R*"UR-5/5n[R*"UR-5/5n[R*"UR-5/5n[R*"UR-5/5n[R."SSS9 [1UUU-U- SSUU5n[1UUSSXE5nS S S 5 US:XaUnUR-5S:XagO US:XaUnOS nUbCUS:wd[ W5S:Xde[R2"WUS 9n[R2"WUS 9nS nWWU4$!,(df  N=f)!a1Compute sensitivity, specificity, and support for each class. The sensitivity is the ratio ``tp / (tp + fn)`` where ``tp`` is the number of true positives and ``fn`` the number of false negatives. The sensitivity quantifies the ability to avoid false negatives_[1]. The specificity is the ratio ``tn / (tn + fp)`` where ``tn`` is the number of true negatives and ``fn`` the number of false negatives. The specificity quantifies the ability to avoid false positives_[1]. The support is the number of occurrences of each class in ``y_true``. If ``pos_label is None`` and in binary classification, this function returns the average sensitivity and specificity if ``average`` is one of ``'weighted'``. 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 targets as returned by a classifier. labels : array-like, default=None The set of labels to include when ``average != 'binary'``, and their order if ``average is None``. Labels present in the data can be excluded, for example to calculate a multiclass average ignoring a majority negative class, while labels not present in the data will result in 0 components in a macro average. For multilabel targets, labels are column indices. By default, all labels in ``y_true`` and ``y_pred`` are used in sorted order. pos_label : str, int or None, default=1 The class to report if ``average='binary'`` and the data is binary. If ``pos_label is None`` and in binary classification, this function returns the average sensitivity and specificity if ``average`` is one of ``'weighted'``. If the data are multiclass, this will be ignored; setting ``labels=[pos_label]`` and ``average != 'binary'`` will report scores for that label only. average : str, default=None If ``None``, the scores for each class are returned. Otherwise, this determines the type of averaging performed on the data: ``'binary'``: Only report results for the class specified by ``pos_label``. This is applicable only if targets (``y_{true,pred}``) are binary. ``'micro'``: Calculate metrics globally by counting the total true positives, false negatives and false positives. ``'macro'``: Calculate metrics for each label, and find their unweighted mean. This does not take label imbalance into account. ``'weighted'``: Calculate metrics for each label, and find their average, weighted by support (the number of true instances for each label). This alters 'macro' to account for label imbalance; it can result in an F-score that is not between precision and recall. ``'samples'``: Calculate metrics for each instance, and find their average (only meaningful for multilabel classification where this differs from :func:`accuracy_score`). warn_for : tuple or set of {{"sensitivity", "specificity"}}, for internal use This determines which warnings will be made in the case that this function is being used to return only one of its metrics. sample_weight : array-like of shape (n_samples,), default=None Sample weights. Returns ------- sensitivity : float (if `average is None`) or ndarray of shape (n_unique_labels,) The sensitivity metric. specificity : float (if `average is None`) or ndarray of shape (n_unique_labels,) The specificity metric. support : int (if `average is None`) or ndarray of shape (n_unique_labels,) The number of occurrences of each label in ``y_true``. References ---------- .. [1] `Wikipedia entry for the Sensitivity and specificity `_ Examples -------- >>> import numpy as np >>> from imblearn.metrics import sensitivity_specificity_support >>> y_true = np.array(['cat', 'dog', 'pig', 'cat', 'dog', 'pig']) >>> y_pred = np.array(['cat', 'pig', 'dog', 'cat', 'cat', 'dog']) >>> sensitivity_specificity_support(y_true, y_pred, average='macro') (0.33..., 0.66..., None) >>> sensitivity_specificity_support(y_true, y_pred, average='micro') (0.33..., 0.66..., None) >>> sensitivity_specificity_support(y_true, y_pred, average='weighted') (0.33..., 0.66..., None) )Nrrrrrzaverage has to be one of r )r"rz pos_label=z is not a valid label: zITarget is %s but average='binary'. Please choose another average setting.)NrzNote that pos_label (set to z+) is ignored when average != 'binary' (got zE). You may use labels=[pos_label] to specify a single positive class.NT assume_unique multilabelz$imblearn does not support multilabelrz{Sample-based precision, recall, fscore is not meaningful outside multilabel classification. See the accuracy_score instead.weights minlengthrignoredivideinvalidr predictedrtruerr)rrNrr') ValueErrorstrrr lenwarningswarn UserWarningnphstack setdiff1d startswithrfit transformclasses_asarraybincountzerossize searchsortedarraysumerrstaterr)rrrrrrraverage_optionsy_typepresent_labelsn_labelsle sorted_labelstptp_binstp_bins_weightstp_sumtrue_sumpred_sumtn_sumindicesrrr's c/srv/projetos/modelo_ml_acdoc/venv/lib/python3.13/site-packages/imblearn/metrics/_classification.pysensitivity_specificity_supportrT!sFFO%'X*=4s?7KKLL+F;FF"62N( X .~&*($$n6 [F24:;  ) # ' #   ~v; R\\.M N  &&?@@ I  >  ^ vf%f%  *  $ jj7;O"O w<<[[CKF ,.88CK+@ @H @x& v;;{{6CPVKXH v;;{{6CPVKXH8 3f <=//- 1BCG$G$'6::<.)88X\\^,-88X\\^,-6::<.) Hh 7 "  X  &      " HmVW  8&* ;;=A   I ("c+&6!&;;;jjg> jjg>   X --E 8 7s -&O O)rrrrrrr)rrrrc ,[UUUUUSUS9un nU$)a Compute the sensitivity. The sensitivity is the ratio ``tp / (tp + fn)`` where ``tp`` is the number of true positives and ``fn`` the number of false negatives. The sensitivity quantifies the ability to avoid false negatives. The best value is 1 and the worst value is 0. 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 targets as returned by a classifier. labels : array-like, default=None The set of labels to include when ``average != 'binary'``, and their order if ``average is None``. Labels present in the data can be excluded, for example to calculate a multiclass average ignoring a majority negative class, while labels not present in the data will result in 0 components in a macro average. pos_label : str, int or None, default=1 The class to report if ``average='binary'`` and the data is binary. If ``pos_label is None`` and in binary classification, this function returns the average sensitivity if ``average`` is one of ``'weighted'``. If the data are multiclass, this will be ignored; setting ``labels=[pos_label]`` and ``average != 'binary'`` will report scores for that label only. average : str, default=None If ``None``, the scores for each class are returned. Otherwise, this determines the type of averaging performed on the data: ``'binary'``: Only report results for the class specified by ``pos_label``. This is applicable only if targets (``y_{true,pred}``) are binary. ``'micro'``: Calculate metrics globally by counting the total true positives, false negatives and false positives. ``'macro'``: Calculate metrics for each label, and find their unweighted mean. This does not take label imbalance into account. ``'weighted'``: Calculate metrics for each label, and find their average, weighted by support (the number of true instances for each label). This alters 'macro' to account for label imbalance; it can result in an F-score that is not between precision and recall. ``'samples'``: Calculate metrics for each instance, and find their average (only meaningful for multilabel classification where this differs from :func:`accuracy_score`). sample_weight : array-like of shape (n_samples,), default=None Sample weights. Returns ------- specificity : float (if `average is None`) or ndarray of shape (n_unique_labels,) The specifcity metric. Examples -------- >>> import numpy as np >>> from imblearn.metrics import sensitivity_score >>> y_true = [0, 1, 2, 0, 1, 2] >>> y_pred = [0, 2, 1, 0, 0, 1] >>> sensitivity_score(y_true, y_pred, average='macro') 0.33... >>> sensitivity_score(y_true, y_pred, average='micro') 0.33... >>> sensitivity_score(y_true, y_pred, average='weighted') 0.33... >>> sensitivity_score(y_true, y_pred, average=None) array([1., 0., 0.]) )rr rT)rrrrrrs_s rSsensitivity_scorerY*s1N.!#GAq! Hc *[UUUUUSUS9upgnU$)a Compute the specificity. The specificity is the ratio ``tn / (tn + fp)`` where ``tn`` is the number of true negatives and ``fp`` the number of false positives. The specificity quantifies the ability to avoid false positives. The best value is 1 and the worst value is 0. 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 targets as returned by a classifier. labels : array-like, default=None The set of labels to include when ``average != 'binary'``, and their order if ``average is None``. Labels present in the data can be excluded, for example to calculate a multiclass average ignoring a majority negative class, while labels not present in the data will result in 0 components in a macro average. pos_label : str, int or None, default=1 The class to report if ``average='binary'`` and the data is binary. If ``pos_label is None`` and in binary classification, this function returns the average specificity if ``average`` is one of ``'weighted'``. If the data are multiclass, this will be ignored; setting ``labels=[pos_label]`` and ``average != 'binary'`` will report scores for that label only. average : str, default=None If ``None``, the scores for each class are returned. Otherwise, this determines the type of averaging performed on the data: ``'binary'``: Only report results for the class specified by ``pos_label``. This is applicable only if targets (``y_{true,pred}``) are binary. ``'micro'``: Calculate metrics globally by counting the total true positives, false negatives and false positives. ``'macro'``: Calculate metrics for each label, and find their unweighted mean. This does not take label imbalance into account. ``'weighted'``: Calculate metrics for each label, and find their average, weighted by support (the number of true instances for each label). This alters 'macro' to account for label imbalance; it can result in an F-score that is not between precision and recall. ``'samples'``: Calculate metrics for each instance, and find their average (only meaningful for multilabel classification where this differs from :func:`accuracy_score`). sample_weight : array-like of shape (n_samples,), default=None Sample weights. Returns ------- specificity : float (if `average is None`) or ndarray of shape (n_unique_labels,) The specificity metric. Examples -------- >>> import numpy as np >>> from imblearn.metrics import specificity_score >>> y_true = [0, 1, 2, 0, 1, 2] >>> y_pred = [0, 2, 1, 0, 0, 1] >>> specificity_score(y_true, y_pred, average='macro') 0.66... >>> specificity_score(y_true, y_pred, average='micro') 0.66... >>> specificity_score(y_true, y_pred, average='weighted') 0.66... >>> specificity_score(y_true, y_pred, average=None) array([0.75, 0.5 , 0.75]) )rr rV)rrrrrrrXrWs rSspecificity_scorer\s/N.!#GA! HrZ>rrrrr multiclassleft)closed)rrrrrr correctionr]r")rrrrr`c UbUS:wa*[UUUUUSUS9upxn [R"Xx-5$[X5n UcU nSn O6[ U5n [R "U[R "XSS9/5n[5n U RU5 U RU5nU RU5nU Rn X:HnXnUb[R"U5UnOSn[ U5(a [R"UU[ U5S9nO![R"[ U55=nn[ U5(a[R"X[ U5S9n[R"XSU 5nUUnWUn[R"SSS 9 [!UUS S SS 5nSSS5 UWUS :H'[R"SSS 9 ["R$R'U5nSSS5 [)W[R*R,R.5(ag U$!,(df  N=f!,(df  NU=f)u"Compute the geometric mean. The geometric mean (G-mean) is the root of the product of class-wise sensitivity. This measure tries to maximize the accuracy on each of the classes while keeping these accuracies balanced. For binary classification G-mean is the squared root of the product of the sensitivity and specificity. For multi-class problems it is a higher root of the product of sensitivity for each class. For compatibility with other imbalance performance measures, G-mean can be calculated for each class separately on a one-vs-rest basis when ``average != 'multiclass'``. The best value is 1 and the worst value is 0. Traditionally if at least one class is unrecognized by the classifier, G-mean resolves to zero. To alleviate this property, for highly multi-class the sensitivity of unrecognized classes can be "corrected" to be a user specified value (instead of zero). This option works only if ``average == 'multiclass'``. 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 targets as returned by a classifier. labels : array-like, default=None The set of labels to include when ``average != 'binary'``, and their order if ``average is None``. Labels present in the data can be excluded, for example to calculate a multiclass average ignoring a majority negative class, while labels not present in the data will result in 0 components in a macro average. pos_label : str, int or None, default=1 The class to report if ``average='binary'`` and the data is binary. If ``pos_label is None`` and in binary classification, this function returns the average geometric mean if ``average`` is one of ``'weighted'``. If the data are multiclass, this will be ignored; setting ``labels=[pos_label]`` and ``average != 'binary'`` will report scores for that label only. average : str or None, default='multiclass' If ``None``, the scores for each class are returned. Otherwise, this determines the type of averaging performed on the data: ``'binary'``: Only report results for the class specified by ``pos_label``. This is applicable only if targets (``y_{true,pred}``) are binary. ``'micro'``: Calculate metrics globally by counting the total true positives, false negatives and false positives. ``'macro'``: Calculate metrics for each label, and find their unweighted mean. This does not take label imbalance into account. ``'multiclass'``: No average is taken. ``'weighted'``: Calculate metrics for each label, and find their average, weighted by support (the number of true instances for each label). This alters 'macro' to account for label imbalance; it can result in an F-score that is not between precision and recall. ``'samples'``: Calculate metrics for each instance, and find their average (only meaningful for multilabel classification where this differs from :func:`accuracy_score`). sample_weight : array-like of shape (n_samples,), default=None Sample weights. correction : float, default=0.0 Substitutes sensitivity of unrecognized classes from zero to a given value. Returns ------- geometric_mean : float Returns the geometric mean. Notes ----- See :ref:`sphx_glr_auto_examples_evaluation_plot_metrics.py`. References ---------- .. [1] Kubat, M. and Matwin, S. "Addressing the curse of imbalanced training sets: one-sided selection" ICML (1997) .. [2] Barandela, R., Sánchez, J. S., Garcıa, V., & Rangel, E. "Strategies for learning in class imbalance problems", Pattern Recognition, 36(3), (2003), pp 849-851. Examples -------- >>> from imblearn.metrics import geometric_mean_score >>> y_true = [0, 1, 2, 0, 1, 2] >>> y_pred = [0, 2, 1, 0, 0, 1] >>> geometric_mean_score(y_true, y_pred) 0.0 >>> geometric_mean_score(y_true, y_pred, correction=0.001) 0.010... >>> geometric_mean_score(y_true, y_pred, average='macro') 0.471... >>> geometric_mean_score(y_true, y_pred, average='micro') 0.471... >>> geometric_mean_score(y_true, y_pred, average='weighted') 0.471... >>> geometric_mean_score(y_true, y_pred, average=None) array([0.866..., 0. , 0. ]) Nr])rrr Tr#r&r)r*recallr.rr")rTr6sqrtr r2r7r8rr:r;r<r=r>r?rArDrspstatsgmean isinstancemacoreMaskedConstant)rrrrrrr`sensperXrGrHrIrJrKrLrMrNrOrRrbrfs rSgeometric_mean_scorermsX'\15  3' !wwsy!!&v6 >#FH6{HYYnDQRF^ vf%f%  *  $ jj7;O"O w<<[[CKF !#V 5 5Hv v;;{{6CPVKXH//- 1BCG$ [[( ; 8VT8TF<(v{ [[( ;HHNN6*E< eRUUZZ66 7 7 < ;< ;s$H8 I 8 I Ibooleanalphasquaredg?c^^UU4SjnU$)uBalance any scoring function using the index balanced accuracy. This factory function wraps scoring function to express it as the index balanced accuracy (IBA). You need to use this function to decorate any scoring function. Only metrics requiring ``y_pred`` can be corrected with the index balanced accuracy. ``y_score`` cannot be used since the dominance cannot be computed. Read more in the :ref:`User Guide `. Parameters ---------- alpha : float, default=0.1 Weighting factor. squared : bool, default=True If ``squared`` is True, then the metric computed will be squared before to be weighted. Returns ------- iba_scoring_func : callable, Returns the scoring metric decorated which will automatically compute the index balanced accuracy. Notes ----- See :ref:`sphx_glr_auto_examples_evaluation_plot_metrics.py`. References ---------- .. [1] García, Vicente, Javier Salvador Sánchez, and Ramón Alberto Mollineda. "On the effectiveness of preprocessing methods when dealing with different levels of class imbalance." Knowledge-Based Systems 25.1 (2012): 13-21. Examples -------- >>> from imblearn.metrics import geometric_mean_score as gmean >>> from imblearn.metrics import make_index_balanced_accuracy as iba >>> gmean = iba(alpha=0.1, squared=True)(gmean) >>> y_true = [1, 0, 0, 1, 0, 1] >>> y_pred = [0, 0, 1, 1, 0, 1] >>> print(gmean(y_true, y_pred, average=None)) [0.44... 0.44...] cL>^[R"T5UUU4Sj5nU$)Ncn>[T5n[URR55n[/SQ5nUR U5(a[ STR S35eUR"U0UD6nUR5 T"UR0URD6nT(a[R"US5n[[5n[URR55nUR [URR555n U V s0sHoURU _M n n TR S:XaSU ;aU SS:XaSU S'O%TR S :XdTR S :XaS U S'[S 0U D6upnX- nS TU--U-$s sn f)N)y_scorey_proby2z The function zh has an unsupported attribute. Metric with`y_pred` are the only supported metrics is the only supported.r rmrr]raccuracy_score jaccard_scorerg?)rset parameterskeys intersectionAttributeError__name__bindapply_defaultsargskwargsr6powerrT arguments)rrsignature_scoring_funcparams_scoring_funcprohibitied_y_predargs_scoring_func_scoresignature_sens_specparams_sens_spec common_paramskargs_sens_specrrrX dominancerp scoring_funcrqs rS compute_scoreEmake_index_balanced_accuracy..decorate..compute_scores%.|%< ""%&<&G&G&L&L&N"O "%%@!A !../BCC$#L$9$9#:;"#!7 ; ;T LV L   , , .!#4#9#9V=N=U=UVF&!,"+,K"L "#6#A#A#F#F#HI ,99%//4467MJWWA!2!>.%i0L@4;y1%%)99((O;-5y)*I+ + 'Ka$1I%)++v5 5'Xs0F2) functoolswraps)rrrprqs` rSdecorate.make_index_balanced_accuracy..decorates'  &. 6 '. 6`rZrz)rprqrs`` rSmake_index_balanced_accuracyrsl2h OrZr4both) rrr target_namesrdigitsrp output_dict zero_divisionF)rrrrrprrc VUc [X5nO[R"U5nSn UcUV s/sHoPM nn [SU55n [U [ U 5U5n /SQn SU -nUS- nUSR U Vs/sHnSPM sn5- nUS - nS /U -n U[ U 5-nUS - n[UUUSUUS 9unnnn[UUUSUS 9n[UUUSUS 9n[US S9"[5nU"UUUSUS 9n0n[U5Hunn 0nUU/n[U SSUUUUUUUUUUUU/5H!unnUSRUU5/- nUUU'M# UUU/- nUUUU S'UU[ U5-- nUUUU'M US - nU /n[U SS[R"UUS9[R"UUS9[R"UUS9[R"UUS9[R"UUS9[R"UUS9/5H$unnUSRUU5/- nUUSU3'M& U[R"U5/- nUU[ U5-- n[R"U5US'U(aU$U$s sn fs snf)at Build a classification report based on metrics used with imbalanced dataset. Specific metrics have been proposed to evaluate the classification performed on imbalanced dataset. This report compiles the state-of-the-art metrics: precision/recall/specificity, geometric mean, and index balanced accuracy of the geometric mean. Read more in the :ref:`User Guide `. Parameters ---------- y_true : 1d array-like, or label indicator array / sparse matrix Ground truth (correct) target values. y_pred : 1d array-like, or label indicator array / sparse matrix Estimated targets as returned by a classifier. labels : array-like of shape (n_labels,), default=None Optional list of label indices to include in the report. target_names : list of str of shape (n_labels,), default=None Optional display names matching the labels (same order). sample_weight : array-like of shape (n_samples,), default=None Sample weights. digits : int, default=2 Number of digits for formatting output floating point values. When ``output_dict`` is ``True``, this will be ignored and the returned values will not be rounded. alpha : float, default=0.1 Weighting factor. output_dict : bool, default=False If True, return output as dict. .. versionadded:: 0.8 zero_division : "warn" or {0, 1}, default="warn" Sets the value to return when there is a zero division. If set to "warn", this acts as 0, but warnings are also raised. .. versionadded:: 0.8 Returns ------- report : string / dict Text summary of the precision, recall, specificity, geometric mean, and index balanced accuracy. Dictionary returned if output_dict is True. Dictionary has the following structure:: {'label 1': {'pre':0.5, 'rec':1.0, ... }, 'label 2': { ... }, ... } Examples -------- >>> import numpy as np >>> from imblearn.metrics import classification_report_imbalanced >>> y_true = [0, 1, 2, 2, 2] >>> y_pred = [0, 0, 2, 2, 1] >>> target_names = ['class 0', 'class 1', 'class 2'] >>> print(classification_report_imbalanced(y_true, y_pred, target_names=target_names)) pre rec spe f1 geo iba sup class 0 0.50 1.00 0.75 0.67 0.87 0.77 1 class 1 0.00 0.00 0.75 0.00 0.00 0.00 1 class 2 1.00 0.67 1.00 0.80 0.82 0.64 3 avg / total 0.70 0.60 0.90 0.61 0.66 0.54 5 Nz avg / totalc38# UHn[U5v M g7f)N)r2).0cns rS 3classification_report_imbalanced..s4|SWW|s)prerecrlf1geoibasupz%% %dsz  z% 9s )rrrr)rrrTrorz {0:0.{1}f}r/avg_ total_support)r r6r=maxr2jointuplerr\rmr enumeratezipformatrrC)rrrrrrrprrlast_line_headinglabel name_widthwidthheadersfmtrXreport precisionrbrsupportrgeo_mean iba_gmeanr report_dictireport_dict_labelvalues score_name score_values rS classification_report_imbalancedrMsTf~v.F#%067u'  74|44J  C 12F ;E>G U C4KC388W-WVW- ..C4KCdWnG 5> !F dNF&E## &"Ivr7$# K$# H-5$GI #  CKf%5q/"'* AbM! q A1 A   ( #J  |**;?@ @F,7 j ) (  gaj\##)0'"+&#f %%'8 LO$)&, dNF F#&" JJy' 2 JJvw / JJ{G 4 JJr7 + JJx 1 JJsG ,   $ K <&&{F;<<+6 d:,'( $ "&&/"$$F cE&M!!F#%66'?K  ME8.s J! J& )rrrrc t[X5up0nUb [U5nO [R"UR5n[ XU5 [ X5n/nUH;n[R"X:H5nUR[XXX'S95 M= [R"U5[U5- $)aCompute Macro-Averaged MAE for imbalanced ordinal classification. This function computes each MAE for each class and average them, giving an equal weight to each class. Read more in the :ref:`User Guide `. .. versionadded:: 0.8 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 targets as returned by a classifier. sample_weight : array-like of shape (n_samples,), default=None Sample weights. Returns ------- loss : float or ndarray of floats Macro-Averaged MAE output is non-negative floating point. The best value is 0.0. Examples -------- >>> import numpy as np >>> from sklearn.metrics import mean_absolute_error >>> from imblearn.metrics import macro_averaged_mean_absolute_error >>> y_true_balanced = [1, 1, 2, 2] >>> y_true_imbalanced = [1, 2, 2, 2] >>> y_pred = [1, 2, 1, 2] >>> mean_absolute_error(y_true_balanced, y_pred) 0.5 >>> mean_absolute_error(y_true_imbalanced, y_pred) 0.25 >>> macro_averaged_mean_absolute_error(y_true_balanced, y_pred) 0.5 >>> macro_averaged_mean_absolute_error(y_true_imbalanced, y_pred) 0.16... r) rr r6onesshaper r flatnonzeroappendrrCr2)rrrrXrmaepossible_classrRs rS"macro_averaged_mean_absolute_errorr-sh'v6Av $]3  - FM: 6 *F C ..!9: +4  ! 66#;S !!rZ)%__doc__rnumbersr3inspectrnumpyr6scipyrdsklearn.metricsrrsklearn.metrics._classificationrrsklearn.preprocessingrsklearn.utils.multiclassr sklearn.utils.validationr r utils._param_validationr rrr1IntegralrTrYr\RealrmrrrrzrZrSrs2 PG.2JKK..&7++T2  J K "N&- #'&   +w.w.t..&7++T2  J K '- #' $  c  c L..&7++T2  J K '- #' $  c  c L..&7++T2  Q  '- afEF #'*  z#"zz||n)5"&+.tf fR..&%t,&-G,,afEF,,!{ x W%%q!F ;  #'*  L#"L^..&- #' IM?"?"rZ