-iSrSSKJr SSKJr SSKrSSKrSSK J r J r J r SSK JrJr SSKJrJrJrJr SS KJrJr SS KJr SS KJr SS KJrJr SS KJ r SSK!J"r"J#r# SSK$J%r%J&r&J'r' SSK$J(r) \RT"/SQ5SS2\RV4r,\RT"/SQ5SS2\RV4r-"SS\5r."SS\\5r/g)z"Gaussian processes classification.)Integral) itemgetterN) cho_solvecholeskysolve)erfexpit) BaseEstimatorClassifierMixin _fit_contextclone)OneVsOneClassifierOneVsRestClassifier) LabelEncoder)check_random_state)Interval StrOptions)_check_optimize_result)check_is_fitted validate_data)RBFCompoundKernelKernel)ConstantKernel)g= ףp=?g?gGz?g)\(?g(\?)g; !IgQfAy@g>[(dk@gK`@gvicj\rSrSrSrSSSSSSSS .S jjrS rS rS rSSjr Sr SSjr Sr Sr g)'_BinaryGaussianProcessClassifierLaplace$aBinary Gaussian process classification based on Laplace approximation. The implementation is based on Algorithm 3.1, 3.2, and 5.1 from [RW2006]_. Internally, the Laplace approximation is used for approximating the non-Gaussian posterior by a Gaussian. Currently, the implementation is restricted to using the logistic link function. .. versionadded:: 0.18 Parameters ---------- kernel : kernel instance, default=None The kernel specifying the covariance function of the GP. If None is passed, the kernel "1.0 * RBF(1.0)" is used as default. Note that the kernel's hyperparameters are optimized during fitting. optimizer : 'fmin_l_bfgs_b' or callable, default='fmin_l_bfgs_b' Can either be one of the internally supported optimizers for optimizing the kernel's parameters, specified by a string, or an externally defined optimizer passed as a callable. If a callable is passed, it must have the signature:: def optimizer(obj_func, initial_theta, bounds): # * 'obj_func' is the objective function to be maximized, which # takes the hyperparameters theta as parameter and an # optional flag eval_gradient, which determines if the # gradient is returned additionally to the function value # * 'initial_theta': the initial value for theta, which can be # used by local optimizers # * 'bounds': the bounds on the values of theta .... # Returned are the best found hyperparameters theta and # the corresponding value of the target function. return theta_opt, func_min Per default, the 'L-BFGS-B' algorithm from scipy.optimize.minimize is used. If None is passed, the kernel's parameters are kept fixed. Available internal optimizers are:: 'fmin_l_bfgs_b' n_restarts_optimizer : int, default=0 The number of restarts of the optimizer for finding the kernel's parameters which maximize the log-marginal likelihood. The first run of the optimizer is performed from the kernel's initial parameters, the remaining ones (if any) from thetas sampled log-uniform randomly from the space of allowed theta-values. If greater than 0, all bounds must be finite. Note that n_restarts_optimizer=0 implies that one run is performed. max_iter_predict : int, default=100 The maximum number of iterations in Newton's method for approximating the posterior during predict. Smaller values will reduce computation time at the cost of worse results. warm_start : bool, default=False If warm-starts are enabled, the solution of the last Newton iteration on the Laplace approximation of the posterior mode is used as initialization for the next call of _posterior_mode(). This can speed up convergence when _posterior_mode is called several times on similar problems as in hyperparameter optimization. See :term:`the Glossary `. copy_X_train : bool, default=True If True, a persistent copy of the training data is stored in the object. Otherwise, just a reference to the training data is stored, which might cause predictions to change if the data is modified externally. random_state : int, RandomState instance or None, default=None Determines random number generation used to initialize the centers. Pass an int for reproducible results across multiple function calls. See :term:`Glossary `. Attributes ---------- X_train_ : array-like of shape (n_samples, n_features) or list of object Feature vectors or other representations of training data (also required for prediction). y_train_ : array-like of shape (n_samples,) Target values in training data (also required for prediction) classes_ : array-like of shape (n_classes,) Unique class labels. kernel_ : kernl instance The kernel used for prediction. The structure of the kernel is the same as the one passed as parameter but with optimized hyperparameters L_ : array-like of shape (n_samples, n_samples) Lower-triangular Cholesky decomposition of the kernel in X_train_ pi_ : array-like of shape (n_samples,) The probabilities of the positive class for the training points X_train_ W_sr_ : array-like of shape (n_samples,) Square root of W, the Hessian of log-likelihood of the latent function values for the observed labels. Since W is diagonal, only the diagonal of sqrt(W) is stored. log_marginal_likelihood_value_ : float The log-marginal-likelihood of ``self.kernel_.theta`` References ---------- .. [RW2006] `Carl E. Rasmussen and Christopher K.I. Williams, "Gaussian Processes for Machine Learning", MIT Press 2006 `_ N fmin_l_bfgs_brdFT) optimizern_restarts_optimizermax_iter_predict warm_start copy_X_train random_statecXXlX lX0lX@lXPlX`lXplgNkernelr"r#r$r%r&r')selfr+r"r#r$r%r&r's P/var/www/html/venv/lib/python3.13/site-packages/sklearn/gaussian_process/_gpc.py__init__0_BinaryGaussianProcessClassifierLaplace.__init__s+ "$8! 0$((c R^TRc[SSS9[SSS9-TlO[ TR5Tl[ TR 5TlTR(a[R"U5OUTl [5nURU5TlURTlTRR S:a0[#TR$R&<STR<35eTRR S:XaC[#S R)TR$R&TRR 55eTR*GbTRR,S :GaSU4S jjnTR/UTRR0TRR25/nTR4S :a[R6"TRR25R95(d [#S 5eTRR2n[;TR45Hbn[R<"TRR?USS2S 4USS2S455nURATR/XHU55 Md [C[E[GS5U55n U[RH"U 5S TRlTRRK5 [RL"U 5*Tl'O*TRQTRR05Tl'TRTR5n TRSU S S9un uTl*Tl+Tl, n T$)aAFit Gaussian process classification model. Parameters ---------- X : array-like of shape (n_samples, n_features) or list of object Feature vectors or other representations of training data. y : array-like of shape (n_samples,) Target values, must be binary. Returns ------- self : returns an instance of self. Ng?fixed)constant_value_bounds)length_scale_boundsr z9 supports only binary classification. y contains classes rz){0:s} requires 2 classes; got {1:d} classrTcf>U(aTRUSSS9up#U*U*4$TRUSS9*$)NTF) eval_gradient clone_kernelr7)log_marginal_likelihood)thetar6lmlgradr,s r-obj_func=_BinaryGaussianProcessClassifierLaplace.fit..obj_funcsM $ < <T!=!IC 4$;& 88U8SSSr0zYMultiple optimizer restarts (n_restarts_optimizer>0) requires that all bounds are finite.return_temporaries)T)-r+Crkernel_rrr'rngr&npcopyX_train_r fit_transformy_train_classes_size ValueError __class____name__formatr"n_dims_constrained_optimizationr:boundsr#isfiniteallrangeexpuniformappendlistmaprargmin_check_bounds_paramsminlog_marginal_likelihood_value_r9_posterior_modepi_W_sr_L_) r,Xy label_encoderr=optimarQ iteration theta_initial lml_valuesK_s ` r-fit+_BinaryGaussianProcessClassifierLaplace.fits ;; S@3DDL!-DL%d&7&78&*&7&7 Q % %33A6 %.. ==   !>>**DMM; ]]  1 $;BBNN++T]]-?-?  >> %$,,*=*=*A T..dll00$,,2E2EF((1,{{4<<#6#67;;==$?,,!&t'@'@!AI$&FF488+;+;F1a4L&QRTUQU,+W$XMMM66xPVW"Bc*Q-89J!' *(=!>q!ADLL  LL - - /3566*3E2ED /262N2N ""3D / LL '373G3G $4H4 0 0DHdj$'1a r0c[U5 URURU5nURR UR UR - 5n[R"US:URSURS5$)aAPerform classification on an array of test vectors X. Parameters ---------- X : array-like of shape (n_samples, n_features) or list of object Query points where the GP is evaluated for classification. Returns ------- C : ndarray of shape (n_samples,) Predicted target values for X, values are from ``classes_`` rr) rrBrFTdotrHr_rDwhererI)r,rbK_starf_stars r-predict/_BinaryGaussianProcessClassifierLaplace.predict sj  dmmQ/dmmdhh67xx DMM!$4dmmA6FGGr0c [U5 URU5up#SSU-- n[U-n[R"[R U- 5[ U[R"XD[S--- 5-5-S[R"US-[R -5-- n[U-RSS9S[R5--n[R"SU- U45R$)aReturn probability estimates for the test vector X. Parameters ---------- X : array-like of shape (n_samples, n_features) or list of object Query points where the GP is evaluated for classification. Returns ------- C : array-like of shape (n_samples, n_classes) Returns the probability of the samples for each class in the model. The columns correspond to the classes in sorted order, as they appear in the attribute ``classes_``. rr r)axis?) rlatent_mean_and_varianceLAMBDASrDsqrtpirCOEFSsumvstackrn)r,rb latent_mean latent_varalphagamma integralspi_stars r- predict_proba5_BinaryGaussianProcessClassifierLaplace.predict_proba$s #'"?"?"B Q^$+% GGBEEEM "%"''%7A:+=">??@ A277:>BEE122 4  9$))q)1C%))+4EEyy!g+w/0222r0cUcU(a [S5eUR$U(aURRU5nOURnXlU(aU"UR SS9upVOU"UR 5nUR USS9unuppn U(dU$[R"URS5n U SS2[R4[U S4[R"U 55-n[XSS2[R4U-5nS[R"U5[R"SX5- -US U- -S S U-- --n[U RS5HnWSS2SS2U4nS U R R#U5R#U 5-S UR R%5R#UR$"55-- nUR""UR&U- 5n XR#UR#U 55- nUUR R#U5-U U'M X}4$) a!Returns log-marginal likelihood of theta for training data. Parameters ---------- theta : array-like of shape (n_kernel_params,), default=None Kernel hyperparameters for which the log-marginal likelihood is evaluated. If None, the precomputed log_marginal_likelihood of ``self.kernel_.theta`` is returned. eval_gradient : bool, default=False If True, the gradient of the log-marginal likelihood with respect to the kernel hyperparameters at position theta is returned additionally. If True, theta must not be None. clone_kernel : bool, default=True If True, the kernel attribute is copied. If False, the kernel attribute is modified, but may result in a performance improvement. Returns ------- log_likelihood : float Log-marginal likelihood of theta for training data. log_likelihood_gradient : ndarray of shape (n_kernel_params,), optional Gradient of the log-marginal likelihood with respect to the kernel hyperparameters at position theta. Only returned when `eval_gradient` is True. N.Gradient can only be evaluated for theta!=NoneT)r6r?rz ij, ij -> jrr rw)rKr]rBclone_with_thetar:rFr^rDemptyshapenewaxisrdiagreinsumrTrnroravelrH)r,r:r6r7r+ri K_gradientZr{W_srLbad_ZRrAs_2js_1s_3s r-r9?_BinaryGaussianProcessClassifierLaplace.log_marginal_likelihoodKs@ = !QRR66 6 \\2259F\\F L "4==EMAzt}}%A"&!5!5aD!5!Q BaAHhhu{{1~& BJJ )QIrwwt}"E E !!RZZ-(1, - wwqzBIImQ:: <QV}AF + - syy|$A1a7#A q))C!##))+//!'')2L,LLCdmmb()AeeAEE!Ho%C35599S>)CF%v r0c[U5 URURU5nURR UR UR - 5n[URURSS2[R4U-5nURRU5[R"SXD5- nX54$)aCompute the mean and variance of the latent function values. Based on algorithm 3.2 of [RW2006]_, this function returns the latent mean (Line 4) and variance (Line 6) of the Gaussian process classification model. Note that this function is only supported for binary classification. Parameters ---------- X : array-like of shape (n_samples, n_features) or list of object Query points where the GP is evaluated for classification. Returns ------- latent_mean : array-like of shape (n_samples,) Mean of the latent function values at the query points. latent_var : array-like of shape (n_samples,) Variance of the latent function values at the query points. Nzij,ij->j)rrBrFrnrorHr_rrar`rDrrr)r,rbrqrvrs r-rx@_BinaryGaussianProcessClassifierLaplace.latent_mean_and_variances, dmmQ/hhll4==488#;< $''4::am4v= >\\&&q)BIIj!,GG &&r0c |UR(aL[US5(a;URRURR:Xa URnO-[ R "UR[ RS9n[ R*n[UR5GHpn[U5nUSU- -n[ R"U5nUSS2[ R4U-n [ R"URS5X--n [U SS9n Xs-URU- -n X[!U S4U R#U 55-- n UR#U 5nSU R$R#U5-[ R&"[ R("URS -S- *U-55R+5- [ R,"[ R."U 55R+5- nX- S :a OUnGMs X0lU(a UWWW W W 44$U$) aMode-finding for binary Laplace GPC and fixed kernel. This approximates the posterior of the latent function values for given inputs and target observations with a Gaussian approximation and uses Newton's iteration to find the mode of this approximation. f_cached)dtyperNrT)lowerrr g|=)r%hasattrrrrHrD zeros_likefloat64infrTr$r rzreyerrrornlog1prUr}logr)r,rir@fr9rjr{WrW_sr_KBrrrr;s r-r^7_BinaryGaussianProcessClassifierLaplace._posterior_modes OOj)) ##t}}':':: A dmm2::>A$&66't,,-AqBa"f A771:D!RZZ-(1,Fqwwqz"V]2A$'A+,A9aY 1 >>>AaA qsswwqz!((266DMMA$5$9":Q">?@DDFG&&$((*+ ,u4&) #9.< *Rq!Q,?? ?* *r0c<URS:XaF[RRXSSUS9n[ SU5 UR UR peXV4$[UR5(aURXUS9upVXV4$[SUR-5e)Nr zL-BFGS-BT)methodjacrQlbfgs)rQzUnknown optimizer %s.) r"scipyoptimizeminimizerxfuncallablerK)r,r= initial_thetarQopt_res theta_optfunc_mins r-rPA_BinaryGaussianProcessClassifierLaplace._constrained_optimizations >>_ ,nn-- V.G #7G 4")))W[[x "" dnn % %"&..QW."X I""4t~~EF Fr0)rar`rFrIr&rr+rBr]r$r#r"r_r'rCr%rHr)NFT)F)rM __module__ __qualname____firstlineno____doc__r.rkrsrr9rxr^rP__static_attributes__r0r-rr$s]qj)")&`DH.%3P=AM^'B8+t #r0rc \rSrSr%Sr\S/\"S15\S/\"\ SSSS9/\"\ SSSS9/S /S /S /\"S S 15/\ S/S . r \ \ S'SSSSSSSS SS.Sjjr \"SS9S5rSrSr\S5rSSjrSrSrg)GaussianProcessClassifieriaCGaussian process classification (GPC) based on Laplace approximation. The implementation is based on Algorithm 3.1, 3.2, and 5.1 from [RW2006]_. Internally, the Laplace approximation is used for approximating the non-Gaussian posterior by a Gaussian. Currently, the implementation is restricted to using the logistic link function. For multi-class classification, several binary one-versus rest classifiers are fitted. Note that this class thus does not implement a true multi-class Laplace approximation. Read more in the :ref:`User Guide `. .. versionadded:: 0.18 Parameters ---------- kernel : kernel instance, default=None The kernel specifying the covariance function of the GP. If None is passed, the kernel "1.0 * RBF(1.0)" is used as default. Note that the kernel's hyperparameters are optimized during fitting. Also kernel cannot be a `CompoundKernel`. optimizer : 'fmin_l_bfgs_b', callable or None, default='fmin_l_bfgs_b' Can either be one of the internally supported optimizers for optimizing the kernel's parameters, specified by a string, or an externally defined optimizer passed as a callable. If a callable is passed, it must have the signature:: def optimizer(obj_func, initial_theta, bounds): # * 'obj_func' is the objective function to be maximized, which # takes the hyperparameters theta as parameter and an # optional flag eval_gradient, which determines if the # gradient is returned additionally to the function value # * 'initial_theta': the initial value for theta, which can be # used by local optimizers # * 'bounds': the bounds on the values of theta .... # Returned are the best found hyperparameters theta and # the corresponding value of the target function. return theta_opt, func_min Per default, the 'L-BFGS-B' algorithm from scipy.optimize.minimize is used. If None is passed, the kernel's parameters are kept fixed. Available internal optimizers are:: 'fmin_l_bfgs_b' n_restarts_optimizer : int, default=0 The number of restarts of the optimizer for finding the kernel's parameters which maximize the log-marginal likelihood. The first run of the optimizer is performed from the kernel's initial parameters, the remaining ones (if any) from thetas sampled log-uniform randomly from the space of allowed theta-values. If greater than 0, all bounds must be finite. Note that n_restarts_optimizer=0 implies that one run is performed. max_iter_predict : int, default=100 The maximum number of iterations in Newton's method for approximating the posterior during predict. Smaller values will reduce computation time at the cost of worse results. warm_start : bool, default=False If warm-starts are enabled, the solution of the last Newton iteration on the Laplace approximation of the posterior mode is used as initialization for the next call of _posterior_mode(). This can speed up convergence when _posterior_mode is called several times on similar problems as in hyperparameter optimization. See :term:`the Glossary `. copy_X_train : bool, default=True If True, a persistent copy of the training data is stored in the object. Otherwise, just a reference to the training data is stored, which might cause predictions to change if the data is modified externally. random_state : int, RandomState instance or None, default=None Determines random number generation used to initialize the centers. Pass an int for reproducible results across multiple function calls. See :term:`Glossary `. multi_class : {'one_vs_rest', 'one_vs_one'}, default='one_vs_rest' Specifies how multi-class classification problems are handled. Supported are 'one_vs_rest' and 'one_vs_one'. In 'one_vs_rest', one binary Gaussian process classifier is fitted for each class, which is trained to separate this class from the rest. In 'one_vs_one', one binary Gaussian process classifier is fitted for each pair of classes, which is trained to separate these two classes. The predictions of these binary predictors are combined into multi-class predictions. Note that 'one_vs_one' does not support predicting probability estimates. n_jobs : int, default=None The number of jobs to use for the computation: the specified 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 ---------- base_estimator_ : ``Estimator`` instance The estimator instance that defines the likelihood function using the observed data. kernel_ : kernel instance The kernel used for prediction. In case of binary classification, the structure of the kernel is the same as the one passed as parameter but with optimized hyperparameters. In case of multi-class classification, a CompoundKernel is returned which consists of the different kernels used in the one-versus-rest classifiers. log_marginal_likelihood_value_ : float The log-marginal-likelihood of ``self.kernel_.theta`` classes_ : array-like of shape (n_classes,) Unique class labels. n_classes_ : int The number of classes in the training data 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 -------- GaussianProcessRegressor : Gaussian process regression (GPR). References ---------- .. [RW2006] `Carl E. Rasmussen and Christopher K.I. Williams, "Gaussian Processes for Machine Learning", MIT Press 2006 `_ Examples -------- >>> from sklearn.datasets import load_iris >>> from sklearn.gaussian_process import GaussianProcessClassifier >>> from sklearn.gaussian_process.kernels import RBF >>> X, y = load_iris(return_X_y=True) >>> kernel = 1.0 * RBF(1.0) >>> gpc = GaussianProcessClassifier(kernel=kernel, ... random_state=0).fit(X, y) >>> gpc.score(X, y) 0.9866... >>> gpc.predict_proba(X[:2,:]) array([[0.83548752, 0.03228706, 0.13222543], [0.79064206, 0.06525643, 0.14410151]]) For a comparison of the GaussianProcessClassifier with other classifiers see: :ref:`sphx_glr_auto_examples_classification_plot_classification_probability.py`. Nr rleft)closedrbooleanr' one_vs_rest one_vs_one r+r"r#r$r%r&r' multi_classn_jobs_parameter_constraintsr!FT)r"r#r$r%r&r'rrcpXlX lX0lX@lXPlX`lXplXlXlgr)r) r,r+r"r#r$r%r&r'rrs r-r."GaussianProcessClassifier.__init__s6 "$8! 0$((& r0)prefer_skip_nested_validationc [UR[5(a [S5eURbURR(a[ XUSSSS9upO[ XUSSSS9up[ URURURURURURURS9Ul [R"U5UlUR R"UlUR$S:Xa'[S UR$UR S 4-5eUR$S :aUR&S :Xa$[)URUR*S 9Ul OLUR&S:Xa$[-URUR*S 9Ul O[SUR&-5eURR/X5 UR$S :aP[R0"URR2Vs/sHnUR55PM sn5UlU$URR55UlU$s snf)aLFit Gaussian process classification model. Parameters ---------- X : array-like of shape (n_samples, n_features) or list of object Feature vectors or other representations of training data. y : array-like of shape (n_samples,) Target values, must be binary. Returns ------- self : object Returns an instance of self. z!kernel cannot be a CompoundKernelNFTnumeric) multi_output ensure_2drr*rzfGaussianProcessClassifier requires 2 or more distinct classes; got %d class (only class %s is present)rr r)rrzUnknown multi-class mode %s) isinstancer+rrKrequires_vector_inputrrr"r#r$r%r&r'base_estimator_rDuniquerIrJ n_classes_rrrrrkmean estimators_r9r])r,rbrc estimators r-rkGaussianProcessClassifier.fits" dkk> 2 2@A A ;; $++"C"C $iDAq!%tDA G;;nn!%!:!:!22****  !  --,, ??a !%$--2B CD  ??Q =0':((($!!\1'9((($!!>AQAQ!QRR   & ??Q 24''&*%9%9%E%E%E 557%E3D / $$<<>  / sI%c[U5 URbURR(a [XSSSS9nO [XSSSS9nURR U5$)aBPerform classification on an array of test vectors X. Parameters ---------- X : array-like of shape (n_samples, n_features) or list of object Query points where the GP is evaluated for classification. Returns ------- C : ndarray of shape (n_samples,) Predicted target values for X, values are from ``classes_``. NTrFrrreset)rr+rrrrsr,rbs r-rs!GaussianProcessClassifier.predictsY  ;; $++"C"CdYeTAdd%PA##++A..r0c&[U5 URS:aURS:Xa [S5eURbURR (a [ XSSSS9nO [ XSSSS9nURRU5$) aReturn probability estimates for the test vector X. Parameters ---------- X : array-like of shape (n_samples, n_features) or list of object Query points where the GP is evaluated for classification. Returns ------- C : array-like of shape (n_samples, n_classes) Returns the probability of the samples for each class in the model. The columns correspond to the classes in sorted order, as they appear in the attribute :term:`classes_`. r rzlone_vs_one multi-class mode does not support predicting probability estimates. Use one_vs_rest mode instead.NTrFr) rrrrKr+rrrrrs r-r'GaussianProcessClassifier.predict_proba+s  ??Q 4#3#3|#C,  ;; $++"C"CdYeTAdd%PA##11!44r0cURS:XaURR$[URRVs/sHoRPM sn5$s snf)z(Return the kernel of the base estimator.r )rrrBrr)r,rs r-rB!GaussianProcessClassifier.kernel_IsV ??a ''// /!484H4H4T4TU4Ty""4TU UsA c z[U5 UcU(a [S5eUR$[R"U5nUR S:XaUR RXUS9$U(a [S5eUR RnUSRRnURSU:XaA[R"[U5VVs/sHupgURXS9PM snn5$URSXPRRS-:XaL[R"[U5VVs/sHupgURXU-XVS--US9PM! snn5$[SXUURRS-URS4-5es snnfs snnf)aReturn log-marginal likelihood of theta for training data. In the case of multi-class classification, the mean log-marginal likelihood of the one-versus-rest classifiers are returned. Parameters ---------- theta : array-like of shape (n_kernel_params,), default=None Kernel hyperparameters for which the log-marginal likelihood is evaluated. In the case of multi-class classification, theta may be the hyperparameters of the compound kernel or of an individual kernel. In the latter case, all individual kernel get assigned the same theta values. If None, the precomputed log_marginal_likelihood of ``self.kernel_.theta`` is returned. eval_gradient : bool, default=False If True, the gradient of the log-marginal likelihood with respect to the kernel hyperparameters at position theta is returned additionally. Note that gradient computation is not supported for non-binary classification. If True, theta must not be None. clone_kernel : bool, default=True If True, the kernel attribute is copied. If False, the kernel attribute is modified, but may result in a performance improvement. Returns ------- log_likelihood : float Log-marginal likelihood of theta for training data. log_likelihood_gradient : ndarray of shape (n_kernel_params,), optional Gradient of the log-marginal likelihood with respect to the kernel hyperparameters at position theta. Only returned when `eval_gradient` is True. rr r8zHGradient of log-marginal-likelihood not implemented for multi-class GPC.rrzEShape of theta must be either %d or %d. Obtained theta with shape %d.)rrKr]rDasarrayrrr9NotImplementedErrorrrBrOrr enumeraterI)r,r:r6r7 estimatorsrOirs r-r91GaussianProcessClassifier.log_marginal_likelihoodSsL  = !QRR66 6 5! ??a ''??<@ )'--99J]**11F{{1~'ww -6j,A -BLA"99!:-B Q6MM,?,?,B#BBww -6j,A  -BLA "99!1*vQ/?@)5:-B !4 (;(;A(>> AOP's F1 &F7 c"URS:a[SURS35e[U5 URbURR(a [ XSSSS9nO [ XSSSS9nUR RU5$) aCompute the mean and variance of the latent function. Based on algorithm 3.2 of [RW2006]_, this function returns the latent mean (Line 4) and variance (Line 6) of the Gaussian process classification model. Note that this function is only supported for binary classification. .. versionadded:: 1.7 Parameters ---------- X : array-like of shape (n_samples, n_features) or list of object Query points where the GP is evaluated for classification. Returns ------- latent_mean : array-like of shape (n_samples,) Mean of the latent function values at the query points. latent_var : array-like of shape (n_samples,) Variance of the latent function values at the query points. r zoReturning the mean and variance of the latent function f is only supported for binary classification, received z classes.NTrFr)rrKrr+rrrrxrs r-rx2GaussianProcessClassifier.latent_mean_and_variances0 ??Q I??#9.   ;; $++"C"CdYeTAdd%PA##<rs( 33$FF@(&:3=00( ((0 1!RZZ- @ N RZZ-  ]#m]#@I@I@r0