0PhSdZddlZddlmZmZddlmZmZddlZ ddl m Z ddl m Z mZmZddlmZdd lmZdd lmZdd lmZmZdd lmZdd lmZddlmZddl m!Z!m"Z"Gddee eZ#Gdde#Z$Gdde#Z%dS)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 \eZdZUdZeddhegeedddgeedddgdeedd dgeedddgeedddgdegd Z e e d < dd d d dddddZ ddZ edZdZdZeddZfdZxZS)BaseLabelPropagationafBase 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&ch||_||_||_||_||_||_||_dSN)r$r%r r!r"r#r&)selfr r!r"r#r$r%r&s j/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/sklearn/semi_supervised/_label_propagation.py__init__zBaseLabelPropagation.__init__xs>!   &  c|jdkr0|t|||jSt|||jS|jdkr|j3t |j|j||_|,|j|jj |jdS|j |dSt|jr.||||S|||SdS) Nr)r!r)r"r& connectivity)modeF)return_distance) r r r!nn_fitrr"r&fitkneighbors_graph_fit_X kneighborscallable)r/Xys r0 _get_kernelz BaseLabelPropagation._get_kernels  ;%  y!!Qdj9999!!Qdj9999 [E ! !{". $ 0#a&& y{33K&(8~4{--a-GGG dk " " )y{{1a((({{1a(((  ) )r2c td)NzHGraph construction must be implemented to fit a label propagation model.)NotImplementedError)r/s r0 _build_graphz!BaseLabelPropagation._build_graphs! V   r2c||}|jtj|dS)a%Perform 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)r/r=probass r0predictzBaseLabelPropagation.predicts?"##A&&}RYvA6667==???r2cztt|gdd}j|}jdkr!t jfd|D}n|j}t|j }t j t j |dj}||z}|S)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_sparseresetrcRg|]#}tjj|d$S)rrD)rHsumlabel_distributions_).0 weight_matrixr/s r0 z6BaseLabelPropagation.predict_proba..s@%F44]C!LLLr2rrD) rrr?X_r rHarrayTrrZ atleast_2drY)r/r=X_2dweight_matrices probabilities normalizers` r0rFz"BaseLabelPropagation.predict_probas$   KKK     **47D99 ;%  H)8MM./O+OT=VWWM]26-a#@#@#@AAC # r2T)prefer_skip_nested_validationc~t|||ddgd\}}||_t||}t j|}||dk}||_t|t|}}t j|}|dk}t j ||f|_ |D]}d|j ||k||kf<t j |j } |j dkrd| |<n | d|j z z} t j |jjd|f} |d d tjf}t!j|r|}t'|jD]|_t j|j | z |jkrn|j } t3||j |_ |j dkrit j|j d d d tjf} d| | dk<|xj | zc_ t j||j | |_ t j|j |j | z|_ t9jd |jzt< |xjdz c_t j|j d d d tjf} d| | dk<|xj | zc_ |jt j|j d } | |_!|S) a~Fit 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. rOrNTrUr propagationrNrDz,max_iter=%d was reached without convergence.)category)"rr^rrBrHuniquerGlenasarrayzerosrZcopy_variantr#shapenewaxisrissparsetocsrranger$n_iter_absrYr%rwheremultiplywarningswarnr rIrJ transduction_) r/r=r> graph_matrixclasses n_samples n_classes unlabeledlabely_static l_previousre transductions r0r8zBaseLabelPropagation.fitsH2   %.    1$Q'''((** )A,,'R-( "1vvs7||9 JqMMG %'Hi-C$D$D! H HEFGD %a5j'U2B&B C C74455 =M ) )"#HY   DJ &HXtw}Q/;<< aaam, ?< ( ( 0'--//L!$-00  DLvd/*<==AACCdhNN2J(7d7))D %} --VD$=AFFFqqq"*}U ./ :?+))Z7)),.Ht8(--)) K D,EFFQ)) M>N+     LLA LLVD5A>>>qqq"*}M &' :?# !!Z/!!}RYt/Hq%Q%Q%QR )//11 r2c`t}d|j_|S)NT)super__sklearn_tags__ input_tagsr)r/tags __class__s r0rz%BaseLabelPropagation.__sklearn_tags__Ss'ww''))!% r2rr.)__name__ __module__ __qualname____doc__rr<rrrr'dict__annotations__r1r?rrBrLrFr r8r __classcell__rs@r0rrLsD:uen--x8(4D8889 1d9EEEFq!I>>>?Xh4 BBBCq$v6667"$$D 0)))).  ^ @@@('''R\555ff65fPr2r) metaclassceZdZUdZdZiejZeed<e d ddddd d d fd Z d Z fdZ xZ S)LabelPropagationa 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(...) rir'r#rr(r)ir+N)r!r"r$r%r&c Xt||||||ddS)N)r r!r"r$r%r&r#rr1)r/r r!r"r$r%r&rs r0r1zLabelPropagation.__init__sE #      r2cN|jdkrd|_||j}|d}t j|r5|xjtj tj |zc_n||ddtj fz}|S)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). rNrrD) r r7r?r^rYrrsdatarHdiagr_rr)r/affinity_matrixres r0rBzLabelPropagation._build_graphs ;%  DK**4733$((a(00 ?? + + 9  BGBHZ,@,@$A$A A z!!!RZ-8 8Or2cHt||S)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. )rr8)r/r=r>rs r0r8zLabelPropagation.fits&ww{{1a   r2r)rrrrrprr'rrpopr1rBr8rrs@r0rrYsRRhH#R&:&Q#RDRRRw'''         ( !!!!!!!!!r2rceZdZUdZdZiejZeed<e e dddged< dd d d d dddfd Z dZ xZ S)LabelSpreadinga 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#rr(r)g?r*r+Nr,c Xt|||||||dS)Nrr) r/r r!r"r#r$r%r&rs r0r1zLabelSpreading.__init__RsE #      r2c(|jdkrd|_|jjd}||j}t |d}| }t j|r|j|j k}d|j |<nd|j dd|dz<|S)z=Graph matrix for Label Spreading computes the graph laplacianrNrT)normedgr) r r7r^rqr?csgraph_laplacianrrsrowcolrflat)r/rrr diag_masks r0rBzLabelSpreading._build_graphhs ;%  DKGM!$ **4733%odCCC J ?9 % % 3! 6I(+IN9 % %/2IN++i!m+ ,r2r)rrrrrprr'rrrrr1rBrrs@r0rrs]]~H#R&:&Q#RDRRR'/xa9'M'M'M&N7#         ,r2r)&rrzabcrrnumbersrrnumpyrHscipyrbaser r r exceptionsr metrics.pairwiser neighborsrutils._param_validationrr utils.extmathr utils.fixesrrutils.multiclassrutils.validationrrrrrr2r0rs33p''''''''""""""""??????????++++++))))))((((((::::::::++++++888888;;;;;;========JJJJJ?MWJJJJZQ!Q!Q!Q!Q!+Q!Q!Q!hIIIII)IIIIIr2