\c@sodZddlmZmZddlmZddlZddlZddl m Z m Z ddl m Z mZmZddlmZdd lmZdd lmZdd lmZd Zd ed d5fdYZdejefdYZdefdYZdefdYZdefdYZdefdYZ de fdYZ!d e fd!YZ"d"efd#YZ#d$eefd%YZ$d&eefd'YZ%d(eeefd)YZ&d*e&fd+YZ'd,eeefd-YZ(d.eeefd/YZ)d0efd1YZ*d6d2Z+d3efd4YZ,dS(7sKernels for Gaussian process regression and classification. The kernels in this module allow kernel-engineering, i.e., they can be combined via the "+" and "*" operators or be exponentiated with a scalar via "**". These sum and product expressions can also contain scalar values, which are automatically converted to a constant kernel. All kernels allow (analytic) gradient-based hyperparameter optimization. The space of hyperparameters can be specified by giving lower und upper boundaries for the value of each hyperparameter (the search space is thus rectangular). Instead of specifying bounds, hyperparameters can also be declared to be "fixed", which causes these hyperparameters to be excluded from optimization. i(tABCMetatabstractmethod(t namedtupleN(tkvtgamma(tpdisttcdistt squareformi(tpairwise_kernels(tsix(tclone(t signaturecCstj|jt}tj|dkr<tdntj|dkr|jd|jdkrtd|jd|jdfn|S(Nis2length_scale cannot be of dimension greater than 1isKAnisotropic kernel must have the same number of dimensions as data (%d!=%d)(tnptsqueezetastypetfloattndimt ValueErrortshape(tXt length_scale((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyt_check_length_scale$s/!tHyperparametertnamet value_typetboundst n_elementstfixedcBs,eZdZdZdddZdZRS(sA kernel hyperparameter's specification in form of a namedtuple. .. versionadded:: 0.18 Attributes ---------- name : string 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 : string 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. icCst|tj s|dkrtj|}|dkr|jddkretj||d}q|jd|krtd|||jdfqqn|dkrt|tjo|dk}nt t |j ||||||S(NRiis@Bounds on %s should have either 1 or %d dimensions. Given are %d( t isinstanceR t string_typesR t atleast_2dRtrepeatRtNonetsuperRt__new__(tclsRRRRR((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyR"]s # !cCsa|j|jko`|j|jko`tj|j|jko`|j|jko`|j|jkS(N(RRR tallRRR(tselftother((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyt__eq__os (N(t__name__t __module__t__doc__t __slots__R R"R'(((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyR/s# tKernelcBseZdZedZdZdZedZedZ edZ e j dZ edZ d Z d Zd Zd Zd ZdZdZededZedZedZRS(s<Base class for all kernels. .. versionadded:: 0.18 c Cs t}|j}t|jd|j}t|}gg}}xp|jjD]_}|j|jkr|j dkr|j |j n|j|j krS|j |j qSqSWt |dkrt d|fnx$|D]} t|| d|| __`` so that it's possible to update each component of a nested object. Returns ------- self R:t__ismInvalid parameter %s for kernel %s. Check the list of available parameters with `kernel.get_params().keys()`.( RBtTrueR t iteritemstsplitR8Rt set_paramsR/R(tsetattr( R%R;t valid_paramstkeytvalueRFRtsub_namet sub_object((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRGs"     cCst|}||_|S(sReturns a clone of self with given hyperparameters theta. Parameters ---------- theta : array, shape (n_dims,) The hyperparameters (R ttheta(R%RNtcloned((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pytclone_with_thetas  cCs|jjdS(s>Returns the number of non-fixed hyperparameters of the kernel.i(RNR(R%((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pytn_dimsscCsIg}x<t|D].}|jdr|jt||qqW|S(s4Returns a list of all hyperparameter specifications.thyperparameter_(tdirt startswithR6R0(R%trtattr((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pythyperparameterss cCsg}|j}x1|jD]&}|js|j||jqqWt|dkrntjtj|Stj gSdS(sReturns 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 : array, shape (n_dims,) The non-fixed, log-transformed hyperparameters of the kernel iN( RBRWRR6RR8R tlogthstacktarray(R%RNR;thyperparameter((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRNs  cCs|j}d}x|jD]|}|jr1qn|jdkrttj||||j!||j<||j7}qtj||||j<|d7}qW|t|krtd|t|fn|j |dS(sSets the (flattened, log-transformed) non-fixed hyperparameters. Parameters ---------- theta : array, shape (n_dims,) The non-fixed, log-transformed hyperparameters of the kernel iisGtheta has not the correct number of entries. Should be %d; given are %dN( RBRWRRR texpRR8RRG(R%RNR;tiR[((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRNs  cCsog}x-|jD]"}|js|j|jqqWt|dkr^tjtj|StjgSdS(sReturns the log-transformed bounds on the theta. Returns ------- bounds : array, shape (n_dims, 2) The log-transformed bounds on the kernel's hyperparameters theta iN( RWRR6RR8R RXtvstackRZ(R%RR[((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRs  cCs/t|ts"t|t|St||S(N(RR,tSumtConstantKernel(R%tb((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyt__add__*scCs/t|ts"tt||St||S(N(RR,R_R`(R%Ra((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyt__radd__/scCs/t|ts"t|t|St||S(N(RR,tProductR`(R%Ra((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyt__mul__4scCs/t|ts"tt||St||S(N(RR,RdR`(R%Ra((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyt__rmul__9scCs t||S(N(tExponentiation(R%Ra((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyt__pow__>scCst|t|krtS|j}|j}xatt|jt|jD]7}tj|j|d|j|dkr]tSq]Wt S(N( ttypetFalseRBtsettlisttkeysR tanytgetR RD(R%Ratparams_atparams_bRJ((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyR'As  /-cCs.dj|jjdjtdj|jS(Ns{0}({1})s, s{0:.3g}(tformatR/R(tjointmapRN(R%((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyt__repr__KscCsdS(sEvaluate the kernel.N((R%RtYt eval_gradient((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyt__call__OscCsdS(sReturns 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, shape (n_samples_X, n_features) Left argument of the returned kernel k(X, Y) Returns ------- K_diag : array, shape (n_samples_X,) Diagonal of kernel k(X, X) N((R%R((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pytdiagSscCsdS(s*Returns whether the kernel is stationary. N((R%((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyt is_stationaryfsN(R(R)R*RDRBRGRPtpropertyRQRWRNtsetterRRbRcReRfRhR'RuRR RjRxRyRz(((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyR,ws( ' %        tNormalizedKernelMixincBseZdZdZRS(sSMixin for kernels which are normalized: k(X, X)=1. .. versionadded:: 0.18 cCstj|jdS(sReturns 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, shape (n_samples_X, n_features) Left argument of the returned kernel k(X, Y) Returns ------- K_diag : array, shape (n_samples_X,) Diagonal of kernel k(X, X) i(R tonesR(R%R((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRyqs(R(R)R*Ry(((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyR}kstStationaryKernelMixincBseZdZdZRS(sYMixin for kernels which are stationary: k(X, Y)= f(X-Y). .. versionadded:: 0.18 cCstS(s*Returns whether the kernel is stationary. (RD(R%((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRzs(R(R)R*Rz(((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRstCompoundKernelcBs}eZdZdZedZedZejdZedZ d e dZ dZ dZd ZRS( sKernel which is composed of a set of other kernels. .. versionadded:: 0.18 Parameters ---------- kernels : list of Kernel objects The other kernels cCs ||_dS(N(tkernels(R%R((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyR1scCstd|jS(skGet parameters of this kernel. Parameters ---------- deep : boolean, optional If True, will return the parameters for this estimator and contained subobjects that are estimators. Returns ------- params : mapping of string to any Parameter names mapped to their values. R(R.R(R%R:((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRBscCs&tjg|jD]}|j^qS(sReturns 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 : array, shape (n_dims,) The non-fixed, log-transformed hyperparameters of the kernel (R RYRRN(R%tkernel((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRNscCsL|jj}x9t|jD](\}}||||d|!|_qWdS(sSets the (flattened, log-transformed) non-fixed hyperparameters. Parameters ---------- theta : array, shape (n_dims,) The non-fixed, log-transformed hyperparameters of the kernel iN(tk1RQt enumerateRRN(R%RNtk_dimsR]R((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRNs cCs&tjg|jD]}|j^qS(sReturns the log-transformed bounds on the theta. Returns ------- bounds : array, shape (n_dims, 2) The log-transformed bounds on the kernel's hyperparameters theta (R R^RR(R%R((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRs c Cs|rg}g}xP|jD]E}||||\}}|j||j|dtjfqWtj|tj|dfStjg|jD]}||||^qSdS(s!Return 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, shape (n_samples_X, n_features) Left argument of the returned kernel k(X, Y) Y : array, shape (n_samples_Y, n_features), (optional, default=None) Right argument of the returned kernel k(X, Y). If None, k(X, X) if evaluated instead. eval_gradient : bool (optional, default=False) Determines whether the gradient with respect to the kernel hyperparameter is determined. Returns ------- K : array, shape (n_samples_X, n_samples_Y, n_kernels) Kernel k(X, Y) K_gradient : array, shape (n_samples_X, n_samples_X, n_dims, n_kernels) The gradient of the kernel k(X, X) with respect to the hyperparameter of the kernel. Only returned when eval_gradient is True. .iN(RR6R tnewaxistdstackt concatenate( R%RRvRwtKtK_gradRtK_singlet K_grad_single((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRxs  cCs}t|t|ks6t|jt|jkr:tStjgtt|jD] }|j||j|k^qVS(N(RiR8RRjR R$trange(R%RaR]((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyR's6 cCs)tjg|jD]}|j^qS(s*Returns whether the kernel is stationary. (R R$RRz(R%R((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRzscCs/tjg|jD]}|j|^qjS(sReturns 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, shape (n_samples_X, n_features) Left argument of the returned kernel k(X, Y) Returns ------- K_diag : array, shape (n_samples_X, n_kernels) Diagonal of kernel k(X, X) (R R^RRytT(R%RR((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRy sN(R(R)R*R1RDRBR{RNR|RR RjRxR'RzRy(((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRs     )  tKernelOperatorcBsteZdZdZedZedZedZej dZedZ dZ dZ RS( sEBase class for all kernel operators. .. versionadded:: 0.18 cCs||_||_dS(N(Rtk2(R%RR((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyR1#s cCstd|jd|j}|r||jjj}|jd|D|jjj}|jd|Dn|S(skGet parameters of this kernel. Parameters ---------- deep : boolean, optional If True, will return the parameters for this estimator and contained subobjects that are estimators. Returns ------- params : mapping of string to any Parameter names mapped to their values. RRcss%|]\}}d||fVqdS(tk1__N((t.0tktval((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pys 8scss%|]\}}d||fVqdS(tk2__N((RRR((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pys :s(R.RRRBtitemstupdate(R%R:R;t deep_items((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRB'scCsg}x@|jjD]2}|jtd|j|j|j|jqWx@|jjD]2}|jtd|j|j|j|jqVW|S(s%Returns a list of all hyperparameter.RR( RRWR6RRRRRR(R%RUR[((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRW>scCstj|jj|jjS(sReturns 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 : array, shape (n_dims,) The non-fixed, log-transformed hyperparameters of the kernel (R R6RRNR(R%((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRNNscCs0|jj}|| |j_|||j_dS(sSets the (flattened, log-transformed) non-fixed hyperparameters. Parameters ---------- theta : array, shape (n_dims,) The non-fixed, log-transformed hyperparameters of the kernel N(RRQRNR(R%RNtk1_dims((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRN^s cCs]|jjjdkr|jjS|jjjdkr>|jjStj|jj|jjfS(sReturns the log-transformed bounds on the theta. Returns ------- bounds : array, shape (n_dims, 2) The log-transformed bounds on the kernel's hyperparameters theta i(RRtsizeRR R^(R%((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRks   cCsbt|t|krtS|j|jkr@|j|jkpa|j|jkoa|j|jkS(N(RiRjRR(R%Ra((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyR'zs$cCs|jjo|jjS(s*Returns whether the kernel is stationary. (RRzR(R%((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRzs( R(R)R*R1RDRBR{RWRNR|RR'Rz(((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRs    R_cBs/eZdZdedZdZdZRS(sKSum-kernel k1 + k2 of two kernels k1 and k2. The resulting kernel is defined as k_sum(X, Y) = k1(X, Y) + k2(X, Y) .. versionadded:: 0.18 Parameters ---------- k1 : Kernel object The first base-kernel of the sum-kernel k2 : Kernel object The second base-kernel of the sum-kernel cCs|r_|j||dt\}}|j||dt\}}||tj||ffS|j|||j||SdS(sReturn the kernel k(X, Y) and optionally its gradient. Parameters ---------- X : array, shape (n_samples_X, n_features) Left argument of the returned kernel k(X, Y) Y : array, shape (n_samples_Y, n_features), (optional, default=None) Right argument of the returned kernel k(X, Y). If None, k(X, X) if evaluated instead. eval_gradient : bool (optional, default=False) Determines whether the gradient with respect to the kernel hyperparameter is determined. Returns ------- K : array, shape (n_samples_X, n_samples_Y) Kernel k(X, Y) K_gradient : array (opt.), shape (n_samples_X, n_samples_X, n_dims) The gradient of the kernel k(X, X) with respect to the hyperparameter of the kernel. Only returned when eval_gradient is True. RwN(RRDRR R(R%RRvRwtK1t K1_gradienttK2t K2_gradient((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRxs cCs |jj||jj|S(sReturns 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, shape (n_samples_X, n_features) Left argument of the returned kernel k(X, Y) Returns ------- K_diag : array, shape (n_samples_X,) Diagonal of kernel k(X, X) (RRyR(R%R((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRyscCsdj|j|jS(Ns {0} + {1}(RrRR(R%((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRusN(R(R)R*R RjRxRyRu(((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyR_s! RdcBs/eZdZdedZdZdZRS(sXProduct-kernel k1 * k2 of two kernels k1 and k2. The resulting kernel is defined as k_prod(X, Y) = k1(X, Y) * k2(X, Y) .. versionadded:: 0.18 Parameters ---------- k1 : Kernel object The first base-kernel of the product-kernel k2 : Kernel object The second base-kernel of the product-kernel cCs|r|j||dt\}}|j||dt\}}||tj||ddddtjf||ddddtjfffS|j|||j||SdS(sReturn the kernel k(X, Y) and optionally its gradient. Parameters ---------- X : array, shape (n_samples_X, n_features) Left argument of the returned kernel k(X, Y) Y : array, shape (n_samples_Y, n_features), (optional, default=None) Right argument of the returned kernel k(X, Y). If None, k(X, X) if evaluated instead. eval_gradient : bool (optional, default=False) Determines whether the gradient with respect to the kernel hyperparameter is determined. Returns ------- K : array, shape (n_samples_X, n_samples_Y) Kernel k(X, Y) K_gradient : array (opt.), shape (n_samples_X, n_samples_X, n_dims) The gradient of the kernel k(X, X) with respect to the hyperparameter of the kernel. Only returned when eval_gradient is True. RwN(RRDRR RR(R%RRvRwRRRR((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRxs 0-cCs |jj||jj|S(sReturns 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, shape (n_samples_X, n_features) Left argument of the returned kernel k(X, Y) Returns ------- K_diag : array, shape (n_samples_X,) Diagonal of kernel k(X, X) (RRyR(R%R((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRyscCsdj|j|jS(Ns {0} * {1}(RrRR(R%((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRusN(R(R)R*R RjRxRyRu(((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRds" RgcBseZdZdZedZedZedZej dZedZ dZ d e dZd Zd Zd ZRS( s'Exponentiate kernel by given exponent. The resulting kernel is defined as k_exp(X, Y) = k(X, Y) ** exponent .. versionadded:: 0.18 Parameters ---------- kernel : Kernel object The base kernel exponent : float The exponent for the base kernel cCs||_||_dS(N(Rtexponent(R%RR((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyR1+s cCsTtd|jd|j}|rP|jjj}|jd|Dn|S(skGet parameters of this kernel. Parameters ---------- deep : boolean, optional If True, will return the parameters for this estimator and contained subobjects that are estimators. Returns ------- params : mapping of string to any Parameter names mapped to their values. RRcss%|]\}}d||fVqdS(tkernel__N((RRR((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pys @s(R.RRRBRR(R%R:R;R((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRB/s cCsMg}x@|jjD]2}|jtd|j|j|j|jqW|S(s%Returns a list of all hyperparameter.R(RRWR6RRRRR(R%RUR[((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRWCscCs |jjS(sReturns 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 : array, shape (n_dims,) The non-fixed, log-transformed hyperparameters of the kernel (RRN(R%((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRNNscCs||j_dS(sSets the (flattened, log-transformed) non-fixed hyperparameters. Parameters ---------- theta : array, shape (n_dims,) The non-fixed, log-transformed hyperparameters of the kernel N(RRN(R%RN((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRN^s cCs |jjS(sReturns the log-transformed bounds on the theta. Returns ------- bounds : array, shape (n_dims, 2) The log-transformed bounds on the kernel's hyperparameters theta (RR(R%((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRis cCs>t|t|krtS|j|jko=|j|jkS(N(RiRjRR(R%Ra((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyR'tscCs|rm|j||dt\}}||j|ddddtjf|jd9}||j|fS|j||dt}||jSdS(sReturn the kernel k(X, Y) and optionally its gradient. Parameters ---------- X : array, shape (n_samples_X, n_features) Left argument of the returned kernel k(X, Y) Y : array, shape (n_samples_Y, n_features), (optional, default=None) Right argument of the returned kernel k(X, Y). If None, k(X, X) if evaluated instead. eval_gradient : bool (optional, default=False) Determines whether the gradient with respect to the kernel hyperparameter is determined. Returns ------- K : array, shape (n_samples_X, n_samples_Y) Kernel k(X, Y) K_gradient : array (opt.), shape (n_samples_X, n_samples_X, n_dims) The gradient of the kernel k(X, X) with respect to the hyperparameter of the kernel. Only returned when eval_gradient is True. RwNi(RRDRR RRj(R%RRvRwRt K_gradient((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRxys5cCs|jj||jS(sReturns 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, shape (n_samples_X, n_features) Left argument of the returned kernel k(X, Y) Returns ------- K_diag : array, shape (n_samples_X,) Diagonal of kernel k(X, X) (RRyR(R%R((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRyscCsdj|j|jS(Ns {0} ** {1}(RrRR(R%((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRuscCs |jjS(s*Returns whether the kernel is stationary. (RRz(R%((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRzsN(R(R)R*R1RDRBR{RWRNR|RR'R RjRxRyRuRz(((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRgs     #  R`cBsMeZdZdd dZedZd edZdZ dZ RS( sFConstant 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. k(x_1, x_2) = constant_value for all x_1, x_2 .. 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, default: (1e-5, 1e5) The lower and upper bound on constant_value g?gh㈵>gj@cCs||_||_dS(N(tconstant_valuetconstant_value_bounds(R%RR((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyR1s cCstdd|jS(NRtnumeric(RR(R%((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pythyperparameter_constant_valuescCstj|}|dkr$|}n|r9tdntj|jd|jdf|jdtj|jj}|r|j j s|tj|jd|jddf|jdtj|jjfS|tj |jd|jddffSn|SdS(sReturn the kernel k(X, Y) and optionally its gradient. Parameters ---------- X : array, shape (n_samples_X, n_features) Left argument of the returned kernel k(X, Y) Y : array, shape (n_samples_Y, n_features), (optional, default=None) Right argument of the returned kernel k(X, Y). If None, k(X, X) if evaluated instead. eval_gradient : bool (optional, default=False) Determines whether the gradient with respect to the kernel hyperparameter is determined. Only supported when Y is None. Returns ------- K : array, shape (n_samples_X, n_samples_Y) Kernel k(X, Y) K_gradient : array (opt.), shape (n_samples_X, n_samples_X, n_dims) The gradient of the kernel k(X, X) with respect to the hyperparameter of the kernel. Only returned when eval_gradient is True. s.Gradient can only be evaluated when Y is None.itdtypeiN( R RR RtfullRRRZRRRtempty(R%RRvRwR((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRxs  & # -cCs/tj|jd|jdtj|jjS(sReturns 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, shape (n_samples_X, n_features) Left argument of the returned kernel k(X, Y) Returns ------- K_diag : array, shape (n_samples_X,) Diagonal of kernel k(X, X) iR(R RRRRZR(R%R((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRyscCsdjtj|jS(Ns {0:.3g}**2(RrR tsqrtR(R%((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRus(gh㈵>gj@N( R(R)R*R1R{RR RjRxRyRu(((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyR`s , t WhiteKernelcBsMeZdZdd dZedZd edZdZ dZ RS( s White kernel. The main use-case of this kernel is as part of a sum-kernel where it explains the noise-component of the signal. Tuning its parameter corresponds to estimating the noise-level. k(x_1, x_2) = noise_level if x_1 == x_2 else 0 .. versionadded:: 0.18 Parameters ---------- noise_level : float, default: 1.0 Parameter controlling the noise level noise_level_bounds : pair of floats >= 0, default: (1e-5, 1e5) The lower and upper bound on noise_level g?gh㈵>gj@cCs||_||_dS(N(t noise_leveltnoise_level_bounds(R%RR((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyR1-s cCstdd|jS(NRR(RR(R%((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pythyperparameter_noise_level1scCstj|}|dk r0|r0tdn|dkr|jtj|jd}|r|jjs||jtj|jdddddtj ffS|tj |jd|jddffSq|Sn!tj |jd|jdfSdS(sReturn the kernel k(X, Y) and optionally its gradient. Parameters ---------- X : array, shape (n_samples_X, n_features) Left argument of the returned kernel k(X, Y) Y : array, shape (n_samples_Y, n_features), (optional, default=None) Right argument of the returned kernel k(X, Y). If None, k(X, X) if evaluated instead. eval_gradient : bool (optional, default=False) Determines whether the gradient with respect to the kernel hyperparameter is determined. Only supported when Y is None. Returns ------- K : array, shape (n_samples_X, n_samples_Y) Kernel k(X, Y) K_gradient : array (opt.), shape (n_samples_X, n_samples_X, n_dims) The gradient of the kernel k(X, X) with respect to the hyperparameter of the kernel. Only returned when eval_gradient is True. s.Gradient can only be evaluated when Y is None.iN( R RR RRteyeRRRRRtzeros(R%RRvRwR((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRx6s   4-cCs/tj|jd|jdtj|jjS(sReturns 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, shape (n_samples_X, n_features) Left argument of the returned kernel k(X, Y) Returns ------- K_diag : array, shape (n_samples_X,) Diagonal of kernel k(X, X) iR(R RRRRZR(R%R((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRyascCsdj|jj|jS(Ns{0}(noise_level={1:.3g})(RrR/R(R(R%((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRuus(gh㈵>gj@N( R(R)R*R1R{RR RjRxRyRu(((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRs + tRBFcBsSeZdZdd dZedZedZd edZ dZ RS( sRadial-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 length_scale>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: k(x_i, x_j) = exp(-1 / 2 d(x_i / length_scale, x_j / length_scale)^2) 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. .. versionadded:: 0.18 Parameters ----------- length_scale : float or array with 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, default: (1e-5, 1e5) The lower and upper bound on length_scale g?gh㈵>gj@cCs||_||_dS(N(Rtlength_scale_bounds(R%RR((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyR1s cCs%tj|jo$t|jdkS(Ni(R titerableRR8(R%((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyt anisotropicscCs;|jr(tdd|jt|jStdd|jS(NRR(RRRR8R(R%((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pythyperparameter_length_scales   cCstj|}t||j}|dkrut||dd}tjd|}t|}tj|dnE|rt dnt ||||dd}tjd|}|r|j j r|tj |jd|jddffS|j s|jddkrI|t|ddddtjf}||fS|jr|ddtjddf|tjddddfd|d}||d tjf9}||fSn|SdS( sReturn the kernel k(X, Y) and optionally its gradient. Parameters ---------- X : array, shape (n_samples_X, n_features) Left argument of the returned kernel k(X, Y) Y : array, shape (n_samples_Y, n_features), (optional, default=None) Right argument of the returned kernel k(X, Y). If None, k(X, X) if evaluated instead. eval_gradient : bool (optional, default=False) Determines whether the gradient with respect to the kernel hyperparameter is determined. Only supported when Y is None. Returns ------- K : array, shape (n_samples_X, n_samples_Y) Kernel k(X, Y) K_gradient : array (opt.), shape (n_samples_X, n_samples_X, n_dims) The gradient of the kernel k(X, X) with respect to the hyperparameter of the kernel. Only returned when eval_gradient is True. tmetrict sqeuclideangis.Gradient can only be evaluated when Y is None.iNi.(R RRRR RR\Rt fill_diagonalRRRRRRRR(R%RRvRwRtdistsRR((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRxs2     *,  C  cCsa|jr7dj|jjdjtdj|jSdj|jjtj|jdSdS(Ns{0}(length_scale=[{1}])s, s{0:.3g}s{0}(length_scale={1:.3g})i( RRrR/R(RsRtRR travel(R%((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRus  (gh㈵>gj@N( R(R)R*R1R{RRR RjRxRu(((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRzs  ;tMaterncBs8eZdZddddZd edZdZRS( s Matern kernel. The class of Matern kernels is a generalization of the RBF and the absolute exponential kernel parameterized by an additional parameter nu. 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). See Rasmussen and Williams 2006, pp84 for details regarding the different variants of the Matern kernel. .. versionadded:: 0.18 Parameters ----------- length_scale : float or array with 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, default: (1e-5, 1e5) The lower and upper bound on length_scale 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. g?gh㈵>gj@g?cCs&tt|j||||_dS(N(R!RR1tnu(R%RRR((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyR1sc sMtjtj}dkrFt|dd}n2|r[tdnt||dd}jdkrtj | }njdkr|t j d}d|tj | }njdkr |t j d }d||d d tj | }n|}||d kctj t j7)' E cCsm|jr=dj|jjdjtdj|j|jSdj|jjtj |jd|jSdS(Ns#{0}(length_scale=[{1}], nu={2:.3g})s, s{0:.3g}s%{0}(length_scale={1:.3g}, nu={2:.3g})i( RRrR/R(RsRtRRR R(R%((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRuvs   (gh㈵>gj@N(R(R)R*R1R RjRxRu(((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRs & ^tRationalQuadraticcBsYeZdZddd d dZedZedZd edZ dZ RS( sRational 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 length_scale>0 and a scale mixture parameter alpha>0. Only the isotropic variant where length_scale is a scalar is supported at the moment. The kernel given by: k(x_i, x_j) = (1 + d(x_i, x_j)^2 / (2*alpha * length_scale^2))^-alpha .. 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, default: (1e-5, 1e5) The lower and upper bound on length_scale alpha_bounds : pair of floats >= 0, default: (1e-5, 1e5) The lower and upper bound on alpha g?gh㈵>gj@cCs(||_||_||_||_dS(N(RtalphaRt alpha_bounds(R%RRRR((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyR1s   cCstdd|jS(NRR(RR(R%((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRscCstdd|jS(NRR(RR(R%((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pythyperparameter_alphasc Cstj|}|dkrztt|dd}|d|j|jd}d|}||j }tj|dnR|rtdnt ||dd}d|d|j|jd|j }|r|j j s|||jd|}|ddddtj f}n&tj |jd|jddf}|jj s||j tj||d|jd|} | ddddtj f} n&tj |jd|jddf} |tj| |ffS|SdS(sReturn the kernel k(X, Y) and optionally its gradient. Parameters ---------- X : array, shape (n_samples_X, n_features) Left argument of the returned kernel k(X, Y) Y : array, shape (n_samples_Y, n_features), (optional, default=None) Right argument of the returned kernel k(X, Y). If None, k(X, X) if evaluated instead. eval_gradient : bool (optional, default=False) Determines whether the gradient with respect to the kernel hyperparameter is determined. Only supported when Y is None. Returns ------- K : array, shape (n_samples_X, n_samples_Y) Kernel k(X, Y) K_gradient : array (opt.), shape (n_samples_X, n_samples_X, n_dims) The gradient of the kernel k(X, X) with respect to the hyperparameter of the kernel. Only returned when eval_gradient is True. RRiis.Gradient can only be evaluated when Y is None.Ni(R RR RRRRRRRRRRRRRRXR( R%RRvRwRRtbaseRtlength_scale_gradienttalpha_gradient((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRxs2     %& %&cCsdj|jj|j|jS(Ns({0}(alpha={1:.3g}, length_scale={2:.3g})(RrR/R(RR(R%((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRus(gh㈵>gj@(gh㈵>gj@N( R(R)R*R1R{RRR RjRxRu(((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRs?tExpSineSquaredcBsYeZdZddd d dZedZedZd edZ dZ RS( s\Exp-Sine-Squared kernel. The ExpSineSquared kernel allows modeling periodic functions. It is parameterized by a length-scale parameter length_scale>0 and a periodicity parameter periodicity>0. Only the isotropic variant where l is a scalar is supported at the moment. The kernel given by: k(x_i, x_j) = exp(-2 (sin(\pi / periodicity * d(x_i, x_j)) / length_scale) ^ 2) .. 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, default: (1e-5, 1e5) The lower and upper bound on length_scale periodicity_bounds : pair of floats >= 0, default: (1e-5, 1e5) The lower and upper bound on periodicity g?gh㈵>gj@cCs(||_||_||_||_dS(N(Rt periodicityRtperiodicity_bounds(R%RRRR((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyR1s   cCstdd|jS(NRR(RR(R%((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRscCstdd|jS(NRR(RR(R%((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pythyperparameter_periodicitysc Cstj|}|dkrwtt|dd}tj||j}tj|}tjd||j d}n_|rt dnt ||dd}tjdtjtj|j||j d}|rtj |}|j js9d|j d|d|} | ddddtjf} n&tj|jd|jd df} |jjsd||j d|||} | ddddtjf} n&tj|jd|jd df} |tj| | ffS|SdS( sReturn the kernel k(X, Y) and optionally its gradient. Parameters ---------- X : array, shape (n_samples_X, n_features) Left argument of the returned kernel k(X, Y) Y : array, shape (n_samples_Y, n_features), (optional, default=None) Right argument of the returned kernel k(X, Y). If None, k(X, X) if evaluated instead. eval_gradient : bool (optional, default=False) Determines whether the gradient with respect to the kernel hyperparameter is determined. Only supported when Y is None. Returns ------- K : array, shape (n_samples_X, n_samples_Y) Kernel k(X, Y) K_gradient : array (opt.), shape (n_samples_X, n_samples_X, n_dims) The gradient of the kernel k(X, X) with respect to the hyperparameter of the kernel. Only returned when eval_gradient is True. RRiis.Gradient can only be evaluated when Y is None.iNii(R RR RRtpiRtsinR\RRRtcosRRRRRRR( R%RRvRwRRAt sin_of_argRt cos_of_argRtperiodicity_gradient((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRx s0 ! # %& !%&cCsdj|jj|j|jS(Ns.{0}(length_scale={1:.3g}, periodicity={2:.3g})(RrR/R(RR(R%((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRu^s(gh㈵>gj@(gh㈵>gj@N( R(R)R*R1R{RRR RjRxRu(((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRs >t DotProductcBsVeZdZdd dZedZd edZdZ dZ d Z RS( sDot-Product kernel. The DotProduct kernel is non-stationary and can be obtained from linear regression by putting N(0, 1) priors on the coefficients of x_d (d = 1, . . . , D) and a prior of N(0, \sigma_0^2) on the bias. The DotProduct kernel is invariant to a rotation of the coordinates about the origin, but not translations. It is parameterized by a parameter sigma_0^2. For sigma_0^2 =0, the kernel is called the homogeneous linear kernel, otherwise it is inhomogeneous. The kernel is given by k(x_i, x_j) = sigma_0 ^ 2 + x_i \cdot x_j The DotProduct kernel is commonly combined with exponentiation. .. 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 homogenous. sigma_0_bounds : pair of floats >= 0, default: (1e-5, 1e5) The lower and upper bound on l g?gh㈵>gj@cCs||_||_dS(N(tsigma_0tsigma_0_bounds(R%RR((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyR1s cCstdd|jS(NRR(RR(R%((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pythyperparameter_sigma_0scCstj|}|dkr;tj|||jd}n2|rPtdntj|||jd}|r|jjstj|j d|j ddf}d|jd|d<||fS|tj|j d|j ddffSn|SdS(sReturn the kernel k(X, Y) and optionally its gradient. Parameters ---------- X : array, shape (n_samples_X, n_features) Left argument of the returned kernel k(X, Y) Y : array, shape (n_samples_Y, n_features), (optional, default=None) Right argument of the returned kernel k(X, Y). If None, k(X, X) if evaluated instead. eval_gradient : bool (optional, default=False) Determines whether the gradient with respect to the kernel hyperparameter is determined. Only supported when Y is None. Returns ------- K : array, shape (n_samples_X, n_samples_Y) Kernel k(X, Y) K_gradient : array (opt.), shape (n_samples_X, n_samples_X, n_dims) The gradient of the kernel k(X, X) with respect to the hyperparameter of the kernel. Only returned when eval_gradient is True. is.Gradient can only be evaluated when Y is None.ii.N(.i( R RR tinnerRRRRRR(R%RRvRwRR((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRxs    & -cCstjd|||jdS(sReturns 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, shape (n_samples_X, n_features) Left argument of the returned kernel k(X, Y) Returns ------- K_diag : array, shape (n_samples_X,) Diagonal of kernel k(X, X) sij,ij->ii(R teinsumR(R%R((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRyscCstS(s*Returns whether the kernel is stationary. (Rj(R%((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRzscCsdj|jj|jS(Ns{0}(sigma_0={1:.3g})(RrR/R(R(R%((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRus(gh㈵>gj@N( R(R)R*R1R{RR RjRxRyRzRu(((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRcs-  c Cs||f|}tj|jd|jdt|ft}tjt|ft}xttt|D]`}d||<||}|||f|||||dddd|ftf0tgradteiRtd((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRs/  <tPairwiseKernelcBs\eZdZdd dd dZedZd edZdZ d Z d Z RS( sWrapper for kernels in sklearn.metrics.pairwise. A thin wrapper around the functionality of the kernels in sklearn.metrics.pairwise. Note: Evaluation of eval_gradient is not analytic but numeric and all kernels support only isotropic distances. The parameter gamma is considered to be a hyperparameter and may be optimized. The other kernel parameters are set directly at initialization and are kept fixed. .. versionadded:: 0.18 Parameters ---------- gamma : float >= 0, default: 1.0 Parameter gamma of the pairwise kernel specified by metric gamma_bounds : pair of floats >= 0, default: (1e-5, 1e5) The lower and upper bound on gamma metric : string, 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. g?gh㈵>gj@tlinearcCs(||_||_||_||_dS(N(Rt gamma_boundsRtpairwise_kernels_kwargs(R%RRRR((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyR1s   cCstdd|jS(NRR(RR(R%((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pythyperparameter_gamma sc sjjdkr!intjtdjdjdt}|rjj r|tj j dj ddffSfd}|t j |dfSn|SdS(sReturn the kernel k(X, Y) and optionally its gradient. Parameters ---------- X : array, shape (n_samples_X, n_features) Left argument of the returned kernel k(X, Y) Y : array, shape (n_samples_Y, n_features), (optional, default=None) Right argument of the returned kernel k(X, Y). If None, k(X, X) if evaluated instead. eval_gradient : bool (optional, default=False) Determines whether the gradient with respect to the kernel hyperparameter is determined. Only supported when Y is None. Returns ------- K : array, shape (n_samples_X, n_samples_Y) Kernel k(X, Y) K_gradient : array (opt.), shape (n_samples_X, n_samples_X, n_dims) The gradient of the kernel k(X, X) with respect to the hyperparameter of the kernel. Only returned when eval_gradient is True. RRt filter_paramsic s.tdjdtj|dtS(NRRR(RRR R\RD(R(RRvRR%(s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyR5s!g|=N(RR R RRRRRDRRRRRRN(R%RRvRwRR((RRvRR%s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRxs    *cCstj|d|jS(sReturns 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, shape (n_samples_X, n_features) Left argument of the returned kernel k(X, Y) Returns ------- K_diag : array, shape (n_samples_X,) Diagonal of kernel k(X, X) i(R tapply_along_axisR(R%R((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRy=scCs |jdkS(s*Returns whether the kernel is stationary. trbf(R(R(R%((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRzQscCsdj|jj|j|jS(Ns{0}(gamma={1}, metric={2})(RrR/R(RR(R%((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRuUs(gh㈵>gj@N( R(R)R*R R1R{RRjRxRyRzRu(((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyRs$  /  (RRRRR((-R*tabcRRt collectionsRRtnumpyR t scipy.specialRRtscipy.spatial.distanceRRRtmetrics.pairwiseRt externalsR RR t utils.fixesR RRtwith_metaclassR,tobjectR}RRRR_RdRgR`RRRRRRRR(((s?lib/python2.7/site-packages/sklearn/gaussian_process/kernels.pyts>   F hJKbarpqn