-irLPSrSSKrSSKrSSKJrJr SSKJr SSKJ r SSK r SSK J r JrJr SSKJrJr SS KJr SS KJr SS KJr SS KJr S r"SS\"SS55r"SS\S9r"SS5r"SS5r"SS5r "SS\5r!"SS\5r""SS\"5r#"S S!\"5r$"S"S#\5r%"S$S%\\ \5r&"S&S'\\ \5r'"S(S)\\\5r("S*S+\(5r)"S,S-\\\5r*"S.S/\\\5r+"S0S1\5r,S5S2jr-"S3S4\5r.g)6zRA set of kernels that can be combined by operators and used in Gaussian processes.N)ABCMetaabstractmethod) namedtuple) signature)cdistpdist squareform)gammakv)clone)ConvergenceWarning)pairwise_kernels) _num_samplescj[R"U5R[5n[R"U5S:a [ S5e[R"U5S:XaJUR SUR S:wa*[ SUR SUR S4-5eU$)Nz2length_scale cannot be of dimension greater than 1rzKAnisotropic kernel must have the same number of dimensions as data (%d!=%d))npsqueezeastypefloatndim ValueErrorshape)X length_scales S/var/www/html/venv/lib/python3.13/site-packages/sklearn/gaussian_process/kernels.py_check_length_scaler(s::l+2259L ww|q MNN ww|!aggajL4F4Fq4I&I *-9-?-?-BAGGAJ,O P   c:^\rSrSrSrSrSU4SjjrSrSrU=r $)Hyperparameter4aA kernel hyperparameter's specification in form of a namedtuple. .. versionadded:: 0.18 Attributes ---------- name : str The name of the hyperparameter. Note that a kernel using a hyperparameter with name "x" must have the attributes self.x and self.x_bounds value_type : str The type of the hyperparameter. Currently, only "numeric" hyperparameters are supported. bounds : pair of floats >= 0 or "fixed" The lower and upper bound on the parameter. If n_elements>1, a pair of 1d array with n_elements each may be given alternatively. If the string "fixed" is passed as bounds, the hyperparameter's value cannot be changed. n_elements : int, default=1 The number of elements of the hyperparameter value. Defaults to 1, which corresponds to a scalar hyperparameter. n_elements > 1 corresponds to a hyperparameter which is vector-valued, such as, e.g., anisotropic length-scales. fixed : bool, default=None Whether the value of this hyperparameter is fixed, i.e., cannot be changed during hyperparameter tuning. If None is passed, the "fixed" is derived based on the given bounds. Examples -------- >>> from sklearn.gaussian_process.kernels import ConstantKernel >>> from sklearn.datasets import make_friedman2 >>> from sklearn.gaussian_process import GaussianProcessRegressor >>> from sklearn.gaussian_process.kernels import Hyperparameter >>> X, y = make_friedman2(n_samples=50, noise=0, random_state=0) >>> kernel = ConstantKernel(constant_value=1.0, ... constant_value_bounds=(0.0, 10.0)) We can access each hyperparameter: >>> for hyperparameter in kernel.hyperparameters: ... print(hyperparameter) Hyperparameter(name='constant_value', value_type='numeric', bounds=array([[ 0., 10.]]), n_elements=1, fixed=False) >>> params = kernel.get_params() >>> for key in sorted(params): print(f"{key} : {params[key]}") constant_value : 1.0 constant_value_bounds : (0.0, 10.0) c>[U[5(aUS:waw[R"U5nUS:a[URSS:Xa[R "X4S5nO0URSU:wa[ SXURS4-5eUc[U[5=(a US:Hn[TU]!XX#XE5$)Nfixedrrz@Bounds on %s should have either 1 or %d dimensions. Given are %d) isinstancestrr atleast_2drrepeatrsuper__new__)clsname value_typebounds n_elementsr$ __class__s rr*Hyperparameter.__new__zs&#&&&G*;]]6*FA~<<?a'YYv1=F\\!_ 2$6V\\!_=> =vs+A'0AEws*jPPrc\URUR:H=(a URUR:H=(am [R"URUR:H5=(a9 UR UR :H=(a UR UR :H$N)r,r-rallr.r/r$)selfothers r__eq__Hyperparameter.__eq__s| II # *5#3#33 *t{{ell23 *5#3#33 * ekk)  r)rN) __name__ __module__ __qualname____firstlineno____doc__ __slots__r*r7__static_attributes__ __classcell__r0s@rr r 4s 5~IQ&  rr )r,r-r.r/r$c\rSrSrSrSSjrSrSr\S5r \S5r \S5r \ RS 5r \S 5r S rS rS rSrSrSrSr\SSj5r\S5r\S5r\S5rSrSrg)KernelaBase class for all kernels. .. versionadded:: 0.18 Examples -------- >>> from sklearn.gaussian_process.kernels import Kernel, RBF >>> import numpy as np >>> class CustomKernel(Kernel): ... def __init__(self, length_scale=1.0): ... self.length_scale = length_scale ... def __call__(self, X, Y=None): ... if Y is None: ... Y = X ... return np.inner(X, X if Y is None else Y) ** 2 ... def diag(self, X): ... return np.ones(X.shape[0]) ... def is_stationary(self): ... return True >>> kernel = CustomKernel(length_scale=2.0) >>> X = np.array([[1, 2], [3, 4]]) >>> print(kernel(X)) [[ 25 121] [121 625]] c4[5nURn[URSUR5n[ U5n//pvUR R 5HnURUR:wa+URS:waURUR5 URUR:XdMdURUR5 M [U5S:wa[SU<S35eUHn [X 5X)'M U$)Get parameters of this kernel. Parameters ---------- deep : bool, default=True If True, will return the parameters for this estimator and contained subobjects that are estimators. Returns ------- params : dict Parameter names mapped to their values. deprecated_originalr5rzmscikit-learn kernels should always specify their parameters in the signature of their __init__ (no varargs). z doesn't follow this convention.)dictr0getattr__init__r parametersvalueskind VAR_KEYWORDr,appendVAR_POSITIONALlen RuntimeError) r5deepparamsr+init init_signargsvarargs parameterargs r get_paramsKernel.get_paramssnns||%:CLLIdO Bg"--446I~~!6!669>>V;S INN+~~!9!99y~~. 7 w<1 :=?  C!$,FK rc U(dU$URSS9nUR5Hup4URSS5n[U5S:a6UupgXb;a[ SU<SU<S35eX&nUR "S0Xt0D6 M\X2;a([ SU<SUR R<S35e[XU5 M U$) aSet the parameters of this kernel. The method works on simple kernels as well as on nested kernels. The latter have parameters of the form ``__`` so that it's possible to update each component of a nested object. Returns ------- self T)rS__rzInvalid parameter z for kernel zK. Check the list of available parameters with `kernel.get_params().keys()`.r") r[itemssplitrQr set_paramsr0r9setattr) r5rT valid_paramskeyvaluer`r,sub_name sub_objects rraKernel.set_paramssKD1  ,,.JCIIdA&E5zA~!&+$AEdL */ %%:(9:*$ 7 79 5)-). rc([U5nXlU$)zReturns a clone of self with given hyperparameters theta. Parameters ---------- theta : ndarray of shape (n_dims,) The hyperparameters )r theta)r5rjcloneds rclone_with_thetaKernel.clone_with_thetast  rc4URRS$)z>Returns the number of non-fixed hyperparameters of the kernel.r)rjrr5s rn_dims Kernel.n_dimsszz""rc[U5Vs/sH&nURS5(dM[X5PM( nnU$s snf)z4Returns a list of all hyperparameter specifications.hyperparameter_)dir startswithrI)r5attrrs rhyperparametersKernel.hyperparameterssH D  !01 GD !    s??cJ/nUR5nURH3nUR(aMURX#R5 M5 [ U5S:a*[ R"[ R"U55$[ R"/5$)Returns the (flattened, log-transformed) non-fixed hyperparameters. Note that theta are typically the log-transformed values of the kernel's hyperparameters as this representation of the search space is more amenable for hyperparameter search, as hyperparameters like length-scales naturally live on a log-scale. Returns ------- theta : ndarray of shape (n_dims,) The non-fixed, log-transformed hyperparameters of the kernel r) r[rxr$rOr,rQrloghstackarray)r5rjrThyperparameters rrj Kernel.thetasy""22N!''' V$7$7893 u:>66"))E*+ +88B< rcUR5nSnURHnUR(aMURS:a@[R "XX4R-5X$R 'X4R- nMf[R "X5X$R 'US- nM U[U5:wa[SU[U54-5eUR"S0UD6 g)Sets the (flattened, log-transformed) non-fixed hyperparameters. Parameters ---------- theta : ndarray of shape (n_dims,) The non-fixed, log-transformed hyperparameters of the kernel rrzGtheta has not the correct number of entries. Should be %d; given are %dNr") r[rxr$r/rexpr,rQrra)r5rjrTirs rrjr5s" "22N##((1,.0ffa";";;</**+....0ffUX.>**+Q3 E ?.12CJ@  !&!rcURVs/sH"nUR(aMURPM$ nn[U5S:a*[R "[R "U55$[R"/5$s snfReturns the log-transformed bounds on the theta. Returns ------- bounds : ndarray of shape (n_dims, 2) The log-transformed bounds on the kernel's hyperparameters theta r)rxr$r.rQrr|vstackr~)r5rr.s rr. Kernel.boundsTss#'"6"6 "6!'' "N ! !"6  v;?66"))F+, ,88B<  s B B cl[U[5(d[U[U55$[X5$r3r%rCSumConstantKernelr5bs r__add__Kernel.__add__gs+!V$$t^A./ /4|rcl[U[5(d[[U5U5$[X5$r3rrs r__radd__Kernel.__radd__ls+!V$$~a($/ /1|rcl[U[5(d[U[U55$[X5$r3r%rCProductrrs r__mul__Kernel.__mul__qs,!V$$4!23 3trcl[U[5(d[[U5U5$[X5$r3rrs r__rmul__Kernel.__rmul__vs,!V$$>!,d3 3qrc[X5$r3)Exponentiationrs r__pow__Kernel.__pow__{s d&&rc|[U5[U5:wagUR5nUR5n[[UR 55[UR 55-5HCn[ R "URUS5URUS5:g5(dMC g g)NFT)typer[setlistkeysranyget)r5rparams_aparams_brds rr7 Kernel.__eq__~s :a ??$<<>tHMMO,tHMMO/DDECvvhll3-c41HHIIFrc SRURRSR[ SRUR 555$)Nz{0}({1}), {0:.3g})formatr0r9joinmaprjros r__repr__Kernel.__repr__s>  NN # #TYYs93C3CTZZ/P%Q  rNcg)zEvaluate the kernel.Nr")r5rY eval_gradients r__call__Kernel.__call__rcg)aReturns the diagonal of the kernel k(X, X). The result of this method is identical to np.diag(self(X)); however, it can be evaluated more efficiently since only the diagonal is evaluated. Parameters ---------- X : array-like of shape (n_samples,) Left argument of the returned kernel k(X, Y) Returns ------- K_diag : ndarray of shape (n_samples_X,) Diagonal of kernel k(X, X) Nr"r5rs rdiag Kernel.diagrrcg))Returns whether the kernel is stationary.Nr"ros r is_stationaryKernel.is_stationaryrrcg)zReturns whether the kernel is defined on fixed-length feature vectors or generic objects. Defaults to True for backward compatibility.Tr"ros rrequires_vector_inputKernel.requires_vector_inputs rc ^[R"UR[R"UR5R 5nSnUR HnUR(aM[UR5HnXS4(aC[R"SU<SUR<SURUS<S3[5 OMXS4(aB[R"SU<SUR<SURUS<S3[5 US- nM M g ) z?Called after fitting to warn if bounds may have been too tight.rz&The optimal value found for dimension z of parameter z' is close to the specified lower bound zE. Decreasing the bound and calling fit again may find a better value.rz' is close to the specified upper bound zE. Increasing the bound and calling fit again may find a better value.N)riscloser.r'rjTrxr$ranger/warningswarnr,r)r5 list_closeidxhypdims r_check_bounds_paramsKernel._check_bounds_paramssZZ R]]4::-F-H-HI ''CyyS^^,1f%MM ,/#**S/!:L N + Q'MM ,/#**S/!:L N +q+-(rr"TNF)r9r:r;r<r=r[rarlpropertyrprxrjsetterr.rrrrrr7rrrrrrrr?r"rrrCrCs4&P&P ##  . \\""<  $    ' ##  $88 rrC) metaclassc\rSrSrSrSrSrg)NormalizedKernelMixinizKMixin for kernels which are normalized: k(X, X)=1. .. versionadded:: 0.18 cH[R"URS5$)Returns the diagonal of the kernel k(X, X). The result of this method is identical to np.diag(self(X)); however, it can be evaluated more efficiently since only the diagonal is evaluated. Parameters ---------- X : ndarray of shape (n_samples_X, n_features) Left argument of the returned kernel k(X, Y) Returns ------- K_diag : ndarray of shape (n_samples_X,) Diagonal of kernel k(X, X) r)ronesrrs rrNormalizedKernelMixin.diags"wwqwwqz""rr"N)r9r:r;r<r=rr?r"rrrrs  #rrc\rSrSrSrSrSrg)StationaryKernelMixinizQMixin for kernels which are stationary: k(X, Y)= f(X-Y). .. versionadded:: 0.18 cg)rTr"ros rr#StationaryKernelMixin.is_stationarysrr"N)r9r:r;r<r=rr?r"rrrrs  rrc(\rSrSrSr\S5rSrg)GenericKernelMixinizMixin for kernels which operate on generic objects such as variable- length sequences, trees, and graphs. .. versionadded:: 0.22 cg)z>Whether the kernel works only on fixed-length feature vectors.Fr"ros rr(GenericKernelMixin.requires_vector_inputsrr"N)r9r:r;r<r=rrr?r"rrrrs rrc\rSrSrSrSrSSjr\S5r\RS5r\S5r SS jr S r S r \S 5rS rSrg)CompoundKerneliaSKernel which is composed of a set of other kernels. .. versionadded:: 0.18 Parameters ---------- kernels : list of Kernels The other kernels Examples -------- >>> from sklearn.gaussian_process.kernels import WhiteKernel >>> from sklearn.gaussian_process.kernels import RBF >>> from sklearn.gaussian_process.kernels import CompoundKernel >>> kernel = CompoundKernel( ... [WhiteKernel(noise_level=3.0), RBF(length_scale=2.0)]) >>> print(kernel.bounds) [[-11.51292546 11.51292546] [-11.51292546 11.51292546]] >>> print(kernel.n_dims) 2 >>> print(kernel.theta) [1.09861229 0.69314718] cXlgr3kernels)r5rs rrJCompoundKernel.__init__s rc([URS9$)rFr)rHr)r5rSs rr[CompoundKernel.get_paramssDLL))rc[R"URVs/sHoRPM sn5$s snfr{)rr}rrjr5kernels rrjCompoundKernel.theta-s+yyT\\B\6,,\BCCB;cURRn[UR5Hup4XU-US-U-UlM g)zSets the (flattened, log-transformed) non-fixed hyperparameters. Parameters ---------- theta : array of shape (n_dims,) The non-fixed, log-transformed hyperparameters of the kernel rN)k1rp enumeraterrj)r5rjk_dimsrrs rrjr=s?"4<<0IA Vq1u.>?FL1rc[R"URVs/sHoRPM sn5$s snf)zReturns the log-transformed bounds on the theta. Returns ------- bounds : array of shape (n_dims, 2) The log-transformed bounds on the kernel's hyperparameters theta )rrrr.rs rr.CompoundKernel.boundsJs+yydllClF--lCDDCrNc U(a/n/nURHCnU"XU5upxURU5 URUS[R45 ME [R"U5[R "US54$[R"URVs/sH of"XU5PM sn5$s snf)aReturn the kernel k(X, Y) and optionally its gradient. Note that this compound kernel returns the results of all simple kernel stacked along an additional axis. Parameters ---------- X : array-like of shape (n_samples_X, n_features) or list of object, default=None Left argument of the returned kernel k(X, Y) Y : array-like of shape (n_samples_X, n_features) or list of object, default=None Right argument of the returned kernel k(X, Y). If None, k(X, X) is evaluated instead. eval_gradient : bool, default=False Determines whether the gradient with respect to the log of the kernel hyperparameter is computed. Returns ------- K : ndarray of shape (n_samples_X, n_samples_Y, n_kernels) Kernel k(X, Y) K_gradient : ndarray of shape (n_samples_X, n_samples_X, n_dims, n_kernels), optional The gradient of the kernel k(X, X) with respect to the log of the hyperparameter of the kernel. Only returned when `eval_gradient` is True. .)rrOrnewaxisdstack concatenate) r5rrrKK_gradrK_single K_grad_singles rrCompoundKernel.__call__Us@ AF,,*0}*E'" mCO<='99Q<!:: :99 U ffQ=9 UV VUs*CcT[U5[U5:wd,[UR5[UR5:wag[R"[ [UR55Vs/sH!o RUURU:HPM# sn5$s snfr)rrQrrr4r)r5rrs rr7CompoundKernel.__eq__sv :a C $5QYY$Gvv6;C ,KernelOperator.get_params..E*6A:s+*c34# UHupSU-U4v M g7f)k2__Nr"rs rrrrr)rHrrr[r_updater5rSrT deep_itemss rr[KernelOperator.get_paramsszTWW- ++-335J MME*E E++-335J MME*E E rc URRVs/sH<n[SUR-URUR UR 5PM> nnURRHKnUR[SUR-URUR UR 55 MM U$s snf)%Returns a list of all hyperparameter.rr) rrxr r,r-r.r/rrO)r5rrws rrxKernelOperator.hyperparameterss#'''"9"9 #: ,,,))%%))   #:  #gg55N HH^000"--"))"--  6' sACc[R"URRURR5$r)rrOrrjrros rrjKernelOperator.thetas%yy 66rc~URRnUSUURlXSURlgrN)rrprjr)r5rjk1_dimss rrjr&s1''..hw h rcjURRRS:XaURR$URRRS:XaURR$[R "URRURR45$r)rr.sizerrrros rr.KernelOperator.boundssp 77>>  ! #77>> ! 77>>  ! #77>> !yy$''..$''..9::rc&[U5[U5:wagURUR:H=(a URUR:H=(d9 URUR:H=(a URUR:H$r)rrrrs rr7KernelOperator.__eq__ s_ :a 1443DGGqttO GGqttO /144 rcxURR5=(a URR5$r)rrrros rrKernelOperator.is_stationarys'ww$$&B477+@+@+BBrchURR=(d URR$r)rrrros rr$KernelOperator.requires_vector_inputs#ww,,M0M0MMrrNr)r9r:r;r<r=rJr[rrxrjrr.r7rrr?r"rrr r s .. 7 7 \\ ( ( ; ; CNNrr c.\rSrSrSrSSjrSrSrSrg) riaThe `Sum` kernel takes two kernels :math:`k_1` and :math:`k_2` and combines them via .. math:: k_{sum}(X, Y) = k_1(X, Y) + k_2(X, Y) Note that the `__add__` magic method is overridden, so `Sum(RBF(), RBF())` is equivalent to using the + operator with `RBF() + RBF()`. Read more in the :ref:`User Guide `. .. versionadded:: 0.18 Parameters ---------- k1 : Kernel The first base-kernel of the sum-kernel k2 : Kernel The second base-kernel of the sum-kernel Examples -------- >>> from sklearn.datasets import make_friedman2 >>> from sklearn.gaussian_process import GaussianProcessRegressor >>> from sklearn.gaussian_process.kernels import RBF, Sum, ConstantKernel >>> X, y = make_friedman2(n_samples=500, noise=0, random_state=0) >>> kernel = Sum(ConstantKernel(2), RBF()) >>> gpr = GaussianProcessRegressor(kernel=kernel, ... random_state=0).fit(X, y) >>> gpr.score(X, y) 1.0 >>> kernel 1.41**2 + RBF(length_scale=1) NcU(a?URXSS9upEURXSS9upgXF-[R"XW454$URX5URX5-$)aYReturn the kernel k(X, Y) and optionally its gradient. Parameters ---------- X : array-like of shape (n_samples_X, n_features) or list of object Left argument of the returned kernel k(X, Y) Y : array-like of shape (n_samples_X, n_features) or list of object, default=None Right argument of the returned kernel k(X, Y). If None, k(X, X) is evaluated instead. eval_gradient : bool, default=False Determines whether the gradient with respect to the log of the kernel hyperparameter is computed. Returns ------- K : ndarray of shape (n_samples_X, n_samples_Y) Kernel k(X, Y) K_gradient : ndarray of shape (n_samples_X, n_samples_X, n_dims), optional The gradient of the kernel k(X, X) with respect to the log of the hyperparameter of the kernel. Only returned when `eval_gradient` is True. Tr)rrrrr5rrrK1 K1_gradientK2 K2_gradients rr Sum.__call__Asc8 "gga$g?OB"gga$g?OB7BII{&@AA A771=4771=0 0rcpURRU5URRU5-$)aReturns the diagonal of the kernel k(X, X). The result of this method is identical to `np.diag(self(X))`; however, it can be evaluated more efficiently since only the diagonal is evaluated. Parameters ---------- X : array-like of shape (n_samples_X, n_features) or list of object Argument to the kernel. Returns ------- K_diag : ndarray of shape (n_samples_X,) Diagonal of kernel k(X, X) rrrrs rrSum.diagd'"ww||Aa00rcNSRURUR5$)Nz {0} + {1}rrrros rr Sum.__repr__w!!$''47733rr"r r9r:r;r<r=rrrr?r"rrrrs$L!1F1&4rrc.\rSrSrSrSSjrSrSrSrg) ri{aThe `Product` kernel takes two kernels :math:`k_1` and :math:`k_2` and combines them via .. math:: k_{prod}(X, Y) = k_1(X, Y) * k_2(X, Y) Note that the `__mul__` magic method is overridden, so `Product(RBF(), RBF())` is equivalent to using the * operator with `RBF() * RBF()`. Read more in the :ref:`User Guide `. .. versionadded:: 0.18 Parameters ---------- k1 : Kernel The first base-kernel of the product-kernel k2 : Kernel The second base-kernel of the product-kernel Examples -------- >>> from sklearn.datasets import make_friedman2 >>> from sklearn.gaussian_process import GaussianProcessRegressor >>> from sklearn.gaussian_process.kernels import (RBF, Product, ... ConstantKernel) >>> X, y = make_friedman2(n_samples=500, noise=0, random_state=0) >>> kernel = Product(ConstantKernel(2), RBF()) >>> gpr = GaussianProcessRegressor(kernel=kernel, ... random_state=0).fit(X, y) >>> gpr.score(X, y) 1.0 >>> kernel 1.41**2 * RBF(length_scale=1) Nc >U(atURXSS9upEURXSS9upgXF-[R"XVSS2SS2[R4-XtSS2SS2[R4-454$URX5URX5-$)aVReturn the kernel k(X, Y) and optionally its gradient. Parameters ---------- X : array-like of shape (n_samples_X, n_features) or list of object Left argument of the returned kernel k(X, Y) Y : array-like of shape (n_samples_Y, n_features) or list of object, default=None Right argument of the returned kernel k(X, Y). If None, k(X, X) is evaluated instead. eval_gradient : bool, default=False Determines whether the gradient with respect to the log of the kernel hyperparameter is computed. Returns ------- K : ndarray of shape (n_samples_X, n_samples_Y) Kernel k(X, Y) K_gradient : ndarray of shape (n_samples_X, n_samples_X, n_dims), optional The gradient of the kernel k(X, X) with respect to the log of the hyperparameter of the kernel. Only returned when `eval_gradient` is True. Tr5N)rrrrrr6s rrProduct.__call__s8 "gga$g?OB"gga$g?OB7BII!Q "233[aBJJFVCW5WX 771=4771=0 0rcpURRU5URRU5-$Returns the diagonal of the kernel k(X, X). The result of this method is identical to np.diag(self(X)); however, it can be evaluated more efficiently since only the diagonal is evaluated. Parameters ---------- X : array-like of shape (n_samples_X, n_features) or list of object Argument to the kernel. Returns ------- K_diag : ndarray of shape (n_samples_X,) Diagonal of kernel k(X, X) r=rs rr Product.diagr?rcNSRURUR5$)Nz {0} * {1}rAros rrProduct.__repr__rCrr"rrDr"rrrr{s%N#1J1&4rrc\rSrSrSrSrSSjr\S5r\S5r \ RS5r \S5r S r SS jr S rS rSr\S5rSrg )ria The Exponentiation kernel takes one base kernel and a scalar parameter :math:`p` and combines them via .. math:: k_{exp}(X, Y) = k(X, Y) ^p Note that the `__pow__` magic method is overridden, so `Exponentiation(RBF(), 2)` is equivalent to using the ** operator with `RBF() ** 2`. Read more in the :ref:`User Guide `. .. versionadded:: 0.18 Parameters ---------- kernel : Kernel The base kernel exponent : float The exponent for the base kernel Examples -------- >>> from sklearn.datasets import make_friedman2 >>> from sklearn.gaussian_process import GaussianProcessRegressor >>> from sklearn.gaussian_process.kernels import (RationalQuadratic, ... Exponentiation) >>> X, y = make_friedman2(n_samples=500, noise=0, random_state=0) >>> kernel = Exponentiation(RationalQuadratic(), exponent=2) >>> gpr = GaussianProcessRegressor(kernel=kernel, alpha=5, ... random_state=0).fit(X, y) >>> gpr.score(X, y) 0.419 >>> gpr.predict(X[:1,:], return_std=True) (array([635.5]), array([0.559])) cXlX lgr3rexponent)r5rrQs rrJExponentiation.__init__s   rc[URURS9nU(a@URR5R 5nUR SU55 U$)rFrPc34# UHupSU-U4v M g7f)kernel__Nr"rs rr,Exponentiation.get_params..sIjFA:>3/jr)rHrrQr[r_rrs rr[Exponentiation.get_params sMT[[4==A //1779J MMIjI I rc /nURRHKnUR[SUR-UR UR UR55 MM U$)r#rU)rrxrOr r,r-r.r/)r5rwrs rrxExponentiation.hyperparameters sa "kk99N HH!4!44"--"))"--  :rc.URR$rrrjros rrjExponentiation.theta/s{{   rc$XRlgr(r[)r5rjs rrjr\?s" rc.URR$)r)rr.ros rr.Exponentiation.boundsJs{{!!!rc[U5[U5:wagURUR:H=(a URUR:H$r)rrrQrs rr7Exponentiation.__eq__Us: :a {{ahh&F4==AJJ+FFrNcU(a[URXSS9upEXPRUSS2SS2[R4URS- ---nX@R-U4$URXSS9nX@R-$)aUReturn the kernel k(X, Y) and optionally its gradient. Parameters ---------- X : array-like of shape (n_samples_X, n_features) or list of object Left argument of the returned kernel k(X, Y) Y : array-like of shape (n_samples_Y, n_features) or list of object, default=None Right argument of the returned kernel k(X, Y). If None, k(X, X) is evaluated instead. eval_gradient : bool, default=False Determines whether the gradient with respect to the log of the kernel hyperparameter is computed. Returns ------- K : ndarray of shape (n_samples_X, n_samples_Y) Kernel k(X, Y) K_gradient : ndarray of shape (n_samples_X, n_samples_X, n_dims), optional The gradient of the kernel k(X, X) with respect to the log of the hyperparameter of the kernel. Only returned when `eval_gradient` is True. Tr5NrF)rrQrrr5rrrr K_gradients rrExponentiation.__call__Zs|8  KKDKAMA --!Aq"**,<*=$--RSBS*TT TJmm#Z/ / A 6Amm# #rcRURRU5UR-$rI)rrrQrs rrExponentiation.diag~s""{{"dmm33rcNSRURUR5$)Nz {0} ** {1})rrrQros rrExponentiation.__repr__s""4;; >>rc6URR5$r)rrros rrExponentiation.is_stationarys{{((**rc.URR$r)rrros rr$Exponentiation.requires_vector_inputs{{000r)rQrrr)r9r:r;r<r=rJr[rrxrjrr.r7rrrrrr?r"rrrrs&P!(   ! ! \\""""G "$H4&?+11rrcH\rSrSrSrS Sjr\S5rS SjrSr Sr S r g) riapConstant kernel. Can be used as part of a product-kernel where it scales the magnitude of the other factor (kernel) or as part of a sum-kernel, where it modifies the mean of the Gaussian process. .. math:: k(x_1, x_2) = constant\_value \;\forall\; x_1, x_2 Adding a constant kernel is equivalent to adding a constant:: kernel = RBF() + ConstantKernel(constant_value=2) is the same as:: kernel = RBF() + 2 Read more in the :ref:`User Guide `. .. versionadded:: 0.18 Parameters ---------- constant_value : float, default=1.0 The constant value which defines the covariance: k(x_1, x_2) = constant_value constant_value_bounds : pair of floats >= 0 or "fixed", default=(1e-5, 1e5) The lower and upper bound on `constant_value`. If set to "fixed", `constant_value` cannot be changed during hyperparameter tuning. Examples -------- >>> from sklearn.datasets import make_friedman2 >>> from sklearn.gaussian_process import GaussianProcessRegressor >>> from sklearn.gaussian_process.kernels import RBF, ConstantKernel >>> X, y = make_friedman2(n_samples=500, noise=0, random_state=0) >>> kernel = RBF() + ConstantKernel(constant_value=2) >>> gpr = GaussianProcessRegressor(kernel=kernel, alpha=5, ... random_state=0).fit(X, y) >>> gpr.score(X, y) 0.3696 >>> gpr.predict(X[:1,:], return_std=True) (array([606.1]), array([0.248])) cXlX lgr3constant_valueconstant_value_bounds)r5rqrrs rrJConstantKernel.__init__s,%:"rc0[SSUR5$)Nrqnumeric)r rrros rhyperparameter_constant_value,ConstantKernel.hyperparameter_constant_values. 4;U;UVVrNcJUcUnOU(a [S5e[R"[U5[U54UR[R "UR5R S9nU(aURR(d_U[R"[U5[U5S4UR[R "UR5R S94$U[R"[U5[U5S454$U$)atReturn the kernel k(X, Y) and optionally its gradient. Parameters ---------- X : array-like of shape (n_samples_X, n_features) or list of object Left argument of the returned kernel k(X, Y) Y : array-like of shape (n_samples_X, n_features) or list of object, default=None Right argument of the returned kernel k(X, Y). If None, k(X, X) is evaluated instead. eval_gradient : bool, default=False Determines whether the gradient with respect to the log of the kernel hyperparameter is computed. Only supported when Y is None. Returns ------- K : ndarray of shape (n_samples_X, n_samples_Y) Kernel k(X, Y) K_gradient : ndarray of shape (n_samples_X, n_samples_X, n_dims), optional The gradient of the kernel k(X, X) with respect to the log of the hyperparameter of the kernel. Only returned when eval_gradient is True. .Gradient can only be evaluated when Y is None.dtyperr) rrfullrrqr~r{rvr$emptyr5rrrrs rrConstantKernel.__call__s: 9A MN N GG !_l1o .   ((4../55  55;;GG%a,q/1=++ hht':':;AA"((LO\!_a#HIIIHrc[R"[U5UR[R"UR5R S9$rJrz)rr|rrqr~r{rs rrConstantKernel.diag s="ww O   ((4../55  rc`SR[R"UR55$)Nz {0:.3g}**2)rrsqrtrqros rrConstantKernel.__repr__$s"""2774+>+>#?@@rrp?gh㈵>gj@r) r9r:r;r<r=rJrrvrrrr?r"rrrrs4.`;WW4l .ArrcH\rSrSrSrS Sjr\S5rS SjrSr Sr S r g) WhiteKerneli(aWhite kernel. The main use-case of this kernel is as part of a sum-kernel where it explains the noise of the signal as independently and identically normally-distributed. The parameter noise_level equals the variance of this noise. .. math:: k(x_1, x_2) = noise\_level \text{ if } x_i == x_j \text{ else } 0 Read more in the :ref:`User Guide `. .. versionadded:: 0.18 Parameters ---------- noise_level : float, default=1.0 Parameter controlling the noise level (variance) noise_level_bounds : pair of floats >= 0 or "fixed", default=(1e-5, 1e5) The lower and upper bound on 'noise_level'. If set to "fixed", 'noise_level' cannot be changed during hyperparameter tuning. Examples -------- >>> from sklearn.datasets import make_friedman2 >>> from sklearn.gaussian_process import GaussianProcessRegressor >>> from sklearn.gaussian_process.kernels import DotProduct, WhiteKernel >>> X, y = make_friedman2(n_samples=500, noise=0, random_state=0) >>> kernel = DotProduct() + WhiteKernel(noise_level=0.5) >>> gpr = GaussianProcessRegressor(kernel=kernel, ... random_state=0).fit(X, y) >>> gpr.score(X, y) 0.3680 >>> gpr.predict(X[:2,:], return_std=True) (array([653.0, 592.1 ]), array([316.6, 316.6])) cXlX lgr3 noise_levelnoise_level_bounds)r5rrs rrJWhiteKernel.__init__Qs&"4rc0[SSUR5$)Nrru)r rros rhyperparameter_noise_level&WhiteKernel.hyperparameter_noise_levelUmY8O8OPPrNc UbU(a [S5eUcUR[R"[ U55-nU(aUR R (dFUUR[R"[ U55SS2SS2[R4-4$U[R"[ U5[ U5S454$U$[R"[ U5[ U545$)arReturn the kernel k(X, Y) and optionally its gradient. Parameters ---------- X : array-like of shape (n_samples_X, n_features) or list of object Left argument of the returned kernel k(X, Y) Y : array-like of shape (n_samples_X, n_features) or list of object, default=None Right argument of the returned kernel k(X, Y). If None, k(X, X) is evaluated instead. eval_gradient : bool, default=False Determines whether the gradient with respect to the log of the kernel hyperparameter is computed. Only supported when Y is None. Returns ------- K : ndarray of shape (n_samples_X, n_samples_Y) Kernel k(X, Y) K_gradient : ndarray of shape (n_samples_X, n_samples_X, n_dims), optional The gradient of the kernel k(X, X) with respect to the log of the hyperparameter of the kernel. Only returned when eval_gradient is True. Nryr) rrreyerrr$rr}zerosr~s rrWhiteKernel.__call__Ys: =]MN N 9  266,q/#::A66<<((266,q/+B1aCS+TT bhh Qa!'LMMM88\!_l1o>? ?rc[R"[U5UR[R"UR5R S9$r)rr|rrr~r{rs rrWhiteKernel.diags;"ww OT--RXXd>N>N5O5U5U  rcbSRURRUR5$)Nz{0}(noise_level={1:.3g}))rr0r9rros rrWhiteKernel.__repr__s*)00 NN # #T%5%5  rrrr) r9r:r;r<r=rJrrrrrr?r"rrrr(s4&P5QQ-@^ * rrcR\rSrSrSrS Sjr\S5r\S5rS Sjr Sr S r g) RBFiaRadial basis function kernel (aka squared-exponential kernel). The RBF kernel is a stationary kernel. It is also known as the "squared exponential" kernel. It is parameterized by a length scale parameter :math:`l>0`, which can either be a scalar (isotropic variant of the kernel) or a vector with the same number of dimensions as the inputs X (anisotropic variant of the kernel). The kernel is given by: .. math:: k(x_i, x_j) = \exp\left(- \frac{d(x_i, x_j)^2}{2l^2} \right) where :math:`l` is the length scale of the kernel and :math:`d(\cdot,\cdot)` is the Euclidean distance. For advice on how to set the length scale parameter, see e.g. [1]_. This kernel is infinitely differentiable, which implies that GPs with this kernel as covariance function have mean square derivatives of all orders, and are thus very smooth. See [2]_, Chapter 4, Section 4.2, for further details of the RBF kernel. Read more in the :ref:`User Guide `. .. versionadded:: 0.18 Parameters ---------- length_scale : float or ndarray of shape (n_features,), default=1.0 The length scale of the kernel. If a float, an isotropic kernel is used. If an array, an anisotropic kernel is used where each dimension of l defines the length-scale of the respective feature dimension. length_scale_bounds : pair of floats >= 0 or "fixed", default=(1e-5, 1e5) The lower and upper bound on 'length_scale'. If set to "fixed", 'length_scale' cannot be changed during hyperparameter tuning. References ---------- .. [1] `David Duvenaud (2014). "The Kernel Cookbook: Advice on Covariance functions". `_ .. [2] `Carl Edward Rasmussen, Christopher K. I. Williams (2006). "Gaussian Processes for Machine Learning". The MIT Press. `_ 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.8354, 0.03228, 0.1322], [0.7906, 0.0652, 0.1441]]) cXlX lgr3rlength_scale_bounds)r5rrs rrJ RBF.__init__s(#6 rc[R"UR5=(a [UR5S:$)Nr)riterablerrQros r anisotropicRBF.anisotropics,{{4,,-L#d6G6G2H12LLrcUR(a+[SSUR[UR55$[SSUR5$Nrru)rr rrQrros rhyperparameter_length_scaleRBF.hyperparameter_length_scalesL   !((D%%&   ni9Q9QRRrNc[R"U5n[XR5nUcH[ X- SS9n[R "SU-5n[ U5n[R"US5 O:U(a [S5e[X- X$- SS9n[R "SU-5nU(GaURR(a5U[R"URSURSS454$UR(aURSS:Xa)U[ U5-SS2SS2[R4nXg4$UR(aXUSS2[RSS24U[RSS2SS24- S-US-- nXvS [R4-nXg4$gU$) DReturn the kernel k(X, Y) and optionally its gradient. Parameters ---------- X : ndarray of shape (n_samples_X, n_features) Left argument of the returned kernel k(X, Y) Y : ndarray of shape (n_samples_Y, n_features), default=None Right argument of the returned kernel k(X, Y). If None, k(X, X) if evaluated instead. eval_gradient : bool, default=False Determines whether the gradient with respect to the log of the kernel hyperparameter is computed. Only supported when Y is None. Returns ------- K : ndarray of shape (n_samples_X, n_samples_Y) Kernel k(X, Y) K_gradient : ndarray of shape (n_samples_X, n_samples_X, n_dims), optional The gradient of the kernel k(X, X) with respect to the log of the hyperparameter of the kernel. Only returned when `eval_gradient` is True. N sqeuclideanmetricgrryrr .)rr'rrrrr fill_diagonalrrrr$r}rrr)r5rrrrdistsrrds rr RBF.__call__s8 MM! *1.?.?@ 9!*=AEte|$A1 A   Q " !QRR!*A,<]SEte|$A //55"((AGGAJ A#>???%%););A)>!)C*U"33Q2::5EF }$!!2::q 01Abjj!Q6F4GGAM !O RZZ00 }$ "Hrc XUR(aSSRURRSR [ SRUR 555$SRURR[R"UR 5S5$)Nz{0}(length_scale=[{1}])rrz{0}(length_scale={1:.3g})r) rrr0r9rrrrravelros rr RBF.__repr__0s   ,33'' #i..0A0ABC  /55''$2C2C)DQ)G rrrr) r9r:r;r<r=rJrrrrrr?r"rrrrsD<|7MMSS9v rrc@^\rSrSrSrSU4SjjrSSjrSrSrU=r $) Materni<u Matern kernel. The class of Matern kernels is a generalization of the :class:`RBF`. It has an additional parameter :math:`\nu` which controls the smoothness of the resulting function. The smaller :math:`\nu`, the less smooth the approximated function is. As :math:`\nu\rightarrow\infty`, the kernel becomes equivalent to the :class:`RBF` kernel. When :math:`\nu = 1/2`, the Matérn kernel becomes identical to the absolute exponential kernel. Important intermediate values are :math:`\nu=1.5` (once differentiable functions) and :math:`\nu=2.5` (twice differentiable functions). The kernel is given by: .. math:: k(x_i, x_j) = \frac{1}{\Gamma(\nu)2^{\nu-1}}\Bigg( \frac{\sqrt{2\nu}}{l} d(x_i , x_j ) \Bigg)^\nu K_\nu\Bigg( \frac{\sqrt{2\nu}}{l} d(x_i , x_j )\Bigg) where :math:`d(\cdot,\cdot)` is the Euclidean distance, :math:`K_{\nu}(\cdot)` is a modified Bessel function and :math:`\Gamma(\cdot)` is the gamma function. See [1]_, Chapter 4, Section 4.2, for details regarding the different variants of the Matern kernel. Read more in the :ref:`User Guide `. .. versionadded:: 0.18 Parameters ---------- length_scale : float or ndarray of shape (n_features,), default=1.0 The length scale of the kernel. If a float, an isotropic kernel is used. If an array, an anisotropic kernel is used where each dimension of l defines the length-scale of the respective feature dimension. length_scale_bounds : pair of floats >= 0 or "fixed", default=(1e-5, 1e5) The lower and upper bound on 'length_scale'. If set to "fixed", 'length_scale' cannot be changed during hyperparameter tuning. nu : float, default=1.5 The parameter nu controlling the smoothness of the learned function. The smaller nu, the less smooth the approximated function is. For nu=inf, the kernel becomes equivalent to the RBF kernel and for nu=0.5 to the absolute exponential kernel. Important intermediate values are nu=1.5 (once differentiable functions) and nu=2.5 (twice differentiable functions). Note that values of nu not in [0.5, 1.5, 2.5, inf] incur a considerably higher computational cost (appr. 10 times higher) since they require to evaluate the modified Bessel function. Furthermore, in contrast to l, nu is kept fixed to its initial value and not optimized. References ---------- .. [1] `Carl Edward Rasmussen, Christopher K. I. Williams (2006). "Gaussian Processes for Machine Learning". The MIT Press. `_ Examples -------- >>> from sklearn.datasets import load_iris >>> from sklearn.gaussian_process import GaussianProcessClassifier >>> from sklearn.gaussian_process.kernels import Matern >>> X, y = load_iris(return_X_y=True) >>> kernel = 1.0 * Matern(length_scale=1.0, nu=1.5) >>> gpc = GaussianProcessClassifier(kernel=kernel, ... random_state=0).fit(X, y) >>> gpc.score(X, y) 0.9866 >>> gpc.predict_proba(X[:2,:]) array([[0.8513, 0.0368, 0.1117], [0.8086, 0.0693, 0.1220]]) c0>[TU]X5 X0lgr3)r)rJnu)r5rrrr0s rrJMatern.__init__s ;rc 4 ^^^[R"T5m[TTR5nTc[ TU- SS9nO#U(a [ S5e[ TU- TU- SS9nTRS:Xa[R"U*5nGOTRS:Xa8U[R"S5-nSU-[R"U*5-nGOFTRS :Xa@U[R"S 5-nSU-US -S - -[R"U*5-nOTR[R:Xa[R"US -*S - 5nOUnXfS:H==[R"[5R- ss'[R"S TR-5U-nURS STR- -[!TR5- 5 XgTR--nU[#TRU5-nTc"[%U5n[R&"US5 U(GaTR(R*(a6[R,"TR.STR.SS45nXh4$TR0(a?TSS2[R2SS24T[R2SS2SS24- S -US -- n O&[%US -5SS2SS2[R24n TRS:Xa[R"U R5S S95SS2SS2[R24n [R6"U 5n [R8"U U U U S:gS9 US[R24U -nGO-TRS:XaWSU -[R"[R"SU R5S5-5*5S[R24-nOTRS :Xa_[R"S U R5S5-5S[R24nSU -US--[R"U*5-nOWTR[R:XaXS[R24-nO!UUU4Sjn U[;TR<U S54$TR0(d3XhSS2SS24R5S5SS2SS2[R244$Xh4$U$)rN euclideanrryg??rrg@r g@g@rr)axis)outwhere.g?c4>TRU5"TT5$r3)rl)rjrrr5s rfMatern.__call__..fs0071==r绽|=)rr'rrrrrrrmathrinffinforepsfillr r r rrr$r}rrrsum zeros_likedivide_approx_fprimerj) r5rrrrrrtmprdD denominator divide_resultrs ``` rrMatern.__call__s8 MM! *1d.?.?@ 9!l*;?E !QRR!l*A ,<[QE 77c>vA WW^ ! $AqBFFA2J&A WW^ ! $Aq1a4#:%3A WW {S()AA 3hK288E?.. .K))AK(1,C FFA#-(E$''N: ; dgg A DGGS! !A 91 A   Q " //55XXqwwqz1771:q&AB }$q"**a'(1RZZA-=+>>1D VWXuax(Arzz)9:ww#~ ggaeeem4Q2::5EF " a 0  %%*  sBJJ/-? CURVVRWWQr]-C,C%DS"**_%UU Cgga!%%)m,S"**_=&]cAg6E BFF"3 ?!33 >.Q>>>##QT*..r21a3CDDD}$Hrc UR(a^SRURRSR [ SRUR 55UR5$SRURR[R"UR 5SUR5$)Nz#{0}(length_scale=[{1}], nu={2:.3g})rrz%{0}(length_scale={1:.3g}, nu={2:.3g})r) rrr0r9rrrrrrros rrMatern.__repr__s   8??'' #i..0A0ABC  ;AA''$2C2C)DQ)G r)r)rrrr) r9r:r;r<r=rJrrr?r@rAs@rrr<s M^eN  rrcZ\rSrSrSrS Sjr\S5r\S5rS Sjr Sr S r g) RationalQuadraticiaRational Quadratic kernel. The RationalQuadratic kernel can be seen as a scale mixture (an infinite sum) of RBF kernels with different characteristic length scales. It is parameterized by a length scale parameter :math:`l>0` and a scale mixture parameter :math:`\alpha>0`. Only the isotropic variant where length_scale :math:`l` is a scalar is supported at the moment. The kernel is given by: .. math:: k(x_i, x_j) = \left( 1 + \frac{d(x_i, x_j)^2 }{ 2\alpha l^2}\right)^{-\alpha} where :math:`\alpha` is the scale mixture parameter, :math:`l` is the length scale of the kernel and :math:`d(\cdot,\cdot)` is the Euclidean distance. For advice on how to set the parameters, see e.g. [1]_. Read more in the :ref:`User Guide `. .. versionadded:: 0.18 Parameters ---------- length_scale : float > 0, default=1.0 The length scale of the kernel. alpha : float > 0, default=1.0 Scale mixture parameter length_scale_bounds : pair of floats >= 0 or "fixed", default=(1e-5, 1e5) The lower and upper bound on 'length_scale'. If set to "fixed", 'length_scale' cannot be changed during hyperparameter tuning. alpha_bounds : pair of floats >= 0 or "fixed", default=(1e-5, 1e5) The lower and upper bound on 'alpha'. If set to "fixed", 'alpha' cannot be changed during hyperparameter tuning. References ---------- .. [1] `David Duvenaud (2014). "The Kernel Cookbook: Advice on Covariance functions". `_ Examples -------- >>> from sklearn.datasets import load_iris >>> from sklearn.gaussian_process import GaussianProcessClassifier >>> from sklearn.gaussian_process.kernels import RationalQuadratic >>> X, y = load_iris(return_X_y=True) >>> kernel = RationalQuadratic(length_scale=1.0, alpha=1.5) >>> gpc = GaussianProcessClassifier(kernel=kernel, ... random_state=0).fit(X, y) >>> gpc.score(X, y) 0.9733 >>> gpc.predict_proba(X[:2,:]) array([[0.8881, 0.0566, 0.05518], [0.8678, 0.0707 , 0.0614]]) c4XlX lX0lX@lgr3)ralphar alpha_bounds)r5rrrrs rrJRationalQuadratic.__init__Cs) #6 (rc0[SSUR5$rr rros rr-RationalQuadratic.hyperparameter_length_scaleOsni9Q9QRRrc0[SSUR5$)Nrru)r rros rhyperparameter_alpha&RationalQuadratic.hyperparameter_alphaSgy$2C2CDDrNc[[R"UR55S:a [ S5e[R "U5nUca[ [USS95nUSUR-URS--- nSU-nX`R*-n[R"US5 OOU(a [S5e[XSS9nSUSUR-URS--- -UR*-nU(GaBURR(d2XG-URS-W-- nUSS2SS2[R4nO3[R"UR SUR SS45nUR"R(d[UUR*[R$"W5-USURS--U-- --n U SS2SS2[R4n O3[R"UR SUR SS45n U[R&"X454$U$) a(Return the kernel k(X, Y) and optionally its gradient. Parameters ---------- X : ndarray of shape (n_samples_X, n_features) Left argument of the returned kernel k(X, Y) Y : ndarray of shape (n_samples_Y, n_features), default=None Right argument of the returned kernel k(X, Y). If None, k(X, X) if evaluated instead. eval_gradient : bool, default=False Determines whether the gradient with respect to the log of the kernel hyperparameter is computed. Only supported when Y is None. Returns ------- K : ndarray of shape (n_samples_X, n_samples_Y) Kernel k(X, Y) K_gradient : ndarray of shape (n_samples_X, n_samples_X, n_dims) The gradient of the kernel k(X, X) with respect to the log of the hyperparameter of the kernel. Only returned when eval_gradient is True. rzeRationalQuadratic kernel only supports isotropic version, please use a single scalar for length_scaleNrrr ryr)rQr atleast_1drAttributeErrorr'r rrrrrrr$rr}rrr|r) r5rrrrrbaserlength_scale_gradientalpha_gradients rrRationalQuadratic.__call__Ws6 r}}T../ 01 4 >  MM!  9uQ}=>E1tzz>D,=,=q,@@ACs7Dzzk!A   Q " !QRR!}5EUa$**nt/@/@!/CCDD$**TA 3399(- T5F5F5ID5P(Q%(=aBJJ>N(O%(*!''!*aggaj!1L(M%,,22!"ZZK"&&,.q4#4#4a#77$>?@""01bjj0@!A!#1771:qwwqz1*E!Fbii GHH HHrcxSRURRURUR5$)Nz({0}(alpha={1:.3g}, length_scale={2:.3g}))rr0r9rrros rrRationalQuadratic.__repr__s09@@ NN # #TZZ1B1B  r)rrrrrrrrr) r9r:r;r<r=rJrrrrrr?r"rrrrsS<@' )SSEEAF rrcZ\rSrSrSrS Sjr\S5r\S5rS Sjr Sr S r g) ExpSineSquarediaExp-Sine-Squared kernel (aka periodic kernel). The ExpSineSquared kernel allows one to model functions which repeat themselves exactly. It is parameterized by a length scale parameter :math:`l>0` and a periodicity parameter :math:`p>0`. Only the isotropic variant where :math:`l` is a scalar is supported at the moment. The kernel is given by: .. math:: k(x_i, x_j) = \text{exp}\left(- \frac{ 2\sin^2(\pi d(x_i, x_j)/p) }{ l^ 2} \right) where :math:`l` is the length scale of the kernel, :math:`p` the periodicity of the kernel and :math:`d(\cdot,\cdot)` is the Euclidean distance. Read more in the :ref:`User Guide `. .. versionadded:: 0.18 Parameters ---------- length_scale : float > 0, default=1.0 The length scale of the kernel. periodicity : float > 0, default=1.0 The periodicity of the kernel. length_scale_bounds : pair of floats >= 0 or "fixed", default=(1e-5, 1e5) The lower and upper bound on 'length_scale'. If set to "fixed", 'length_scale' cannot be changed during hyperparameter tuning. periodicity_bounds : pair of floats >= 0 or "fixed", default=(1e-5, 1e5) The lower and upper bound on 'periodicity'. If set to "fixed", 'periodicity' cannot be changed during hyperparameter tuning. Examples -------- >>> from sklearn.datasets import make_friedman2 >>> from sklearn.gaussian_process import GaussianProcessRegressor >>> from sklearn.gaussian_process.kernels import ExpSineSquared >>> X, y = make_friedman2(n_samples=50, noise=0, random_state=0) >>> kernel = ExpSineSquared(length_scale=1, periodicity=1) >>> gpr = GaussianProcessRegressor(kernel=kernel, alpha=5, ... random_state=0).fit(X, y) >>> gpr.score(X, y) 0.0144 >>> gpr.predict(X[:2,:], return_std=True) (array([425.6, 457.5]), array([0.3894, 0.3467])) c4XlX lX0lX@lgr3)r periodicityrperiodicity_bounds)r5rrrrs rrJExpSineSquared.__init__s)&#6 "4rc0[SSUR5$)zReturns the length scalerrurros rr*ExpSineSquared.hyperparameter_length_scalesni9Q9QRRrc0[SSUR5$)Nrru)r rros rhyperparameter_periodicity)ExpSineSquared.hyperparameter_periodicityrrNc[R"U5nUcr[[USS95n[RU-UR - n[R "U5n[R"SX`R- S--5nOwU(a [S5e[XSS9n[R"S[R "[RUR - U-5UR- S--5nU(Ga:[R"W5nURR(d6SURS-- WS--U-n U SS2SS2[R4n O3[R"UR SUR S S45n UR"R(d9SU-URS-- U-W-U-n U SS2SS2[R4n O3[R"UR SUR S S45n U[R$"X454$U$) rNrrr ryrr)rr'r rpirsinrrrrcosrr$rr}rrr) r5rrrrrZ sin_of_argr cos_of_argrperiodicity_gradients rrExpSineSquared.__call__s8 MM!  9uQ{;ARARRWXXXA J3399()D,=,=q,@(@:q=(PST(T%(=aBJJ>N(O%(*!''!*aggaj!1L(M%2288Gd//22Z?*LqP%(`. .. versionadded:: 0.18 Parameters ---------- sigma_0 : float >= 0, default=1.0 Parameter controlling the inhomogenity of the kernel. If sigma_0=0, the kernel is homogeneous. sigma_0_bounds : pair of floats >= 0 or "fixed", default=(1e-5, 1e5) The lower and upper bound on 'sigma_0'. If set to "fixed", 'sigma_0' cannot be changed during hyperparameter tuning. References ---------- .. [1] `Carl Edward Rasmussen, Christopher K. I. Williams (2006). "Gaussian Processes for Machine Learning". The MIT Press. `_ Examples -------- >>> from sklearn.datasets import make_friedman2 >>> from sklearn.gaussian_process import GaussianProcessRegressor >>> from sklearn.gaussian_process.kernels import DotProduct, WhiteKernel >>> X, y = make_friedman2(n_samples=500, noise=0, random_state=0) >>> kernel = DotProduct() + WhiteKernel() >>> gpr = GaussianProcessRegressor(kernel=kernel, ... random_state=0).fit(X, y) >>> gpr.score(X, y) 0.3680 >>> gpr.predict(X[:2,:], return_std=True) (array([653.0, 592.1]), array([316.6, 316.6])) cXlX lgr3sigma_0sigma_0_bounds)r5r r s rrJDotProduct.__init__js  ,rc0[SSUR5$)Nr ru)r r ros rhyperparameter_sigma_0!DotProduct.hyperparameter_sigma_0nsiD4G4GHHrNc:[R"U5nUc'[R"X5URS--nO8U(a [ S5e[R"X5URS--nU(aUR R (dK[R"URSURSS45nSURS--US'XE4$U[R"URSURSS454$U$)CReturn the kernel k(X, Y) and optionally its gradient. Parameters ---------- X : ndarray of shape (n_samples_X, n_features) Left argument of the returned kernel k(X, Y) Y : ndarray of shape (n_samples_Y, n_features), default=None Right argument of the returned kernel k(X, Y). If None, k(X, X) if evaluated instead. eval_gradient : bool, default=False Determines whether the gradient with respect to the log of the kernel hyperparameter is computed. Only supported when Y is None. Returns ------- K : ndarray of shape (n_samples_X, n_samples_Y) Kernel k(X, Y) K_gradient : ndarray of shape (n_samples_X, n_samples_X, n_dims), optional The gradient of the kernel k(X, X) with respect to the log of the hyperparameter of the kernel. Only returned when `eval_gradient` is True. r ryrr).r) rr'innerr rr r$r}rrcs rrDotProduct.__call__rs8 MM!  9q0A !QRRq0A ..44XXqwwqz1771:q&AB %&q%8 6"}$"((AGGAJ A#>???HrcP[R"SX5URS--$)aReturns the diagonal of the kernel k(X, X). The result of this method is identical to np.diag(self(X)); however, it can be evaluated more efficiently since only the diagonal is evaluated. Parameters ---------- X : ndarray of shape (n_samples_X, n_features) Left argument of the returned kernel k(X, Y). Returns ------- K_diag : ndarray of shape (n_samples_X,) Diagonal of kernel k(X, X). zij,ij->ir )reinsumr rs rrDotProduct.diags""yyQ*T\\1_<= 0 or "fixed", default=(1e-5, 1e5) The lower and upper bound on 'gamma'. If set to "fixed", 'gamma' cannot be changed during hyperparameter tuning. metric : {"linear", "additive_chi2", "chi2", "poly", "polynomial", "rbf", "laplacian", "sigmoid", "cosine"} or callable, default="linear" The metric to use when calculating kernel between instances in a feature array. If metric is a string, it must be one of the metrics in pairwise.PAIRWISE_KERNEL_FUNCTIONS. If metric is "precomputed", X is assumed to be a kernel matrix. Alternatively, if metric is a callable function, it is called on each pair of instances (rows) and the resulting value recorded. The callable should take two arrays from X as input and return a value indicating the distance between them. pairwise_kernels_kwargs : dict, default=None All entries of this dict (if any) are passed as keyword arguments to the pairwise kernel function. Examples -------- >>> from sklearn.datasets import load_iris >>> from sklearn.gaussian_process import GaussianProcessClassifier >>> from sklearn.gaussian_process.kernels import PairwiseKernel >>> X, y = load_iris(return_X_y=True) >>> kernel = PairwiseKernel(metric='rbf') >>> gpc = GaussianProcessClassifier(kernel=kernel, ... random_state=0).fit(X, y) >>> gpc.score(X, y) 0.9733 >>> gpc.predict_proba(X[:2,:]) array([[0.8880, 0.05663, 0.05532], [0.8676, 0.07073, 0.06165]]) Nc4XlX lX0lX@lgr3r gamma_boundsrpairwise_kernels_kwargs)r5r r%rr&s rrJPairwiseKernel.__init__ s ( '>$rc0[SSUR5$)Nr ru)r r%ros rhyperparameter_gamma#PairwiseKernel.hyperparameter_gamma rrc^^^^TRmTRc0m[R"T5m[TT4TRTR SS.TD6nU(arTR R(a5U[R"TRSTRSS454$UUUU4SjnU[TRUS54$U$)rTrr filter_paramsrcb>[TT4TR[R"U5SS.TD6$)NTr,)rrrr)r rrr&r5s rr"PairwiseKernel.__call__..f? s<+ ${{ ffUm&*  2 rr) r&rr'rrr r)r$r}rrrj)r5rrrrrr&s``` @rrPairwiseKernel.__call__ s8#'">">  ' ' /&( # MM!    ;;**  &   ((.."((AGGAJ A#>???.Q>>>HrcN[R"USU5R5$)rr)rapply_along_axisrrs rrPairwiseKernel.diagM s"$""4A.4466rc URS;$)r)rbfrros rrPairwiseKernel.is_stationarya s{{g%%rcxSRURRURUR5$)Nz{0}(gamma={1}, metric={2}))rr0r9r rros rrPairwiseKernel.__repr__e s.+22 NN # #TZZ  rr$)rrlinearNr) r9r:r;r<r=rJrr)rrrrr?r"rrr"r"sF6t  $ ?EE:x7(& rr")r")/r=rrabcrr collectionsrinspectrnumpyrscipy.spatial.distancerrr scipy.specialr r rr exceptionsrmetrics.pairwiserutils.validationrrr rCrrrrr rrrrrrrrrrrr"r"rrrCskX. '";;#+/+ ` Q` Ftwtn ##4  aHVaHHsNVsNl^4.^4Ba4na4H|1V|1~GA*,>GATx ');Vx vV !6VrESEPY -/DfY xN *,A6N bGTGTV ` V` r