0PhլdZddlZddlZddlZddlmZmZddlZddl m Z ddl m Z mZmZmZmZmZmZmZddlmZddlmZddlmZdd lmZmZdd lmZdd l m!Z!m"Z"m#Z#m$Z$dd l%m&Z&m'Z'dd l(m)Z)m*Z*m+Z+ddl,m-Z-m.Z.ddl/m0Z0m1Z1m2Z2m3Z3gdZ4d dZ5dZ6dZ7dZ8Gdde Z9dZ:Gddeeee Z;dZGddeee Z?dS)!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)OneVsRestClassifierOneVsOneClassifierOutputCodeClassifierc\tj|}t|dkrf|A|ddkrd}n|d}tjdt ||zt ||}nt|}|j||fi||S)zFit a single binary estimator.rNrz-Label %s is present in all training examples.) npuniquelenwarningswarnstr_ConstantPredictorfitr ) estimatorXy fit_paramsclassesunique_ycs R/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/sklearn/multiclass.py _fit_binaryr8Qsy||H 8}}  trzzaD M?#gaj//Q   '((,,Q99 )$$  a))j))) cL|j||fdtjdi||S)z(Partially fit a single binary estimator.r4)rr) partial_fitr(array)r0r1r2partial_fit_paramss r7_partial_fit_binaryr>ds5I!QOO(8(8O.checksG 4 ' ' * D$Q' . . . . DND ) ) )tr9rk)rprqs` r7_estimators_hasrrs# Lr9ceZdZdZedggedgdgdZddddZed d Z e e d ed dd Z dZ e e ddZe e ddZedZedZfdZdZxZS)r#a;One-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_jobsrtrrvrtc0||_||_||_dSNru)rWr0rvrts r7__init__zOneVsRestClassifier.__init__Bs"  r9Fprefer_skip_nested_validationc dt|dtdfi|td_j|}|}jj_d|jD}tj j fdt|D_ tj ddrj dj_tj dd rj dj_S) aFit 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_outputc3bK|]*}|V+dSrytoarrayrA.0cols r7 z*OneVsRestClassifier.fit..t688S3;;==&&((888888r9rwc 3K|]]\}}ttj|jjdjj|zjj|gV^dS)znot %sr3r4N)rr8r0r/label_binarizer_classes_)ricolumnr1 routed_paramsrWs r7rz*OneVsRestClassifier.fit..xs N N 6 !GK (26t4=a@@)215    N N N N N N r9rn_features_in_feature_names_in_)rrrr fit_transformtocscrTrrvrt enumeraternrKrr)rWr1r2r3Ycolumnsrs`` @r7r/zOneVsRestClassifier.fitGsg< *dE222'      !/T B B B  ! / / 2 2 GGII-6 88AC888N84; MMM N N N N N N 'w// N N N    4#A&(8 9 9 E"&"21"5"DD  4#A&(; < < K%)%5a%8%JD " r9r;c Ft|dtdfi|t|rYfdtjD_t d_jj ttj |j r:tdtj|j j|}|}d|jD}t'jfdt+j|D_t-jd d rjd j_S) aPartially 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;c8g|]}tjSrkr r0r_rWs r7 z3OneVsRestClassifier.partial_fit..s#VVV!dn 5 5VVVr9Tr~z;Mini-batch contains {0} while classes must be subset of {1}c3bK|]*}|V+dSryrrs r7rz2OneVsRestClassifier.partial_fit..rr9rvc3tK|]2\}}tt||jjV3dSr=N)rr>r0r;)rr0rr1rs r7rz2OneVsRestClassifier.partial_fit..si8 8 " 6 )G' ( (#0#:#F    8 8 8 8 8 8 r9rr)rrrrange n_classes_rnrrr/rr*r( setdiff1d ValueErrorformatr) transformrrrrvziprKr)rWr1r2r4r=rrrs`` @r7r;zOneVsRestClassifier.partial_fitsR ,dMBBB'    !  )w 7 7 5VVVVuT_?U?UVVVD  %3$F$F$FD !  ! % %dm 4 4 4 r|At}-- . . V&1t}55   ! + +A . . GGII88AC888784;7778 8 8 8 8 &))97%C%C8 8 8    4#A&(8 9 9 E"&"21"5"DD  r9c t|t|}|jjdkrt j|t }|tj t j |t}t|j D]5\}}t||}t j|||||||k<6|j|St!|j d}t#jd} t#jddg} |j D]c}| t jt|||kd| t+| dt jt+| t} t/j| | | f|t+|j f} |j| S)agPredict 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. multiclassrP)outrr)shape)r!r ry_type_r(emptyfloatfillinfzerosintrrnrGmaximumrrLr<extendwhereappendr*onessp csc_matrixinverse_transform) rWr1 n_samplesmaxima argmaximarepredthreshindicesindptrdata indicators r7r@zOneVsRestClassifier.predicts  OO  (L 8 8Xiu555F KK #666I!$"233 . .1&q!,, 64V4444,- &D.))=+ +243CA3FGGFk#&&G[qc**F% , ,rx1(=(=(FGGJKKK c'll++++73w<.$s2III1aooa((A.IIIr9rrbN) r!r(r<rnrr* concatenate multilabel_sumnewaxis)rWr1rs ` r7rEz!OneVsRestClassifier.predict_probas2  HIIII8HIII J J L t A % %Q|!444A 2 """111bj=1 1Ar9rBct|t|jdkr |jdSt jfd|jDjS)aDecision 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. rrc^g|])}|*Srk)rBrA)restr1s r7rz9OneVsRestClassifier.decision_function..Ks3 J J J#S " "1 % % + + - - J J Jr9)r!r*rnrBr(r<rr^s `r7rBz%OneVsRestClassifier.decision_function0sv.  t A % %#A&88;; ;x J J J J9I J J J   r9c@|jjdS)z(Whether this is a multilabel classifier. multilabel)rr startswithrWs r7rzOneVsRestClassifier.multilabel_Ns$,77 EEEr9c*t|jSzNumber of classes.r*rrs r7rzOneVsRestClassifier.n_classes_S4=!!!r9ct}t|jjj|j_t|jjj|j_|Sz@Indicate if wrapped estimator is using a precomputed Gram matrixsuper__sklearn_tags__rr0 input_tagspairwisesparserWtags __class__s r7rz$OneVsRestClassifier.__sklearn_tags__XQww''))#+DN#;#;#F#O !)$.!9!9!D!K r9ct|jj||jt dddd}|SjGet 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_mappingrrrgadd_self_requestaddr0rrWrouters r7get_metadata_routingz(OneVsRestClassifier.get_metadata_routing_s !8 9 9 9  d # # S.,E%00M-@@   r9ry)rgrhrirjrr_parameter_constraintsrzr r/rrrr;r@rErBpropertyrrrr __classcell__rs@r7r#r#s jjZ!j%))*T"; -1! \&+@@ @D\//-0011\&+NNN 21 N`$F$F$FL\///2233%%43%N\//"56677  87 :FFXF""X"r9r#c ~tj||k||k}||}tj|jt}d|||k<d|||k<tjt ||}t|||} t|t||d|d|| ||g|fS)z+Fit a single binary estimator (one-vs-one).rrparamsrN)rr) r( logical_orrrraranger rr8r) r0r1r2rjr3condy_binaryindcondfit_params_subsets r7_fit_ovo_binaryr{s =aa ( (D $Ax%%HHQ!VHQ!Vi Q((.G,Qz7SSS   1dG < < ) r0r1r2rrr=rrpartial_fit_params_subsets r7_partial_fit_ovo_binaryrs =aa ( (D $A 1vv{{=##a$8 ($% % % !# qw=V     r9ceZdZUdZedggedgdZeed<dddZ e d d Z e e d e d dd Zd ZdZedZfdZdZxZS)r$a 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/Nr0rvrrc"||_||_dSryr )rWr0rvs r7rzzOneVsOneClassifier.__init__s" r9Fr{c Xt|dtdfi|tddgd\tt j_tjdkrtdjj dtttj fd tD}|d_jj}|r|dnd _S) 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)rRrOrzAOneVsOneClassifier can not be fit when only one class is present.rrc 3K|]b}t|dzD]L}ttjj|j|jjVMcdS)rr3N)rrrr0rr/)rrrr1 n_classesrrWr2s r7rz)OneVsOneClassifier.fit..-s 1 1!&q1ui!8!8 1 1100 N M!, M!,'4'>'B  1 1 1 1 1 1 1r9N)rrr"rr(r)rr*rrlistrrrvrrnrrrpairwise_indices_)rWr1r2r3estimators_indicesrrrs``` @@r7r/zOneVsOneClassifier.fits}: *dE222'       !Quen   1 %Q''' !  t}   " "S M'* ! 0HDK000 1 1 1 1 1 1 1 1"'y!1!1 1 1 1     &.a0((**5>:B!L!3A!6!6 r9r;c 4t|dtdfi|t|}|r3fdtjjdz zdzD_t tjj r:td tj j tddgd| \ttjtjd}t#j fd t'j|D_d _t+jd drjd j_S)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;c8g|]}tjSrkrrs r7rz2OneVsOneClassifier.partial_fit..ws3   dn%%   r9rz6Mini-batch contains {0} while it must be subset of {1}r rFrRrOrSrc 3K|]M\}\}}tt|j|j|jjVNdSr)rrrr0r;)rr0rrr1rrWr2s r7rz1OneVsOneClassifier.partial_fit..s 8 8 " 6Aq -G+ , , a  a #0#:#F     8 8 8 8 8 8 r9Nrr)rrrrrrnr*r(rrrrr)r"r itertools combinationsrrvrrrKr)rWr1r2r4r= first_callrrs``` @r7r;zOneVsOneClassifier.partial_fitDsR ,dMBBB'    !  34AA      t$/A2EF!KLL   D  r|At}-- . . HOOIaLL$-     %.#    1 %Q''' -eDO.D.DaHH 784;777 8 8 8 8 8 8 8 &))9L%J%J 8 8 8   "& 4#A&(8 9 9 E"&"21"5"DD  r9c ||}|jdkrCt|jd}|j||kt S|j|dS)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. rrrrb)rBrrLrnrrdrargmax)rWr1rrs r7r@zOneVsOneClassifier.predictss"  " "1 % % ?a  243CA3FGGF=!f*!4!4S!9!9: :}QXX1X--..r9ct|t|ddd|j}|gt|jz}nfd|D}t jdt|j|Dj}t jdt|j|Dj}t||t|j }|j dkr |ddd fS|S) a.Decision 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. TFrNc(g|]}dd|fSryrk)ridxr1s r7rz8OneVsOneClassifier.decision_function..s%///!AAAsF)///r9c>g|]\}}||Srk)r@rrXis r7rz8OneVsOneClassifier.decision_function..s& F F FbS[[__ F F Fr9c4g|]\}}t||SrkrGr#s r7rz8OneVsOneClassifier.decision_function..s& O O O'#r_S" % % O O Or9rr) r!r"rr*rnr(vstackrrrrr)rWr1rXs predictions confidencesrs ` r7rBz$OneVsOneClassifier.decision_functions#,    #    ( ?s4+,,,BB////w///Bi F FC0@",E,E F F F   i O OS9I25N5N O O O    #; S=O=O P P ?a  QQQT7Nr9c*t|jSrrrs r7rzOneVsOneClassifier.n_classes_rr9ct}t|jjj|j_t|jjj|j_|Srrrs r7rz#OneVsOneClassifier.__sklearn_tags__rr9ct|jj||jt dddd}|Srrrs r7rz'OneVsOneClassifier.get_metadata_routingrr9ry)rgrhrirjrrrrU__annotations__rzr r/rrrr;r@rBrrrrrrs@r7r$r$syKK\!j%))*T"$$D -1\&+EE EN\//-0011\&+UUU 21 Un///....`""X"r9r$ceZdZUdZeddgeddggeedddgd gedgd Ze e d <d ddd dZ e ddZ dZdZfdZxZS)r%a(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_sizer2rvrg?)r4r2rvc>||_||_||_||_dSryr3)rWr0r4r2rvs r7rzzOutputCodeClassifier.__init__}s#""( r9Fr{c ^ t|dtdfi| tdtj}t t j_jj d}|dkrtdt|j z}| ||f_djjdk<tjd rd jjd k<nd jjd k<d t#jDt jfdt't)Dtt+j fdt'j d D_tjddrjdj_tjddrjdj_S)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?rJrBgrrIci|]\}}|| Srkrk)rrr6s r7 z,OutputCodeClassifier.fit..sCCC$!QACCCr9cBg|]}j|Srk) code_book_)rr classes_indexrWr2s r7rz,OutputCodeClassifier.fit..s) R R RaT_]1Q40 1 R R Rr9rrc3K|]>}ttjdd|fjjV?dS)Nr)rr8r0r/)rrr1rrrWs r7rz+OutputCodeClassifier.fit..so8 8  !GK 1QQQT7}7N7R   8 8 8 8 8 8 r9rr)rrr"rr2rr(r)rrrrr4uniformr<rKr0rr<rr rrvrnrr) rWr1r2r3r2r n_estimatorsrr=rs ``` @@@r7r/zOutputCodeClassifier.fitsd: *dE222'      $/Q 7 7 7)$*;<< $Q''' !  M'* >>O 9t~566 '..Y 4M.NN14#-. 4>#6 7 7 848DODOq0 1 147DODOq0 1CC)DM*B*BCCC H R R R R R R5a;Q;Q R R R    884;7778 8 8 8 8 8 8 171:&& 8 8 8    4#A&(8 9 9 E"&"21"5"DD  4#A&(; < < K%)%5a%8%JD " r9ct|tjfd|jDdtjj}t ||jd}|j|S)a9Predict 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. c0g|]}t|Srkr&rs r7rz0OutputCodeClassifier.predict..s# = = =q_Q " " = = =r9F)orderrP euclidean)metric) r!r(r<rnrerrr<r)rWr1rrs ` r7r@zOutputCodeClassifier.predictsz  H = = = =D,< = = =*    )DOKPPP}T""r9ct|jj|jt dd}|S)rrr/rr)rrrgrr0rrs r7rz)OutputCodeClassifier.get_metadata_routingsU dn&=>>>BBn(??..eE.JJC   r9ct}t|jjj|j_|Sry)rrrr0rrrs r7rz%OutputCodeClassifier.__sklearn_tags__s7ww''))!)$.!9!9!D!K r9)rgrhrirjrrrrrrUr.rzr r/r@rrrrs@r7r%r%s0aaJ J23 4 4 J/ 0 0 htS$yAAAB'(T"$$D03d \&+KK KZ###2*r9r%ry)@rjr<rr+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.rrr#rrr$r%rkr9r7rXss< """"""""                    877777))))))%%%%%%99999999!!!!!! <;;;;;;; .-------   &   5M5M5M5M5M5M5M5Mp&nnnnn nnnb ,"jjjjj+_mjjjZ vvvvv- vvvvvr9