0Ph-MdZddlZddlZddlmZmZddlmZddlm Z ddl Z ddl m Z mZmZddlmZmZdd lmZdd lmZdd lmZdd lmZd ZGddeddZGddeZGddZGddZGddZ GddeZ!GddeZ"Gdde"Z#Gd d!e"Z$Gd"d#eZ%Gd$d%ee eZ&Gd&d'ee eZ'Gd(d)eeeZ(Gd*d+e(Z)Gd,d-eeeZ*Gd.d/eeeZ+Gd0d1eZ,d6d3Z-Gd4d5eZ.dS)7zRA 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_sampleschtj|t}tj|dkrt dtj|dkrF|jd|jdkr*t d|jd|jdfz|S)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 `/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/sklearn/gaussian_process/kernels.py_check_length_scaler(s:l++22599L w|q  MNNN w|!!agajL4Fq4I&I&I *-9-?-BAGAJ,O P    c.eZdZdZdZdfd ZdZxZS)HyperparameteraIA 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) rNct|tr|dkrstj|}|dkrY|jddkrtj||d}n1|jd|kr t d|||jdfz|t|to|dk}tt| ||||||S)Nfixedrrz@Bounds on %s should have either 1 or %d dimensions. Given are %d) isinstancestrr atleast_2drrepeatrsuperr __new__)clsname value_typebounds n_elementsr# __class__s rr)zHyperparameter.__new__zs&#&& &G*;*;]6**FA~~<?a''Yvz1==FF\!_ 22$6V\!_=> =vs++A'0AE^S))11 z6:u   rc|j|jkoQ|j|jkoAtj|j|jko|j|jko|j|jkSN)r+r,rallr-r.r#)selfothers r__eq__zHyperparameter.__eq__sg I # *5#33 *t{el233 *5#33 * ek)  r)rN)__name__ __module__ __qualname____doc__ __slots__r)r5 __classcell__r/s@rr r 4s^ 55~I      *       rr )r+r,r-r.r#c(eZdZdZddZdZdZedZedZ edZ e j d Z ed Z d Z d Zd ZdZdZdZdZeddZedZedZedZdZdS)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]] Tct}|j}t|jd|j}t |}gg}}|jD]a}|j|jkr%|j dkr| |j |j|j kr| |j bt|dkrtd|d|D]} t|| || <|S)XGet 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_originalr3rzmscikit-learn kernels should always specify their parameters in the signature of their __init__ (no varargs). z doesn't follow this convention.)dictr/getattr__init__r parametersvalueskind VAR_KEYWORDr+appendVAR_POSITIONALlen RuntimeError) r3deepparamsr*init init_signargsvarargs parameterargs r get_paramszKernel.get_paramssns|%:CLIIdOO Bg"-4466 / /I~!6669>V;S;S IN+++~!999y~... w<<1  ,:=?   - -C!$,,F3KK rc |s|S|d}|D]\}}|dd}t|dkr7|\}}||vrt d|d|d||}|jdi||ie||vr t d|d|jjdt||||S) a:Set 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)rM__rzInvalid parameter z for kernel zK. Check the list of available parameters with `kernel.get_params().keys()`.r!) rUitemssplitrKr set_paramsr/r6setattr) r3rN valid_paramskeyvaluerYr+sub_name sub_objects rrZzKernel.set_paramss% KD11  ,,.. * *JCIIdA&&E5zzA~~!&h|++$*AEdddL *$/ % %::5(9::::l**$*33 7 7 79 c5)))) rc2t|}||_|S)zReturns a clone of self with given hyperparameters theta. Parameters ---------- theta : ndarray of shape (n_dims,) The hyperparameters )r theta)r3rbcloneds rclone_with_thetazKernel.clone_with_thetast  rc&|jjdS)z>Returns the number of non-fixed hyperparameters of the kernel.r)rbrr3s rn_dimsz Kernel.n_dimssz""rc>fdtD}|S)z4Returns a list of all hyperparameter specifications.cZg|]'}|dt|(S)hyperparameter_) startswithrC).0attrr3s r z*Kernel.hyperparameters..sF   011 D$     r)dir)r3rs` rhyperparameterszKernel.hyperparameterss8    D     rc*g}|}|jD])}|js |||j*t |dkr&t jt j|St j gS)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) rUrqr#rIr+rKrloghstackarray)r3rbrNhyperparameters rrbz Kernel.thetas"""2 : :N!' : VN$78999 u::>>6")E**++ +8B<< rc|}d}|jD]s}|jr |jdkr7t j||||jz||j<||jz }Lt j||||j<|dz }t|t|kr!td|t|fz|j di|dS)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!) rUrqr#r.rexpr+rKrrZ)r3rbrNirws rrbz Kernel.theta7s"" "2  N# (1,,.0f!a.";;;<//~*+^...0fU1X.>.>~*+Q E ??.12CJJ@  !!&!!!!!rcd|jD}t|dkr&tjtj|StjgS)Returns 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 c*g|]}|j |jSr!)r#r-rlrws rrnz!Kernel.bounds.._s4   !'  !   rr)rqrKrrtvstackrv)r3r-s rr-z Kernel.boundsVs\  "&"6    v;;??6")F++,, ,8B<< rct|tst|t|St||Sr1r$r>SumConstantKernelr3bs r__add__zKernel.__add__is:!V$$ 0t^A..// /4||rct|tstt||St||Sr1rrs r__radd__zKernel.__radd__ns:!V$$ 0~a(($// /1d||rct|tst|t|St||Sr1r$r>Productrrs r__mul__zKernel.__mul__ss<!V$$ 44!2!233 3tQrct|tstt||St||Sr1rrs r__rmul__zKernel.__rmul__xs<!V$$ 4>!,,d33 3q$rc"t||Sr1)Exponentiationrs r__pow__zKernel.__pow__}sdA&&&rct|t|krdS|}|}tt|t|zD]E}t j||d||dkrdSFdS)NFT)typerUsetlistkeysranyget)r3rparams_aparams_br]s rr5z Kernel.__eq__s ::a 5??$$<<>>tHMMOO,,tHMMOO/D/DDEE  Cvhll3--c41H1HHII uu trc d|jjdt dj|jS)Nz{0}({1}), {0:.3g})formatr/r6joinmaprbrfs r__repr__zKernel.__repr__s?  N #TYYs93CTZ/P/P%Q%Q   rNFcdS)zEvaluate the kernel.Nr!)r3rY eval_gradients r__call__zKernel.__call__rcdS)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!r3rs rdiagz Kernel.diagrrcdS))Returns whether the kernel is stationary.Nr!rfs r is_stationaryzKernel.is_stationaryrrcdS)zReturns whether the kernel is defined on fixed-length feature vectors or generic objects. Defaults to True for backward compatibility.Tr!rfs rrequires_vector_inputzKernel.requires_vector_inputs trc tj|jtj|jj}d}|jD]}|jr t|j D]}||dfr;tj d|d|j d|j|ddtnD||dfr:tj d|d|j d|j|ddt|dz }d S) 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&rbTrqr#ranger.warningswarnr+r)r3 list_closeidxhypdims r_check_bounds_paramszKernel._check_bounds_paramss0Z R]4:-F-F-HII '  Cy S^,,  c1f%MM ,/33#*S/!:L:L:L N + Q' MM ,/33#*S/!:L:L:L N +q+   rTNF)r6r7r8r9rUrZrdpropertyrgrqrbsetterr-rrrrrr5rrrrrrrr!rrr>r>s4&&&&P&&&P   ##X#X  X . \""\"<  X $        '''   ###^#  ^ $88^8X rr>) metaclassceZdZdZdZdS)NormalizedKernelMixinzSMixin for kernels which are normalized: k(X, X)=1. .. versionadded:: 0.18 c@tj|jdS)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 rrzNormalizedKernelMixin.diags"wqwqz"""rN)r6r7r8r9rr!rrrrs- #####rrceZdZdZdZdS)StationaryKernelMixinzYMixin for kernels which are stationary: k(X, Y)= f(X-Y). .. versionadded:: 0.18 cdS)rTr!rfs rrz#StationaryKernelMixin.is_stationarystrN)r6r7r8r9rr!rrrrs- rrc(eZdZdZedZdS)GenericKernelMixinzMixin for kernels which operate on generic objects such as variable- length sequences, trees, and graphs. .. versionadded:: 0.22 cdS)z>Whether the kernel works only on fixed-length feature vectors.Fr!rfs rrz(GenericKernelMixin.requires_vector_inputs urN)r6r7r8r9rrr!rrrrs9 XrrceZdZdZdZddZedZejdZedZ dd Z d Z d Z ed Z dZdS)CompoundKernelaKernel 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] c||_dSr1kernels)r3rs rrDzCompoundKernel.__init__s  rTc,t|jS)r@r)rBr)r3rMs rrUzCompoundKernel.get_paramssDL))))rcHtjd|jDS)rscg|] }|j Sr!)rbrlkernels rrnz(CompoundKernel.theta..=sBBB6&,BBBr)rrurrfs rrbzCompoundKernel.theta/s%yBBT\BBBCCCrc|jj}t|jD]\}}|||z|dz|z|_dS)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)k1rg enumeraterrb)r3rbk_dimsr{rs rrbzCompoundKernel.theta?sX"4<00 @ @IAv Vq1u.>!>?FLL @ @rcHtjd|jDS)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 cg|] }|j Sr!)r-rs rrnz)CompoundKernel.bounds..UsCCCF&-CCCr)rrrrfs rr-zCompoundKernel.boundsLs%yCCdlCCCDDDrNFc`rg}g}|jD]N}|\}}||||dtjfOtj|tj|dfStjfd|jDS)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. .c*g|]}|Sr!r!)rlrrrrs rrnz+CompoundKernel.__call__..s'UUUfffQ=99UUUr)rrIrnewaxisdstack concatenate) r3rrrKK_gradrK_single K_grad_singles ``` rrzCompoundKernel.__call__Ws@  WAF, > >*0&A}*E*E'-""" mCO<====9Q<<!:!:: :9UUUUUU UUUVV Vrcttks*tjtjkrdStjfdt tjDS)NFcHg|]}j|j|kSr!r)rlr{rr3s rrnz)CompoundKernel.__eq__..s* O O OT\!_ ! , O O Or)rrKrrr2rrs``rr5zCompoundKernel.__eq__s| ::a C $5$5QY$G$G5v O O O O OeC .s$III&v++--IIIr)rr2rrfs rrzCompoundKernel.is_stationarys#vIIDLIIIJJJrcHtjd|jDS)=Returns whether the kernel is defined on discrete structures.cg|] }|j Sr!)rrs rrnz8CompoundKernel.requires_vector_input..sOOOv3OOOr)rrrrfs rrz$CompoundKernel.requires_vector_inputs%vOO$,OOOPPPrcXtjfd|jDjS)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, n_kernels) Diagonal of kernel k(X, X) c:g|]}|Sr!)r)rlrrs rrnz'CompoundKernel.diag..s#DDDV&++a..DDDr)rrrrrs `rrzCompoundKernel.diags/"yDDDDt|DDDEEGGrrr)r6r7r8r9rDrUrrbrr-rr5rrrr!rrrrs 2****  D DX D \ @ @\ @EEXE)W)W)W)WV   KKKQQXQHHHHHrrceZdZdZdZd dZedZedZej dZedZ d Z d Z ed Z d S)KernelOperatorzEBase class for all kernel operators. .. versionadded:: 0.18 c"||_||_dSr1rk2)r3rrs rrDzKernelOperator.__init__srTcht|j|j}|r|j}|d|D|j}|d|D|S)r@rc3*K|]\}}d|z|fVdS)k1__Nr!rlkvals r z,KernelOperator.get_params../EE36A:s+EEEEEErc3*K|]\}}d|z|fVdS)k2__Nr!rs rrz,KernelOperator.get_params..rr)rBrrrUrXupdater3rMrN deep_itemss rrUzKernelOperator.get_paramssTW---  F++--3355J MMEE*EEE E E E++--3355J MMEE*EEE E E E rc d|jjD}|jjD]>}|t d|jz|j|j|j?|S)%Returns a list of all hyperparameter.c`g|]+}td|jz|j|j|j,S)r)r r+r,r-r.rs rrnz2KernelOperator.hyperparameters..sQ    ,,)%)      rr) rrqrrIr r+r,r-r.r3rprws rrqzKernelOperator.hyperparameterss  #''"9   #g5  N HH^00"-")"-     rcTtj|jj|jjSrs)rrIrrbrrfs rrbzKernelOperator.thetasy 666rcn|jj}|d||j_||d|j_dSryN)rrgrbr)r3rbk1_dimss rrbzKernelOperator.thetas3'.hwh ghh rc|jjjdkr |jjS|jjjdkr |jjSt j|jj|jjfS)r}r)rr-sizerrrrfs rr-zKernelOperator.boundssY 7> ! # #7> ! 7> ! # #7> !y$'.$'.9:::rct|t|krdS|j|jkr|j|jkp|j|jko|j|jkSr)rrrrs rr5zKernelOperator.__eq__ sX ::a 5143DGqtO GqtO /14 rcf|jo|jSr)rrrrfs rrzKernelOperator.is_stationarys)w$$&&B47+@+@+B+BBrc2|jjp |jjSr )rrrrfs rrz$KernelOperator.requires_vector_inputsw,M0MMrNr)r6r7r8r9rDrUrrqrbrr-r5rrr!rrrrs .X. 7 7X 7 \ ( (\ ( ; ;X ;   CCCNNXNNNrrc&eZdZdZddZdZdZdS)ra+The `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) NFc|rQ|||d\}}|||d\}}||ztj||ffS||||||zS)aReturn 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)rrrrr3rrrK1 K1_gradientK2 K2_gradients rrz Sum.__call__Cs8  1"gga$g??OB "gga$g??OB 7BI{K&@AAA A771a==4771a==0 0rcl|j||j|zS)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 rrzSum.diagf'"w||Aa00rcBd|j|jS)Nz {0} + {1}rrrrfs rrz Sum.__repr__y!!$'47333rrr6r7r8r9rrrr!rrrrsR$$L!1!1!1!1F111&44444rrc&eZdZdZddZdZdZdS)raYThe `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) NFc j|r|||d\}}|||d\}}||ztj||ddddtjfz||ddddtjfzffS||||||zS)aReturn 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. TrN)rrrrrrs rrzProduct.__call__s8  1"gga$g??OB "gga$g??OB 7BIr!!!QQQ "233[2aaaBJFVCW5WX 771a==4771a==0 0rcl|j||j|zSReturns 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) rrs rrz Product.diagrrcBd|j|jS)Nz {0} * {1}rrfs rrzProduct.__repr__rrrrr!rrrr}sR%%N#1#1#1#1J111&44444rrceZdZdZdZddZedZedZej dZedZ d Z dd Z d Z dZdZedZd S)raThe 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...])) c"||_||_dSr1rexponent)r3rr's rrDzExponentiation.__init__ s   rTct|j|j}|rJ|j}|d|D|S)r@r&c3*K|]\}}d|z|fVdS)kernel__Nr!rs rrz,Exponentiation.get_params..s/IIFAs:>3/IIIIIIr)rBrr'rUrXrrs rrUzExponentiation.get_paramsshT[4=AAA  J//117799J MMIIjIII I I I rc g}|jjD]>}|td|jz|j|j|j?|S)rr*)rrqrIr r+r,r-r.rs rrqzExponentiation.hyperparameters"si "k9  N HH!44"-")"-     rc|jjSrrrbrfs rrbzExponentiation.theta1s{  rc||j_dSrr-)r3rbs rrbzExponentiation.thetaAs" rc|jjS)r})rr-rfs rr-zExponentiation.boundsLs{!!rct|t|krdS|j|jko|j|jkSr)rrr'rs rr5zExponentiation.__eq__Ws; ::a 5{ah&F4=AJ+FFrNFc|rV|||d\}}||j|ddddtjf|jdz zzz}||jz|fS|||d}||jzS)aReturn 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. TrNrF)rr'rrr3rrrr K_gradients rrzExponentiation.__call__\s8  $ KK1DKAAMAz $-!AAAqqq"*,<*=$-RSBS*TT TJdm#Z/ / Aq 66Adm# #rcF|j||jzSr!)rrr'rs rrzExponentiation.diags!"{""dm33rcBd|j|jS)Nz {0} ** {1})rrr'rfs rrzExponentiation.__repr__s""4; >>>rc4|jSr )rrrfs rrzExponentiation.is_stationarys{((***rc|jjS)r)rrrfs rrz$Exponentiation.requires_vector_inputs{00rrr)r6r7r8r9rDrUrrqrbrr-r5rrrrrr!rrrrs&&P!!!(  X  ! !X ! \""\"""X"GGG "$"$"$"$H444&???+++11X111rrcDeZdZdZd dZedZd dZd Zd Z dS) raConstant 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.24...])) ?gh㈵>gj@c"||_||_dSr1)constant_valueconstant_value_bounds)r3r<r=s rrDzConstantKernel.__init__s,%:"""rc.tdd|jS)Nr<numeric)r r=rfs rhyperparameter_constant_valuez,ConstantKernel.hyperparameter_constant_values. 4;UVVVrNFc ||}n|rtdtjt|t|f|jtj|jj}|r|jjsW|tjt|t|df|jtj|jjfS|tj t|t|dffS|S)aReturn 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. N.Gradient can only be evaluated when Y is None.dtyperr) rrfullrr<rvrDr@r#emptyr3rrrrs rrzConstantKernel.__call__s: 9AA  OMNN N G !__l1oo .  (4.//5     5; JG%a,q//1=+ ht':;;A"(LOO\!__a#HIIIIHrctjt||jtj|jjSr"rC)rrErr<rvrDrs rrzConstantKernel.diags?"w OO  (4.//5    rcZdtj|jS)Nz {0:.3g}**2)rrsqrtr<rfs rrzConstantKernel.__repr__&s#""274+>#?#?@@@rr9r:r) r6r7r8r9rDrr@rrrr!rrrrs..`;;;;WWXW4444l   .AAAAArrcDeZdZdZd dZedZd dZd Zd Z dS) WhiteKernelabWhite 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...])) r9r:c"||_||_dSr1) noise_levelnoise_level_bounds)r3rPrQs rrDzWhiteKernel.__init__Ss&"4rc.tdd|jS)NrPr?)r rQrfs rhyperparameter_noise_levelz&WhiteKernel.hyperparameter_noise_levelWmY8OPPPrNFc||rtd||jtjt |z}|r|jjsB||jtjt |ddddtjfzfS|tjt |t |dffS|Stj t |t |fS)aReturn 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. NrBr) rrPreyerrSr#rrFzerosrGs rrzWhiteKernel.__call__[s: =]=MNN N 9 26,q//#:#::A 6<N(26,q//+B+B111aaaCS+TT bh Qa!'LMMMM8\!__l1oo>?? ?rctjt||jtj|jjSrI)rrErrPrvrDrs rrzWhiteKernel.diags="w OOT-RXd>N5O5O5U    rcLd|jj|jS)Nz{0}(noise_level={1:.3g}))rr/r6rPrfs rrzWhiteKernel.__repr__s')00 N #T%5   rrLr) r6r7r8r9rDrrSrrrr!rrrNrN*s&&P5555QQXQ-@-@-@-@^   *     rrNcTeZdZdZd dZedZedZd d Zd Z dS) RBFa Radial 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...]]) r9r:c"||_||_dSr1)rlength_scale_bounds)r3rr]s rrDz RBF.__init__s(#6   rcdtj|jot|jdkS)Nr)riterablerrKrfs r anisotropiczRBF.anisotropics*{4,--L#d6G2H2H12LLrc|jr)tdd|jt|jStdd|jSNrr?)r`r r]rKrrfs rhyperparameter_length_scalezRBF.hyperparameter_length_scalesP   !(D%&&   ni9QRRRrNFc@tj|}t||j}|Pt ||z d}tjd|z}t |}tj|dn@|rtdt||z ||z d}tjd|z}|r|j j r/|tj |j d|j ddffS|jr|j ddkr-|t |zddddtjf}||fS|jrW|ddtjddf|tjddddfz dz|dzz }||d tjfz}||fSdS|S) 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), 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 sqeuclideanmetricgrrBrr .)rr&rrrrzr fill_diagonalrrrcr#rFrr`r)r3rrrrdistsrr3s rrz RBF.__call__s8 M!  *1d.?@@ 9!l*=AAAEte|$$A1 A  Q " " " " S !QRRR!l*A ,<]SSSEte|$$A  /5 %"(AGAJ A#>????% %);A)>!)C)C*U"3"33QQQ2:5EF *}$! %2:qqq 01Abj!!!QQQ6F4GGAM !O aRZ00 *}$  % %Hrc  |jrKd|jjdt dj|jSd|jjtj|jdS)Nz{0}(length_scale=[{1}])rrz{0}(length_scale={1:.3g})r) r`rr/r6rrrrravelrfs rrz RBF.__repr__2s   ,33' #i.0ABBCC  /55'$2C)D)DQ)G rrLr) r6r7r8r9rDrr`rcrrr!rrr[r[s<<|7777MMXMSSXS9999v     rr[c2eZdZdZd fd Zd dZd ZxZS) Maternu 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...]]) r9r:?cZt||||_dSr1)r(rDnu)r3rr]rqr/s rrDzMatern.__init__s) ':;;;rNFc h tjtj}t |z d}n)|rt dt |z |z d}jdkrtj| }nbjdkr4|tj dz}d|ztj| z}n#jd kr<|tj d z}d|z|d zd z ztj| z}n܉jtj krtj|d z d z }n|}||dkxxtj tjz cc<tj d jz|z}|d djz zt!jz ||jzz}|t#j|z}$t%|}tj|d|rjjr1tjjdjddf}||fSjr=ddtjddftjddddfz d z|d zz } n)t%|d zddddtjf} jdkrtj | d ddddtjf} tj| } tj| | | | dk|dtjf| z}njdkrVd| ztjtj d| dz dtjfz}njd kr^tj d | dzdtjf}d| z|dzztj| z}nLjtj kr| |dtjfz}nfd} |t;j| dfSjs:||ddddfdddddtjffS||fS|S)reN euclideanrgrBg?rorr9g@r g@g@rr)axis)outwhere.g?cB|Sr1)rd)rbrrr3s rfzMatern.__call__..fs#7400771===r绽|=)rr&rrrrrrqrzmathrKinffinforepsfillr r r rircr#rFrr`rsum zeros_likedivide_approx_fprimerb) r3rrrrrjrtmpr3D denominator divide_resultr{s ``` rrzMatern.__call__s8 M!  *1d.?@@ 9!l*;???EE S !QRRR!l*A ,<[QQQE 7c>>vAA W^^ ! $AqBFA2JJ&AA W^^ ! $Aq1a4#:%3AA W  {S())AAA a3hKKK28E??. .KKK)AK((1,C FFA#-(E$'NN: ; ; ; dg A DGS!! !A 91 A  Q " " " ) /5 %Xqwqz171:q&ABB *}$ ;qqq"*aaa'(1RZAAA-=+>>1D VWXuax((AAArz)9:w#~~ gaeeemm44QQQ2:5EF " a 0 0  %%*  sBJ/-? CURVRWQr]-C-C,C%D%DS"*_%UU Cga!%%))m,,S"*_=&]cAg6E BF""3 ?!33 >>>>>>>.Q>>>># %*QQQT*..r22111aaa3CDDD*}$Hrc 8|jrQd|jjdt dj|j|jSd|jjtj |jd|jS)Nz#{0}(length_scale=[{1}], nu={2:.3g})rrz%{0}(length_scale={1:.3g}, nu={2:.3g})r) r`rr/r6rrrrqrrlrfs rrzMatern.__repr__s   8??' #i.0ABBCC  ;AA'$2C)D)DQ)G r)r9r:ror)r6r7r8r9rDrrr;r<s@rrnrn>srMM^eeeeN       rrnc\eZdZdZ d dZedZedZd d Zd Z dS) RationalQuadraticaRational 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...]]) r9r:c>||_||_||_||_dSr1)ralphar] alpha_bounds)r3rrr]rs rrDzRationalQuadratic.__init__Es)) #6 (rc.tdd|jSrbr r]rfs rrcz-RationalQuadratic.hyperparameter_length_scaleQsni9QRRRrc.tdd|jS)Nrr?)r rrfs rhyperparameter_alphaz&RationalQuadratic.hyperparameter_alphaUgy$2CDDDrNFcttj|jdkrt dtj|}|\t t|d}|d|jz|jdzzz }d|z}||j z}tj |dnG|rtdt||d}d|d|jz|jdzzz z|j z}|r|j j s-||z|jdz|zz }|ddddtjf}n-tj|jd|jddf}|jj sN||j tj|z|d|jdzz|zz zz} | ddddtjf} n-tj|jd|jddf} |tj| |ffS|S) aReturn 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_scaleNrfrgr rBr)rKr atleast_1drAttributeErrorr&r rrrirrrcr#rrFrrrtr) r3rrrrjrbaserlength_scale_gradientalpha_gradients rrzRationalQuadratic.__call__Ys16 r}T.// 0 01 4 4 >  M!   9uQ}===>>E1tz>D,=q,@@ACs7Dtzk!A  Q " " " " S !QRRR!Q}555EUa$*nt/@!/CCDD$*TA  39 N(- T5F5ID5P(Q%(=aaaBJ>N(O%%(*!'!*agaj!1L(M(M%,2 G!"ZK"&,,.q4#4a#77$>?@""0111bj0@!A!#171:qwqz1*E!F!Fbi1F GHHH HHrcXd|jj|j|jS)Nz({0}(alpha={1:.3g}, length_scale={2:.3g}))rr/r6rrrfs rrzRationalQuadratic.__repr__s+9@@ N #TZ1B   rr9r9r:r:r) r6r7r8r9rDrrcrrrr!rrrrs<<@' ) ) ) )SSXSEEXEAAAAF     rrc\eZdZdZ d dZedZedZd d Zd Z dS) ExpSineSquaredaExp-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...])) r9r:c>||_||_||_||_dSr1)r periodicityr]periodicity_bounds)r3rrr]rs rrDzExpSineSquared.__init__s*)&#6 "4rc.tdd|jS)zReturns the length scalerr?rrfs rrcz*ExpSineSquared.hyperparameter_length_scalesni9QRRRrc.tdd|jS)Nrr?)r rrfs rhyperparameter_periodicityz)ExpSineSquared.hyperparameter_periodicityrTrNFctj|}|ltt|d}tj|z|jz }tj|}tjd||jz dzz}nl|rtdt||d}tjdtjtj|jz |z|jz dzz}|rtj |}|j j s0d|jdzz |dzz|z} | ddddtjf} n-tj|jd|jd df} |jj s3d|z|jdzz |z|z|z} | ddddtjf} n-tj|jd|jd df} |tj| | ffS|S) reNrsrgr rBrr)rr&r rpirsinrzrrrcosrcr#rrFrrr) r3rrrrjrT sin_of_argr cos_of_argrperiodicity_gradients rrzExpSineSquared.__call__s8 M!   9uQ{;;;<>ARRWXXXA  J39 N()D,=q,@(@:q=(PST(T%(=aaaBJ>N(O%%(*!'!*agaj!1L(M(M%28 MGd/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...])) r9r:c"||_||_dSr1)sigma_0sigma_0_bounds)r3rrs rrDzDotProduct.__init__ls ,rc.tdd|jS)Nrr?)r rrfs rhyperparameter_sigma_0z!DotProduct.hyperparameter_sigma_0psiD4GHHHrNFctj|}|!tj|||jdzz}n1|rt dtj|||jdzz}|r||jjsAtj|jd|jddf}d|jdzz|d<||fS|tj|jd|jddffS|S)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), 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. Nr rBrr).r) rr&innerrrrr#rFrr2s rrzDotProduct.__call__ts8 M!   9Aq0AA S !QRRRAq0A  .4 @Xqwqz171:q&ABB %&q%8 6"*}$"(AGAJ A#>????HrcDtjd|||jdzzS)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 )reinsumrrs rrzDotProduct.diags#"yQ**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...]]) r9r:linearNc>||_||_||_||_dSr1)r gamma_boundsrhpairwise_kernels_kwargs)r3r rrhrs rrDzPairwiseKernel.__init__ s( ( '>$$$rc.tdd|jS)Nr r?)r rrfs rhyperparameter_gammaz#PairwiseKernel.hyperparameter_gamma rrFcHjjitjtfjjdd}|r[jjr/|tjj dj ddffSfd}|tj |dfS|S)rNTrhr filter_paramsrcVtfjtj|ddS)NTr)rrhrrz)r rrrr3s rr{z"PairwiseKernel.__call__..fA sD+ ${ fUmm&*  2 rr|) rrr&rrhr rr#rFrrrb)r3rrrrr{rs``` @rrzPairwiseKernel.__call__ s8#'">  ' /&( # M!     ;*   &     (. ?"(AGAJ A#>????.Q>>>>HrcRtj|d|S)rr)rapply_along_axisrlrs rrzPairwiseKernel.diagO s%$"4A..44666rc|jdvS)r)rbfrgrfs rrzPairwiseKernel.is_stationaryc s{g%%rcXd|jj|j|jS)Nz{0}(gamma={1}, metric={2}))rr/r6r rhrfs rrzPairwiseKernel.__repr__g s*+22 N #TZ   r)r9r:rNr) r6r7r8r9rDrrrrrrr!rrrrs66t  $ ? ? ? ?EEXE::::x777(&&&     rr)r!)/r9r}rabcrr collectionsrinspectrnumpyrscipy.spatial.distancerrr scipy.specialr r rr exceptionsrmetrics.pairwiserutils.validationrrr r>rrrrrrrrrrNr[rnrrrrrr!rrrsXX. ''''''''"""""";;;;;;;;;;########++++++//////++++++   b b b b b JQb b b Jtttttwttttn ########4        aHaHaHaHaHVaHaHaHHsNsNsNsNsNVsNsNsNl^4^4^4^4^4.^4^4^4Ba4a4a4a4a4na4a4a4H|1|1|1|1|1V|1|1|1~GAGAGAGAGA*,>GAGAGATx x x x x ');Vx x x vVVVVV !6VVVrEEEEESEEEPY Y Y Y Y -/DfY Y Y xN N N N N *,A6N N N bGTGTGTGTGTGTGTGTV    ` ` ` ` ` V` ` ` ` ` r