-i3SrSSKrSSKrSSKrSSKJrJr SSKrSSK J r SSK J r JrJrJrJrJrJrJr SSKJr SSKJr SSKJr SS KJrJr SS KJr SS K J!r!J"r"J#r#J$r$ SS K%J&r&J'r' SS K(J)r)J*r*J+r+ SSK,J-r-J.r. SSK/J0r0J1r1J2r2J3r3 /SQr4S Sjr5Sr6Sr7Sr8"SS\ 5r9Sr:"SS\\\\ 5r;Sr"SS\\\ 5r?g)!aMulticlass learning algorithms. - one-vs-the-rest / one-vs-all - one-vs-one - error correcting output codes The estimators provided in this module are meta-estimators: they require a base estimator to be provided in their constructor. For example, it is possible to use these estimators to turn a binary classifier or a regressor into a multiclass classifier. It is also possible to use these estimators with multiclass estimators in the hope that their accuracy or runtime performance improves. All classifiers in scikit-learn implement multiclass classification; you only need to use this module if you want to experiment with custom multiclass strategies. The one-vs-the-rest meta-classifier also implements a `predict_proba` method, so long as such a method is implemented by the base classifier. This method returns probabilities of class membership in both the single label and multilabel case. Note that in the multilabel case, probabilities are the marginal probability that a given sample falls in the given class. As such, in the multilabel case the sum of these probabilities over all possible labels for a given sample *will not* sum to unity, as they do in the single label case. N)IntegralReal) BaseEstimatorClassifierMixinMetaEstimatorMixinMultiOutputMixin _fit_contextclone is_classifier is_regressor)pairwise_distances_argmin)LabelBinarizer)check_random_state) HasMethodsInterval)get_tags)MetadataRouter MethodMapping_raise_for_paramsprocess_routing) _safe_split available_if)_check_partial_fit_first_call_ovr_decision_functioncheck_classification_targets)Paralleldelayed)_check_method_params _num_samplescheck_is_fitted validate_data)OneVsOneClassifierOneVsRestClassifierOutputCodeClassifierc2[R"U5n[U5S:XaSUb5USS:XaSnOUSn[R"S[ XF5-5 [ 5RX5nU$[U5nUR"X40UD6 U$)zFit a single binary estimator.rrz-Label %s is present in all training examples.) npuniquelenwarningswarnstr_ConstantPredictorfitr ) estimatorXy fit_paramsclassesunique_ycs E/var/www/html/venv/lib/python3.13/site-packages/sklearn/multiclass.py _fit_binaryr8Qsyy|H 8}  trzaD MM?#gj/Q '(,,Q9  )$  a)j) cXUR"X4S[R"S50UD6 U$)z(Partially fit a single binary estimator.r4)rr) partial_fitr(array)r0r1r2partial_fit_paramss r7_partial_fit_binaryr>ds* !O(8O[US5(a[URST5 g[URT5 g)N estimators_rT)rKgetattrrur0)rXattrs r7check_estimators_has..checks= 4 ' ' D$$Q' . DNND )r9rr)rwrxs` r7_estimators_hasrzs Lr9c0^\rSrSrSr\"S/5/\S/S/S.rSSS.S jr\ "S S 9S 5r \ "\ "S 55\ "S S 9SSj55r Sr\ "\ "S55S5r\ "\ "S55S5r\S5r\S5rU4SjrSrSrU=r$)r$aOne-vs-the-rest (OvR) multiclass strategy. Also known as one-vs-all, this strategy consists in fitting one classifier per class. For each classifier, the class is fitted against all the other classes. In addition to its computational efficiency (only `n_classes` classifiers are needed), one advantage of this approach is its interpretability. Since each class is represented by one and one classifier only, it is possible to gain knowledge about the class by inspecting its corresponding classifier. This is the most commonly used strategy for multiclass classification and is a fair default choice. OneVsRestClassifier can also be used for multilabel classification. To use this feature, provide an indicator matrix for the target `y` when calling `.fit`. In other words, the target labels should be formatted as a 2D binary (0/1) matrix, where [i, j] == 1 indicates the presence of label j in sample i. This estimator uses the binary relevance method to perform multilabel classification, which involves training one binary classifier independently for each label. Read more in the :ref:`User Guide `. Parameters ---------- estimator : estimator object A regressor or a classifier that implements :term:`fit`. When a classifier is passed, :term:`decision_function` will be used in priority and it will fallback to :term:`predict_proba` if it is not available. When a regressor is passed, :term:`predict` is used. n_jobs : int, default=None The number of jobs to use for the computation: the `n_classes` one-vs-rest problems are computed in parallel. ``None`` means 1 unless in a :obj:`joblib.parallel_backend` context. ``-1`` means using all processors. See :term:`Glossary ` for more details. .. versionchanged:: 0.20 `n_jobs` default changed from 1 to None verbose : int, default=0 The verbosity level, if non zero, progress messages are printed. Below 50, the output is sent to stderr. Otherwise, the output is sent to stdout. The frequency of the messages increases with the verbosity level, reporting all iterations at 10. See :class:`joblib.Parallel` for more details. .. versionadded:: 1.1 Attributes ---------- estimators_ : list of `n_classes` estimators Estimators used for predictions. classes_ : array, shape = [`n_classes`] Class labels. n_classes_ : int Number of classes. label_binarizer_ : LabelBinarizer object Object used to transform multiclass labels to binary labels and vice-versa. multilabel_ : boolean Whether a OneVsRestClassifier is a multilabel classifier. 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 See Also -------- OneVsOneClassifier : One-vs-one multiclass strategy. OutputCodeClassifier : (Error-Correcting) Output-Code multiclass strategy. sklearn.multioutput.MultiOutputClassifier : Alternate way of extending an estimator for multilabel classification. sklearn.preprocessing.MultiLabelBinarizer : Transform iterable of iterables to binary indicator matrix. Examples -------- >>> import numpy as np >>> from sklearn.multiclass import OneVsRestClassifier >>> from sklearn.svm import SVC >>> X = np.array([ ... [10, 10], ... [8, 10], ... [-5, 5.5], ... [-5.4, 5.5], ... [-20, -20], ... [-15, -20] ... ]) >>> y = np.array([0, 0, 1, 1, 2, 2]) >>> clf = OneVsRestClassifier(SVC()).fit(X, y) >>> clf.predict([[-19, -20], [9, 9], [-5, 5]]) array([2, 0, 1]) r/Nverboser0n_jobsr}rrr}c(XlX lX0lgNr~)rXr0rr}s r7__init__OneVsRestClassifier.__init__Bs"  r9Fprefer_skip_nested_validationc z^^^[UTS5 [TS40UD6m[SS9TlTRR U5nUR 5nTRR TlSUR5n[TRTRS9"UUU4Sj[U555Tl [TRSS5(aTRSRTl[TRSS 5(aTRSRTlT$) a{Fit underlying estimators. Parameters ---------- X : {array-like, sparse matrix} of shape (n_samples, n_features) Data. y : {array-like, sparse matrix} of shape (n_samples,) or (n_samples, n_classes) Multi-class targets. An indicator matrix turns on multilabel classification. **fit_params : dict Parameters passed to the ``estimator.fit`` method of each sub-estimator. .. versionadded:: 1.4 Only available if `enable_metadata_routing=True`. See :ref:`Metadata Routing User Guide ` for more details. Returns ------- self : object Instance of fitted estimator. r/T sparse_outputc3\# UH"oR5R5v M$ g7frtoarrayrA.0cols r7 *OneVsRestClassifier.fit..t 8CS;;=&&((C*,rc 3># UHoup[[5"TRTUTRRSTRR U-TRR U/S9v Mq g7f)znot %sr3r4N)rr8r0r/label_binarizer_classes_)ricolumnr1 routed_paramsrXs r7rrxsw N 0  K (2266t44==a@@))2215 0sA7A:rn_features_in_feature_names_in_)rrrr fit_transformtocscrTrrr} enumeraterurKrr)rXr1r2r3Ycolumnsrs`` @r7r/OneVsRestClassifier.fitGs< *dE2'    !/T B  ! ! / / 2 GGI--66 8ACC8$4;; M N 'w/ N   4##A&(8 9 9"&"2"21"5"D"DD  4##A&(; < <%)%5%5a%8%J%JD " r9r;c ^^[X@S5 [US40UD6m[X5(aq[UR5Vs/sHn[ UR 5PM snUl[SS9Ul URRUR5 [[R"X R55(a9[SR![R""U5UR55eURR%U5nUR'5nSUR(5n[+UR,S9"UU4Sj[/URU555Ul[1URSS 5(aURSR2UlU$s snf) a@Partially fit underlying estimators. Should be used when memory is inefficient to train all data. Chunks of data can be passed in several iterations. Parameters ---------- X : {array-like, sparse matrix} of shape (n_samples, n_features) Data. y : {array-like, sparse matrix} of shape (n_samples,) or (n_samples, n_classes) Multi-class targets. An indicator matrix turns on multilabel classification. classes : array, shape (n_classes, ) Classes across all calls to partial_fit. Can be obtained via `np.unique(y_all)`, where y_all is the target vector of the entire dataset. This argument is only required in the first call of partial_fit and can be omitted in the subsequent calls. **partial_fit_params : dict Parameters passed to the ``estimator.partial_fit`` method of each sub-estimator. .. versionadded:: 1.4 Only available if `enable_metadata_routing=True`. See :ref:`Metadata Routing User Guide ` for more details. Returns ------- self : object Instance of partially fitted estimator. r;Trz;Mini-batch contains {0} while classes must be subset of {1}c3\# UH"oR5R5v M$ g7frrrs r7r2OneVsRestClassifier.partial_fit..rrrc3|># UH1up[[5"UTUTRRS9v M3 g7fr=N)rr>r0r;)rr0rr1rs r7rrsD8 &D! ' (#0#:#:#F#F   &Ds9<rr)rrrrange n_classes_r r0rurrr/rr*r( setdiff1d ValueErrorformatr) transformrrrrziprKr) rXr1r2r4r=_rrrs ` @r7r;OneVsRestClassifier.partial_fitsmR ,MB'   ! ) 7 7?DT__?UV?U!dnn 5?UVD  %3$FD !  ! ! % %dmm 4 r||A}}- . .V&1t}}5   ! ! + +A . GGI8ACC8#4;;78 &))9)97%C8   4##A&(8 9 9"&"2"21"5"D"DD  C WsF=c [U5 [U5nURRS:Xa[R "U[ S9nUR[R*5 [R"U[S9n[UR5H+upV[Xa5n[R"X7US9 XTX7:H'M- URU$[!URS5n["R""S5n ["R""SS/5n URHQnU R%[R&"[Xa5U:5S5 U R)[+U 55 MS [R,"[+U 5[S9n [.R0"XU 4U[+UR54S9n URR3U 5$)aPredict multi-class targets using underlying estimators. Parameters ---------- X : {array-like, sparse matrix} of shape (n_samples, n_features) Data. Returns ------- y : {array-like, sparse matrix} of shape (n_samples,) or (n_samples, n_classes) Predicted multi-class targets. multiclassrQ)outrr)shape)r!r ry_type_r(emptyfloatfillinfzerosintrrurGmaximumrrLr<extendwhereappendr*onessp csc_matrixinverse_transform) rXr1 n_samplesmaxima argmaximarepredthreshindicesindptrdata indicators r7r@OneVsRestClassifier.predictsu  O  ( (L 8XXiu5F KK #6I!$"2"23&q, 6V4,-&.)4==+ +243C3CA3FGFkk#&G[[qc*F%%rxx(=(FGJK c'l+&773wJs!C$rBc>[U5 [UR5S:XaURSRU5$[R "URVs/sH!o"RU5R 5PM# sn5R$s snf)a}Decision function for the OneVsRestClassifier. Return the distance of each sample from the decision boundary for each class. This can only be used with estimators which implement the `decision_function` method. Parameters ---------- X : array-like of shape (n_samples, n_features) Input data. Returns ------- T : array-like of shape (n_samples, n_classes) or (n_samples,) for binary classification. Result of calling `decision_function` on the final estimator. .. versionchanged:: 0.19 output shape changed to ``(n_samples,)`` to conform to scikit-learn conventions for binary classification. rr)r!r*rurBr(r<rAr)rXr1ests r7rB%OneVsRestClassifier.decision_function2s.  t A %##A&88; ;xx9=9I9I J9I# " "1 % + + -9I J ! Js!(BcLURRRS5$)z(Whether this is a multilabel classifier. multilabel)rr startswithrXs r7rOneVsRestClassifier.multilabel_Ps!$$,,77 EEr9c,[UR5$zNumber of classes.r*rrs r7rOneVsRestClassifier.n_classes_U4==!!r9c>[TU]5n[UR5RR URl[UR5RR URlU$z@Indicate if wrapped estimator is using a precomputed Gram matrixsuper__sklearn_tags__rr0 input_tagspairwisesparserXtags __class__s r7r$OneVsRestClassifier.__sklearn_tags__ZWw')#+DNN#;#F#F#O#O !)$..!9!D!D!K!K r9c[URRS9RU5R UR [ 5R SSS9R SSS9S9nU$"Get metadata routing of this object. Please check :ref:`User Guide ` on how the routing mechanism works. .. versionadded:: 1.4 Returns ------- routing : MetadataRouter A :class:`~sklearn.utils.metadata_routing.MetadataRouter` encapsulating routing information. ownerr/callercalleer;r0method_mappingrrrladd_self_requestaddr0rrXrouters r7get_metadata_routing(OneVsRestClassifier.get_metadata_routingad !8!8 9  d # S..,E%0M-@   r9)rr0rurrrrr}r)rlrmrnrorprr_parameter_constraintsrr r/rrzr;r@rErBpropertyrrrrrq __classcell__rs@r7r$r$s jZ!%)*T"; -1! &+@ @D/-01&+N 2 N`$FL//23'4'R/"567 8 :FF""r9r$c 6[R"X#:HX$:H5nX&n[R"UR[5nSXrU:H'SXrU:H'[R "[ U55Un[XUS9n [U[XSUS9SUU X4/S9U4$)z+Fit a single binary estimator (one-vs-one).rrparamsrN)rr) r( logical_orrrraranger rr8r) r0r1r2rjr3condy_binaryindcondfit_params_subsets r7_fit_ovo_binaryr}s == (D Axx%HH!VH!Vii Q(.G,Q7S   dG ) r0r1r2rrr=rrpartial_fit_params_subsets r7_partial_fit_ovo_binaryrst == (D A 1v{==#a$8 $% !# w   r9c^\rSrSr%Sr\"S/5/\S/S.r\\ S'SS.Sjr \ "S S 9S 5r \ "\"S 55\ "S S 9SS j55rSrSr\S5rU4SjrSrSrU=r$)r#ia One-vs-one multiclass strategy. This strategy consists in fitting one classifier per class pair. At prediction time, the class which received the most votes is selected. Since it requires to fit `n_classes * (n_classes - 1) / 2` classifiers, this method is usually slower than one-vs-the-rest, due to its O(n_classes^2) complexity. However, this method may be advantageous for algorithms such as kernel algorithms which don't scale well with `n_samples`. This is because each individual learning problem only involves a small subset of the data whereas, with one-vs-the-rest, the complete dataset is used `n_classes` times. Read more in the :ref:`User Guide `. Parameters ---------- estimator : estimator object A regressor or a classifier that implements :term:`fit`. When a classifier is passed, :term:`decision_function` will be used in priority and it will fallback to :term:`predict_proba` if it is not available. When a regressor is passed, :term:`predict` is used. n_jobs : int, default=None The number of jobs to use for the computation: the `n_classes * ( n_classes - 1) / 2` OVO problems are computed in parallel. ``None`` means 1 unless in a :obj:`joblib.parallel_backend` context. ``-1`` means using all processors. See :term:`Glossary ` for more details. Attributes ---------- estimators_ : list of ``n_classes * (n_classes - 1) / 2`` estimators Estimators used for predictions. classes_ : numpy array of shape [n_classes] Array containing labels. n_classes_ : int Number of classes. pairwise_indices_ : list, length = ``len(estimators_)``, or ``None`` Indices of samples used when training the estimators. ``None`` when ``estimator``'s `pairwise` tag is False. n_features_in_ : int Number of features seen during :term:`fit`. .. versionadded:: 0.24 feature_names_in_ : ndarray of shape (`n_features_in_`,) Names of features seen during :term:`fit`. Defined only when `X` has feature names that are all strings. .. versionadded:: 1.0 See Also -------- OneVsRestClassifier : One-vs-all multiclass strategy. OutputCodeClassifier : (Error-Correcting) Output-Code multiclass strategy. Examples -------- >>> from sklearn.datasets import load_iris >>> from sklearn.model_selection import train_test_split >>> from sklearn.multiclass import OneVsOneClassifier >>> from sklearn.svm import LinearSVC >>> X, y = load_iris(return_X_y=True) >>> X_train, X_test, y_train, y_test = train_test_split( ... X, y, test_size=0.33, shuffle=True, random_state=0) >>> clf = OneVsOneClassifier( ... LinearSVC(random_state=0)).fit(X_train, y_train) >>> clf.predict(X_test[:10]) array([2, 1, 0, 2, 0, 2, 0, 1, 1, 1]) r/Nr0rrrcXlX lgrr)rXr0rs r7rOneVsOneClassifier.__init__s " r9Frc <^^^^^[UTS5 [TS40UD6m[TTTSS/SS9umm[T5 [R "T5Tl[TR 5S:Xa [S5eTR RSm[[[TRS 9"UUUUU4S j[T55565nUSTlTR!5R"R$nU(a USTlT$S TlT$) aFit underlying estimators. Parameters ---------- X : {array-like, sparse matrix} of shape (n_samples, n_features) Data. y : array-like of shape (n_samples,) Multi-class targets. **fit_params : dict Parameters passed to the ``estimator.fit`` method of each sub-estimator. .. versionadded:: 1.4 Only available if `enable_metadata_routing=True`. See :ref:`Metadata Routing User Guide ` for more details. Returns ------- self : object The fitted underlying estimator. r/csrcscF)rSrPrzAOneVsOneClassifier can not be fit when only one class is present.rrc 3># UHln[US-T5HUn[[5"TRTTTRUTRUTRR S9v MW Mn g7f)rr3N)rrrr0rr/)rrrr1 n_classesrrXr2s r7r)OneVsOneClassifier.fit../st 1"2A!&q1ui!8A 0 NN MM!, MM!,'4'>'>'B'B "9"2sA4A7N)rrr"rr(r)rr*rrlistrrrrrurrrpairwise_indices_)rXr1r2r3estimators_indicesrr#rs``` @@r7r/OneVsOneClassifier.fits&: *dE2'     !Quen 1 %Q' !  t}}  "S MM''* ! DKK0 1 1"'y!1 1   &.a0((*55>>:B!3A!6 IM r9r;c x^^^^[UTS5 [TS40UD6m[TU5nU(aQ[TRTRS- -S-5Vs/sHn[ TR 5PM snTl[[R"TTR55(a9[SR[R"T5TR55e[TTTSS/SUS9umm[!T5 ["R$"[TR5S5n['TR(S 9"UUUU4S j[+TRU555TlS Tl[/TRS S 5(aTRS R0TlT$s snf)aPartially fit underlying estimators. Should be used when memory is inefficient to train all data. Chunks of data can be passed in several iteration, where the first call should have an array of all target variables. Parameters ---------- X : {array-like, sparse matrix) of shape (n_samples, n_features) Data. y : array-like of shape (n_samples,) Multi-class targets. classes : array, shape (n_classes, ) Classes across all calls to partial_fit. Can be obtained via `np.unique(y_all)`, where y_all is the target vector of the entire dataset. This argument is only required in the first call of partial_fit and can be omitted in the subsequent calls. **partial_fit_params : dict Parameters passed to the ``estimator.partial_fit`` method of each sub-estimator. .. versionadded:: 1.4 Only available if `enable_metadata_routing=True`. See :ref:`Metadata Routing User Guide ` for more details. Returns ------- self : object The partially fitted underlying estimator. r;rz6Mini-batch contains {0} while it must be subset of {1}rr FrSrPrTrc 3># UHPunup#[[5"UTTTRUTRUTRRS9v MR g7fr)rrrr0r;)rr0rrr1rrXr2s r7r1OneVsOneClassifier.partial_fit..s` 8 &K! 6A + , a  a #0#:#:#F#F  &KsAANrr)rrrrrr r0rur*r(rrrrr)r"r itertools combinationsrrrr&rKr) rXr1r2r4r= first_callrr/rs ``` @r7r;OneVsOneClassifier.partial_fitFsR ,dMB'   ! 34A t$//A2EF!KL LAdnn%L D  r||At}}- . .HOOIIaL$--     %.#  1 %Q' --eDOO.DaH #4;;7 8 &))9)9L%J 8  "& 4##A&(8 9 9"&"2"21"5"D"DD  O sF7cURU5nURS:Xa<[URS5nURX#:R [ 5$URURSS9$)aEstimate the best class label for each sample in X. This is implemented as ``argmax(decision_function(X), axis=1)`` which will return the label of the class with most votes by estimators predicting the outcome of a decision for each possible class pair. Parameters ---------- X : {array-like, sparse matrix} of shape (n_samples, n_features) Data. Returns ------- y : numpy array of shape [n_samples] Predicted multi-class targets. r*rrrf)rBrrLrurrhrargmax)rXr1rrs r7r@OneVsOneClassifier.predictsk"  " "1 % ??a 243C3CA3FGF==!*!4!4S!9: :}}QXX1X-..r9c [U5 [UUSSSS9nURnUcU/[UR5-nOUVs/sH oASS2U4PM nn[ R "[URU5VVs/sHupVURU5PM snn5Rn[ R "[URU5VVs/sHupV[XV5PM snn5Rn[Xx[UR55n URS:Xa U SS2S4$U $s snfs snnfs snnf)aDecision function for the OneVsOneClassifier. The decision values for the samples are computed by adding the normalized sum of pair-wise classification confidence levels to the votes in order to disambiguate between the decision values when the votes for all the classes are equal leading to a tie. Parameters ---------- X : array-like of shape (n_samples, n_features) Input data. Returns ------- Y : array-like of shape (n_samples, n_classes) or (n_samples,) Result of calling `decision_function` on the final estimator. .. versionchanged:: 0.19 output shape changed to ``(n_samples,)`` to conform to scikit-learn conventions for binary classification. TFr+Nr*r)r!r"r&r*rur(vstackrr@rrGrrr) rXr1rXsidxrXi predictions confidencesrs r7rB$OneVsOneClassifier.decision_functions/,    #  (( ?s4++,,B'./wAsF)wB/ii,/0@0@",E F,ES[[_,E F ! ii589I9I25N O5N'#_S %5N O !  #;S=O P ??a QT7N0 G PsD>E E c,[UR5$rrrs r7rOneVsOneClassifier.n_classes_rr9c>[TU]5n[UR5RR URl[UR5RR URlU$rrrs r7r#OneVsOneClassifier.__sklearn_tags__rr9c[URRS9RU5R UR [ 5R SSS9R SSS9S9nU$rrrs r7r'OneVsOneClassifier.get_metadata_routingrr9)rr0rurrr&r)rlrmrnrorprrrrV__annotations__rr r/rrzr;r@rBrrrrrqr r s@r7r#r#sK\!%)*T"$D -1&+E EN/-01&+U 2 Un/..`""r9r#c^\rSrSr%Sr\"SS/5\"SS/5/\"\SSSS 9/S /\S/S .r \ \ S 'S SSS.Sjr \ "SS9S5rSrSrU4SjrSrU=r$)r%ia (Error-Correcting) Output-Code multiclass strategy. Output-code based strategies consist in representing each class with a binary code (an array of 0s and 1s). At fitting time, one binary classifier per bit in the code book is fitted. At prediction time, the classifiers are used to project new points in the class space and the class closest to the points is chosen. The main advantage of these strategies is that the number of classifiers used can be controlled by the user, either for compressing the model (0 < `code_size` < 1) or for making the model more robust to errors (`code_size` > 1). See the documentation for more details. Read more in the :ref:`User Guide `. Parameters ---------- estimator : estimator object An estimator object implementing :term:`fit` and one of :term:`decision_function` or :term:`predict_proba`. code_size : float, default=1.5 Percentage of the number of classes to be used to create the code book. A number between 0 and 1 will require fewer classifiers than one-vs-the-rest. A number greater than 1 will require more classifiers than one-vs-the-rest. random_state : int, RandomState instance, default=None The generator used to initialize the codebook. Pass an int for reproducible output across multiple function calls. See :term:`Glossary `. n_jobs : int, default=None The number of jobs to use for the computation: the multiclass problems are computed in parallel. ``None`` means 1 unless in a :obj:`joblib.parallel_backend` context. ``-1`` means using all processors. See :term:`Glossary ` for more details. Attributes ---------- estimators_ : list of `int(n_classes * code_size)` estimators Estimators used for predictions. classes_ : ndarray of shape (n_classes,) Array containing labels. code_book_ : ndarray of shape (n_classes, `len(estimators_)`) Binary array containing the code of each class. 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 See Also -------- OneVsRestClassifier : One-vs-all multiclass strategy. OneVsOneClassifier : One-vs-one multiclass strategy. References ---------- .. [1] "Solving multiclass learning problems via error-correcting output codes", Dietterich T., Bakiri G., Journal of Artificial Intelligence Research 2, 1995. .. [2] "The error coding method and PICTs", James G., Hastie T., Journal of Computational and Graphical statistics 7, 1998. .. [3] "The Elements of Statistical Learning", Hastie T., Tibshirani R., Friedman J., page 606 (second-edition) 2008. Examples -------- >>> from sklearn.multiclass import OutputCodeClassifier >>> from sklearn.ensemble import RandomForestClassifier >>> from sklearn.datasets import make_classification >>> X, y = make_classification(n_samples=100, n_features=4, ... n_informative=2, n_redundant=0, ... random_state=0, shuffle=False) >>> clf = OutputCodeClassifier( ... estimator=RandomForestClassifier(random_state=0), ... random_state=0).fit(X, y) >>> clf.predict([[0, 0, 0, 0]]) array([1]) r/rBrErINneither)closed random_stater0 code_sizerGrrg?)rIrGrc4XlX lX0lX@lgrrH)rXr0rIrGrs r7rOutputCodeClassifier.__init__s""( r9Frc ^^^ ^ [UTS5 [TS40UD6m [TSUS9n[TR5n[ U5 [ R"U5TlTRRSnUS:Xa [S5e[UTR-5nURXV4S9TlSTRTRS:'[TR S 5(aS TRTRS :g'OS TRTRS :g'[#TR5VVs0sHupxX_M n nn[ R$"['[)U55Vs/sHnTRXUPM sn[S 9m [+TR,S9"UU U U4Sj['T RS 555Tl[TR.SS5(aTR.SR0Tl[TR.SS5(aTR.SR2TlT$s snnfs snf)aFit underlying estimators. Parameters ---------- X : {array-like, sparse matrix} of shape (n_samples, n_features) Data. y : array-like of shape (n_samples,) Multi-class targets. **fit_params : dict Parameters passed to the ``estimator.fit`` method of each sub-estimator. .. versionadded:: 1.4 Only available if `enable_metadata_routing=True`. See :ref:`Metadata Routing User Guide ` for more details. Returns ------- self : object Returns a fitted instance of self. r/ no_validation)r1r2rz=OutputCodeClassifier can not be fit when no class is present.)sizeg?rJrBgrrIrrc3># UH@n[[5"TRTTSS2U4TRRS9v MB g7f)Nr")rr8r0r/)rrr1rrrXs r7r+OutputCodeClassifier.fit..sG8 ' K 1QT7}7N7N7R7R 'sAA rr)rrr"rrGrr(r)rrrrrIuniform code_book_rKr0rr<rr rrrurr) rXr1r2r3rGr# n_estimatorsrr6 classes_indexrrs `` @@r7r/OutputCodeClassifier.fits: *dE2'    $/Q 7)$*;*;< $Q' !  MM''* >O 9t~~56 '..Y4M.N14#-. 4>>#6 7 748DOODOOq0 147DOODOOq0 1*3DMM*BC*B$!*B C HH;@a;Q R;QaT__]Q40 1;Q R  $4;;78 1771:& 8   4##A&(8 9 9"&"2"21"5"D"DD  4##A&(; < <%)%5%5a%8%J%JD " 'D Ss I;I$c  [U5 [R"URVs/sHn[ X!5PM snS[R S9R n[X0RSS9nURU$s snf)zPredict multi-class targets using underlying estimators. Parameters ---------- X : {array-like, sparse matrix} of shape (n_samples, n_features) Data. Returns ------- y : ndarray of shape (n_samples,) Predicted multi-class targets. F)orderrQ euclidean)metric) r!r(r<rurGrirrrRr)rXr1rrrs r7r@OutputCodeClassifier.predictsu  HH,0,<,< =,sBc[URRS9RUR[ 5RSSS9S9nU$)rrr/rr)rrrlrr0rrs r7r)OutputCodeClassifier.get_metadata_routingsL dnn&=&=>BBnn(?..eE.JC  r9c>[TU]5n[UR5RR URlU$r)rrrr0rrrs r7r%OutputCodeClassifier.__sklearn_tags__s6w')!)$..!9!D!D!K!K r9) rrRrIr0rurrrrG)rlrmrnrorprrrrrrVrCrr r/r@rrrqr r s@r7r%r%saJ 23 4 / 0 tS$yAB'(T"$D03d &+K KZ#2*r9r%r)@rpr<r.r+numbersrrnumpyr( scipy.sparserrbaserrrr r r r r metrics.pairwiser preprocessingrutilsrutils._param_validationrr utils._tagsrutils.metadata_routingrrrrutils.metaestimatorsrrutils.multiclassrrrutils.parallelrrutils.validationrr r!r"__all__r8r>rGrLr.rzr$rrr#r%rrr9r7ros< "   8)%9! < . & 5M5Mp&p pf ,"j+_mjZ v- vr9