-iSSrSSKrSSKJrJr SSKJrJr SSKr SSK J r SSK J r JrJr SSKJr SS KJr SS KJr SS KJrJr SS KJr SS KJr SSKJr SSK J!r!J"r" "SS\\ \S9r#"SS\#5r$"SS\#5r%g)ad Label propagation in the context of this module refers to a set of semi-supervised classification algorithms. At a high level, these algorithms work by forming a fully-connected graph between all points given and solving for the steady-state distribution of labels at each point. These algorithms perform very well in practice. The cost of running can be very expensive, at approximately O(N^3) where N is the number of (labeled and unlabeled) points. The theory (why they perform so well) is motivated by intuitions from random walk algorithms and geometric relationships in the data. For more information see the references below. Model Features -------------- Label clamping: The algorithm tries to learn distributions of labels over the dataset given label assignments over an initial subset. In one variant, the algorithm does not allow for any errors in the initial assignment (hard-clamping) while in another variant, the algorithm allows for some wiggle room for the initial assignments, allowing them to change by a fraction alpha in each iteration (soft-clamping). Kernel: A function which projects a vector into some higher dimensional space. This implementation supports RBF and KNN kernels. Using the RBF kernel generates a dense matrix of size O(N^2). KNN kernel will generate a sparse matrix of size O(k*N) which will run much faster. See the documentation for SVMs for more info on kernels. Examples -------- >>> import numpy as np >>> from sklearn import datasets >>> from sklearn.semi_supervised import LabelPropagation >>> label_prop_model = LabelPropagation() >>> iris = datasets.load_iris() >>> rng = np.random.RandomState(42) >>> random_unlabeled_points = rng.rand(len(iris.target)) < 0.3 >>> labels = np.copy(iris.target) >>> labels[random_unlabeled_points] = -1 >>> label_prop_model.fit(iris.data, labels) LabelPropagation(...) Notes ----- References: [1] Yoshua Bengio, Olivier Delalleau, Nicolas Le Roux. In Semi-Supervised Learning (2006), pp. 193-216 [2] Olivier Delalleau, Yoshua Bengio, Nicolas Le Roux. Efficient Non-Parametric Function Induction in Semi-Supervised Learning. AISTAT 2005 N)ABCMetaabstractmethod)IntegralReal)sparse) BaseEstimatorClassifierMixin _fit_context)ConvergenceWarning) rbf_kernel)NearestNeighbors)Interval StrOptions)safe_sparse_dot) laplacian)check_classification_targets)check_is_fitted validate_datac ^\rSrSr%Sr\"SS15\/\"\SSSS9/\"\ SSS S9/S\"\SS S S9/\"\ SSS S9/\"\SSSS9/S\ /S .r \ \ S 'SS SS SSSS.Sjjr SSjr\S5rSrSr\"SS9S5rU4SjrSrU=r$)BaseLabelPropagationLaBase class for label propagation module. Parameters ---------- kernel : {'knn', 'rbf'} or callable, default='rbf' String identifier for kernel function to use or the kernel function itself. Only 'rbf' and 'knn' strings are valid inputs. The function passed should take two inputs, each of shape (n_samples, n_features), and return a (n_samples, n_samples) shaped weight matrix. gamma : float, default=20 Parameter for rbf kernel. n_neighbors : int, default=7 Parameter for knn kernel. Need to be strictly positive. alpha : float, default=1.0 Clamping factor. max_iter : int, default=30 Change maximum number of iterations allowed. tol : float, default=1e-3 Convergence tolerance: threshold to consider the system at steady state. n_jobs : int, default=None The number of parallel jobs to run. ``None`` means 1 unless in a :obj:`joblib.parallel_backend` context. ``-1`` means using all processors. See :term:`Glossary ` for more details. knnrbfrNleftclosedneitherkernelgamma n_neighborsalphamax_itertoln_jobs_parameter_constraintsMbP?r"r#r$r%r&r'cXXPlX`lXlX lX0lX@lXplgN)r%r&r!r"r#r$r')selfr!r"r#r$r%r&r's ]/var/www/html/venv/lib/python3.13/site-packages/sklearn/semi_supervised/_label_propagation.py__init__BaseLabelPropagation.__init__xs,!   &  cBURS:Xa+Uc[XURS9$[XURS9$URS:XaURc2[ UR UR S9RU5UlUc9URRURRUR SS9$URRUSS9$[UR5(a%UcURX5$URX5$g) Nr)r"r)r#r' connectivity)modeF)return_distance) r!r r"nn_fitrr#r'fitkneighbors_graph_fit_X kneighborscallable)r0Xys r1 _get_kernel BaseLabelPropagation._get_kernels ;;% y!!djj99!!djj99 [[E !{{". $ 0 0#a& y{{33KK&&(8(8~4{{--a-GG dkk " "y{{1(({{1(( #r4c[S5e)NzHGraph construction must be implemented to fit a label propagation model.)NotImplementedError)r0s r1 _build_graph!BaseLabelPropagation._build_graphs! V  r4cURU5nUR[R"USS9R 5$)zPerform inductive inference across the model. Parameters ---------- X : array-like of shape (n_samples, n_features) The data matrix. Returns ------- y : ndarray of shape (n_samples,) Predictions for input data. raxis) predict_probaclasses_npargmaxravel)r0r?probass r1predictBaseLabelPropagation.predicts7"##A&}}RYYvA67==??r4c [U5 [UU/SQSS9nURURU5nURS:XaH[ R "UVs/sH%n[ R"URUSS9PM' sn5nO!URn[X0R5n[ R"[ R"USS95RnXV-nU$s snf)aPredict probability for each possible outcome. Compute the probability estimates for each single sample in X and each possible outcome seen during training (categorical distribution). Parameters ---------- X : array-like of shape (n_samples, n_features) The data matrix. Returns ------- probabilities : ndarray of shape (n_samples, n_classes) Normalized probability distributions across class labels. )csccsrcoodokbsrlildiaF accept_sparseresetrrrHr) rrrAX_r!rLarraysumlabel_distributions_Tr atleast_2d)r0r?X_2dweight_matrices weight_matrix probabilities normalizers r1rJ"BaseLabelPropagation.predict_probas$   K   **477D9 ;;% HH*9)8 FF444]C!L)8M.//O+O=V=VWM]]266-a#@ACC # s,C(T)prefer_skip_nested_validationc[UUUSS/SS9upXl[U5 UR5n[R "U5nXDS:gnX@l[U5[U5pe[R"U5nUS:Hn[R"XV45Ul UHnSURX(:HXH:H4'M [R"UR5n URS:XaSX'OU SUR- -n [R"URRSU45n US S 2[R4n[ R""U5(aUR%5n['UR(5GH,Ul[R,"URU - 5R/5UR0:a GO!URn [3X0R5Ul URS:Xax[R."URSS 9S S 2[R4n SXS:H'U=RU -sl [R4"XpRU 5Ul M[R6"URUR5U -Ul GM/ [8R:"S UR(-[<S 9 U=R*S- sl[R."URSS 9S S 2[R4n SXS:H'U=RU -sl UR [R>"URSS 9n U RA5Ul!U$) aFit a semi-supervised label propagation model to X. The input samples (labeled and unlabeled) are provided by matrix X, and target labels are provided by matrix y. We conventionally apply the label -1 to unlabeled samples in matrix y in a semi-supervised classification. Parameters ---------- X : {array-like, sparse matrix} of shape (n_samples, n_features) Training data, where `n_samples` is the number of samples and `n_features` is the number of features. y : array-like of shape (n_samples,) Target class values with unlabeled points marked as -1. All unlabeled samples will be transductively assigned labels internally, which are stored in `transduction_`. Returns ------- self : object Returns the instance itself. rTrSTrZr propagationrNrHz,max_iter=%d was reached without convergence.)category)"rr]rrErLuniquerKlenasarrayzerosr`copy_variantr$shapenewaxisrissparsetocsrranger%n_iter_absr_r&rwheremultiplywarningswarnr rMrN transduction_) r0r?r@ graph_matrixclasses n_samples n_classes unlabeledlabely_static l_previousrg transductions r1r:BaseLabelPropagation.fits2   %.  $Q'((* ))A,R-( "1vs7|9 JJqMG %'HHi-C$D!EFGD % %aj'2B&B C774445 ==M )"#H  DJJ &HXXtww}}Q/;< am, ??< ( ('--/L!$--0DLvvd//*<=AACdhhN22J(777)D %}} -VVD$=$=AFq"**}U ./ ?+))Z7),.HH88(-) KK D,E,EFQ)%1, MM>N+  LLA LVVD55A>q"**}M &' ?# !!Z/!}}RYYt/H/Hq%QR )//1 r4cF>[TU]5nSURlU$)NT)super__sklearn_tags__ input_tagsr)r0tags __class__s r1r%BaseLabelPropagation.__sklearn_tags__Ss!w')!% r4) r]r$rKr"r!r`r%ryr'r#r9r&rrr/)__name__ __module__ __qualname____firstlineno____doc__rr>rrrr(dict__annotations__r2rArrErPrJr r:r__static_attributes__ __classcell__rs@r1rrLsDuen-x84D89 1d9EFq!I>?h4 BCq$v67"$D 0).  @('R5f6fPr4r) metaclassc^\rSrSr%SrSr0\REr\\ S'\RS5 SSSSS S S .U4S jjjr S r U4Sjr SrU=r$)LabelPropagationiYa Label Propagation classifier. Read more in the :ref:`User Guide `. Parameters ---------- kernel : {'knn', 'rbf'} or callable, default='rbf' String identifier for kernel function to use or the kernel function itself. Only 'rbf' and 'knn' strings are valid inputs. The function passed should take two inputs, each of shape (n_samples, n_features), and return a (n_samples, n_samples) shaped weight matrix. gamma : float, default=20 Parameter for rbf kernel. n_neighbors : int, default=7 Parameter for knn kernel which need to be strictly positive. max_iter : int, default=1000 Change maximum number of iterations allowed. tol : float, default=1e-3 Convergence tolerance: threshold to consider the system at steady state. n_jobs : int, default=None The number of parallel jobs to run. ``None`` means 1 unless in a :obj:`joblib.parallel_backend` context. ``-1`` means using all processors. See :term:`Glossary ` for more details. Attributes ---------- X_ : {array-like, sparse matrix} of shape (n_samples, n_features) Input array. classes_ : ndarray of shape (n_classes,) The distinct labels used in classifying instances. label_distributions_ : ndarray of shape (n_samples, n_classes) Categorical distribution for each item. transduction_ : ndarray of shape (n_samples) Label assigned to each item during :term:`fit`. 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 n_iter_ : int Number of iterations run. See Also -------- LabelSpreading : Alternate label propagation strategy more robust to noise. References ---------- Xiaojin Zhu and Zoubin Ghahramani. Learning from labeled and unlabeled data with label propagation. Technical Report CMU-CALD-02-107, Carnegie Mellon University, 2002 http://pages.cs.wisc.edu/~jerryzhu/pub/CMU-CALD-02-107.pdf Examples -------- >>> import numpy as np >>> from sklearn import datasets >>> from sklearn.semi_supervised import LabelPropagation >>> label_prop_model = LabelPropagation() >>> iris = datasets.load_iris() >>> rng = np.random.RandomState(42) >>> random_unlabeled_points = rng.rand(len(iris.target)) < 0.3 >>> labels = np.copy(iris.target) >>> labels[random_unlabeled_points] = -1 >>> label_prop_model.fit(iris.data, labels) LabelPropagation(...) rlr(r$r)r*ir,N)r"r#r%r&r'c ,>[TU]UUUUUUSS9 g)N)r!r"r#r%r&r'r$rr2)r0r!r"r#r%r&r'rs r1r2LabelPropagation.__init__s, #  r4cnURS:XaSUlURUR5nUR SS9n[ R "U5(a?U=R[R"[R"U55-slU$XSS2[R4-nU$)zMatrix representing a fully connected graph between each sample This basic implementation creates a non-stochastic affinity matrix, so class distributions will exceed 1 (normalization may be desired). rNrrH) r!r9rAr]r_rrvdatarLdiagr^ru)r0affinity_matrixrgs r1rELabelPropagation._build_graphs ;;% DK**4773$((a(0 ??? + +  BGGBHHZ,@$A A  !RZZ-8 8Or4c">[TU]X5$)aFit a semi-supervised label propagation model to X. Parameters ---------- X : {array-like, sparse matrix} of shape (n_samples, n_features) Training data, where `n_samples` is the number of samples and `n_features` is the number of features. y : array-like of shape (n_samples,) Target class values with unlabeled points marked as -1. All unlabeled samples will be transductively assigned labels internally, which are stored in `transduction_`. Returns ------- self : object Returns the instance itself. )rr:)r0r?r@rs r1r:LabelPropagation.fits&w{1  r4r9r)rrrrrrsrr(rrpopr2rEr:rrrs@r1rrYsjRhH#R&:&Q&Q#RDRw'    ( !!r4rc^\rSrSr%SrSr0\REr\\ S'\ "\ SSSS9/\S 'SS S S S SSS.U4Sjjjr Sr SrU=r$)LabelSpreadingia LabelSpreading model for semi-supervised learning. This model is similar to the basic Label Propagation algorithm, but uses affinity matrix based on the normalized graph Laplacian and soft clamping across the labels. Read more in the :ref:`User Guide `. Parameters ---------- kernel : {'knn', 'rbf'} or callable, default='rbf' String identifier for kernel function to use or the kernel function itself. Only 'rbf' and 'knn' strings are valid inputs. The function passed should take two inputs, each of shape (n_samples, n_features), and return a (n_samples, n_samples) shaped weight matrix. gamma : float, default=20 Parameter for rbf kernel. n_neighbors : int, default=7 Parameter for knn kernel which is a strictly positive integer. alpha : float, default=0.2 Clamping factor. A value in (0, 1) that specifies the relative amount that an instance should adopt the information from its neighbors as opposed to its initial label. alpha=0 means keeping the initial label information; alpha=1 means replacing all initial information. max_iter : int, default=30 Maximum number of iterations allowed. tol : float, default=1e-3 Convergence tolerance: threshold to consider the system at steady state. n_jobs : int, default=None The number of parallel jobs to run. ``None`` means 1 unless in a :obj:`joblib.parallel_backend` context. ``-1`` means using all processors. See :term:`Glossary ` for more details. Attributes ---------- X_ : ndarray of shape (n_samples, n_features) Input array. classes_ : ndarray of shape (n_classes,) The distinct labels used in classifying instances. label_distributions_ : ndarray of shape (n_samples, n_classes) Categorical distribution for each item. transduction_ : ndarray of shape (n_samples,) Label assigned to each item during :term:`fit`. 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 n_iter_ : int Number of iterations run. See Also -------- LabelPropagation : Unregularized graph based semi-supervised learning. References ---------- `Dengyong Zhou, Olivier Bousquet, Thomas Navin Lal, Jason Weston, Bernhard Schoelkopf. Learning with local and global consistency (2004) `_ Examples -------- >>> import numpy as np >>> from sklearn import datasets >>> from sklearn.semi_supervised import LabelSpreading >>> label_prop_model = LabelSpreading() >>> iris = datasets.load_iris() >>> rng = np.random.RandomState(42) >>> random_unlabeled_points = rng.rand(len(iris.target)) < 0.3 >>> labels = np.copy(iris.target) >>> labels[random_unlabeled_points] = -1 >>> label_prop_model.fit(iris.data, labels) LabelSpreading(...) spreadingr(rrrrr$r)r*g?r+r,Nr-c ,>[TU]UUUUUUUS9 g)Nr r) r0r!r"r#r$r%r&r'rs r1r2LabelSpreading.__init__Rs, #  r4cjURS:XaSUlURRSnUR UR5n[ USS9nU*n[ R"U5(a*URUR:HnSURU'U$SURSSUS-2'U$)z=Graph matrix for Label Spreading computes the graph laplacianrNrT)normedgr) r!r9r]rtrAcsgraph_laplacianrrvrowcolrflat)r0rrr diag_masks r1rELabelSpreading._build_graphhs ;;% DKGGMM!$ **4773%odC J ??9 % %! 6I(+INN9 %03INN+i!m+ ,r4rr)rrrrrrsrr(rrrrr2rErrrs@r1rrss]~H#R&:&Q&Q#RDR'/a9'M&N7#    ,r4r)&rr}abcrrnumbersrrnumpyrLscipyrbaser r r exceptionsr metrics.pairwiser neighborsrutils._param_validationrr utils.extmathr utils.fixesrrutils.multiclassrutils.validationrrrrrr4r1rsl3p'"??+)(:+8;=J?MWJZQ!+Q!hI)Ir4