0Ph XdZddlZddlmZmZddlZddlmZ ddl m Z m Z ddl mZddlmZmZmZmZddlmZmZmZdd lmZdd lmZmZdd lmZdd lm Z m!Z!m"Z"Gd deeeZ#GddeeeZ$GddeeeZ%GddeeZ&GddeeeZ'dS)zOApproximate kernel feature maps based on Fourier transforms and count sketches.N)IntegralReal)fftifft)svd) BaseEstimatorClassNamePrefixFeaturesOutMixinTransformerMixin _fit_context) KERNEL_PARAMSPAIRWISE_KERNEL_FUNCTIONSpairwise_kernels)check_random_state)Interval StrOptions)safe_sparse_dot)_check_feature_names_incheck_is_fitted validate_datac eZdZUdZeedddgeedddgeedddgeedddgdgd Zee d <d d dd dd dZ e dddZ dZ fdZxZS)PolynomialCountSketcha Polynomial kernel approximation via Tensor Sketch. Implements Tensor Sketch, which approximates the feature map of the polynomial kernel:: K(X, Y) = (gamma * + coef0)^degree by efficiently computing a Count Sketch of the outer product of a vector with itself using Fast Fourier Transforms (FFT). Read more in the :ref:`User Guide `. .. versionadded:: 0.24 Parameters ---------- gamma : float, default=1.0 Parameter of the polynomial kernel whose feature map will be approximated. degree : int, default=2 Degree of the polynomial kernel whose feature map will be approximated. coef0 : int, default=0 Constant term of the polynomial kernel whose feature map will be approximated. n_components : int, default=100 Dimensionality of the output feature space. Usually, `n_components` should be greater than the number of features in input samples in order to achieve good performance. The optimal score / run time balance is typically achieved around `n_components` = 10 * `n_features`, but this depends on the specific dataset being used. random_state : int, RandomState instance, default=None Determines random number generation for indexHash and bitHash initialization. Pass an int for reproducible results across multiple function calls. See :term:`Glossary `. Attributes ---------- indexHash_ : ndarray of shape (degree, n_features), dtype=int64 Array of indexes in range [0, n_components) used to represent the 2-wise independent hash functions for Count Sketch computation. bitHash_ : ndarray of shape (degree, n_features), dtype=float32 Array with random entries in {+1, -1}, used to represent the 2-wise independent hash functions for Count Sketch computation. n_features_in_ : int Number of features seen during :term:`fit`. .. versionadded:: 0.24 feature_names_in_ : ndarray of shape (`n_features_in_`,) Names of features seen during :term:`fit`. Defined only when `X` has feature names that are all strings. .. versionadded:: 1.0 See Also -------- AdditiveChi2Sampler : Approximate feature map for additive chi2 kernel. Nystroem : Approximate a kernel map using a subset of the training data. RBFSampler : Approximate a RBF kernel feature map using random Fourier features. SkewedChi2Sampler : Approximate feature map for "skewed chi-squared" kernel. sklearn.metrics.pairwise.kernel_metrics : List of built-in kernels. Examples -------- >>> from sklearn.kernel_approximation import PolynomialCountSketch >>> from sklearn.linear_model import SGDClassifier >>> X = [[0, 0], [1, 1], [1, 0], [0, 1]] >>> y = [0, 0, 1, 1] >>> ps = PolynomialCountSketch(degree=3, random_state=1) >>> X_features = ps.fit_transform(X) >>> clf = SGDClassifier(max_iter=10, tol=1e-3) >>> clf.fit(X_features, y) SGDClassifier(max_iter=10) >>> clf.score(X_features, y) 1.0 For a more detailed example of usage, see :ref:`sphx_glr_auto_examples_kernel_approximation_plot_scalable_poly_kernels.py` rNleftclosedrneither random_stategammadegreecoef0 n_componentsr_parameter_constraints?dcL||_||_||_||_||_dSNr)selfrr r!r"rs \/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/sklearn/kernel_approximation.py__init__zPolynomialCountSketch.__init__s/   ((Tprefer_skip_nested_validationc@t||d}t|j}|jd}|jdkr|dz }|d|j|j|f|_| ddg|j|f|_ |j|_ |S)aFit the model with X. Initializes the internal variables. The method needs no information about the distribution of data, so we only care about n_features in X. Parameters ---------- X : {array-like, sparse matrix} of shape (n_samples, n_features) Training data, where `n_samples` is the number of samples and `n_features` is the number of features. y : array-like of shape (n_samples,) or (n_samples, n_outputs), default=None Target values (None for unsupervised transformations). Returns ------- self : object Returns the instance itself. csc accept_sparserr)highsize)ar4) rrrshaper!randintr"r indexHash_choicebitHash__n_features_out)r)Xyr n_featuress r*fitzPolynomialCountSketch.fits, $ 7 7 7)$*;<< WQZ :?? !OJ&.. D%T[*,E/  %++r1gT[*>DDFF4444 7=+,, Q Qt{++QQA!%A!6J#}QT2H"111a#34447111a4=8PP4444Q!aTJJJ"$'*<1"E"E"Egd#:MMMNN r,c`t}d|j_|S)NT)super__sklearn_tags__ input_tagssparser)tags __class__s r*r`z&PolynomialCountSketch.__sklearn_tags__s'ww''))!% r,r(__name__ __module__ __qualname____doc__rrrr#dict__annotations__r+r r@r]r` __classcell__res@r*rrs6UUp(4D88898Haf===>(4tI>>>?!(AtFCCCD'( $$D1ACd)))))\555"""65"H===~r,rceZdZUdZedheedddgeedddgdgd Ze e d <d d dd d Z e dddZ dZfdZxZS) RBFSamplera Approximate a RBF kernel feature map using random Fourier features. It implements a variant of Random Kitchen Sinks.[1] Read more in the :ref:`User Guide `. Parameters ---------- gamma : 'scale' or float, default=1.0 Parameter of RBF kernel: exp(-gamma * x^2). If ``gamma='scale'`` is passed then it uses 1 / (n_features * X.var()) as value of gamma. .. versionadded:: 1.2 The option `"scale"` was added in 1.2. n_components : int, default=100 Number of Monte Carlo samples per original feature. Equals the dimensionality of the computed feature space. random_state : int, RandomState instance or None, default=None Pseudo-random number generator to control the generation of the random weights and random offset when fitting the training data. Pass an int for reproducible output across multiple function calls. See :term:`Glossary `. Attributes ---------- random_offset_ : ndarray of shape (n_components,), dtype={np.float64, np.float32} Random offset used to compute the projection in the `n_components` dimensions of the feature space. random_weights_ : ndarray of shape (n_features, n_components), dtype={np.float64, np.float32} Random projection directions drawn from the Fourier transform of the RBF kernel. n_features_in_ : int Number of features seen during :term:`fit`. .. versionadded:: 0.24 feature_names_in_ : ndarray of shape (`n_features_in_`,) Names of features seen during :term:`fit`. Defined only when `X` has feature names that are all strings. .. versionadded:: 1.0 See Also -------- AdditiveChi2Sampler : Approximate feature map for additive chi2 kernel. Nystroem : Approximate a kernel map using a subset of the training data. PolynomialCountSketch : Polynomial kernel approximation via Tensor Sketch. SkewedChi2Sampler : Approximate feature map for "skewed chi-squared" kernel. sklearn.metrics.pairwise.kernel_metrics : List of built-in kernels. Notes ----- See "Random Features for Large-Scale Kernel Machines" by A. Rahimi and Benjamin Recht. [1] "Weighted Sums of Random Kitchen Sinks: Replacing minimization with randomization in learning" by A. Rahimi and Benjamin Recht. (https://people.eecs.berkeley.edu/~brecht/papers/08.rah.rec.nips.pdf) Examples -------- >>> from sklearn.kernel_approximation import RBFSampler >>> from sklearn.linear_model import SGDClassifier >>> X = [[0, 0], [1, 1], [1, 0], [0, 1]] >>> y = [0, 0, 1, 1] >>> rbf_feature = RBFSampler(gamma=1, random_state=1) >>> X_features = rbf_feature.fit_transform(X) >>> clf = SGDClassifier(max_iter=5, tol=1e-3) >>> clf.fit(X_features, y) SGDClassifier(max_iter=5) >>> clf.score(X_features, y) 1.0 scaleNrrrrrr"rr#r$r&c0||_||_||_dSr(rs)r)rr"rs r*r+zRBFSampler.__init__Ps ((r,Tr-c0t||d}t|j}|jd}t j|}|jdkrk|r?|||dzz n| }|dkrd||zz nd|_ n |j|_ d|j zd z| ||j f z|_ |ddtjz|j |_|jtjkrL|j |jd |_ |j|jd |_|j |_|S) aMFit the model with X. Samples random projection according to n_features. Parameters ---------- X : {array-like, sparse matrix}, shape (n_samples, n_features) Training data, where `n_samples` is the number of samples and `n_features` is the number of features. y : array-like, shape (n_samples,) or (n_samples, n_outputs), default=None Target values (None for unsupervised transformations). Returns ------- self : object Returns the instance itself. csrr1rrqr%rr$@?r4Fcopy)rrrr7rIrJrmultiplymeanvar_gammanormalr"random_weights_uniformrGpirandom_offset_dtypefloat32astyper<)r)r=r>rr?rbX_vars r*r@zRBFSampler.fitUsy* $ 7 7 7)$*;<< WQZ Q : @FSQZZ]]((**affhh1_<#>qwU#>#S#SD "&"5"<"`. Parameters ---------- skewedness : float, default=1.0 "skewedness" parameter of the kernel. Needs to be cross-validated. n_components : int, default=100 Number of Monte Carlo samples per original feature. Equals the dimensionality of the computed feature space. random_state : int, RandomState instance or None, default=None Pseudo-random number generator to control the generation of the random weights and random offset when fitting the training data. Pass an int for reproducible output across multiple function calls. See :term:`Glossary `. Attributes ---------- random_weights_ : ndarray of shape (n_features, n_components) Weight array, sampled from a secant hyperbolic distribution, which will be used to linearly transform the log of the data. random_offset_ : ndarray of shape (n_features, n_components) Bias term, which will be added to the data. It is uniformly distributed between 0 and 2*pi. n_features_in_ : int Number of features seen during :term:`fit`. .. versionadded:: 0.24 feature_names_in_ : ndarray of shape (`n_features_in_`,) Names of features seen during :term:`fit`. Defined only when `X` has feature names that are all strings. .. versionadded:: 1.0 See Also -------- AdditiveChi2Sampler : Approximate feature map for additive chi2 kernel. Nystroem : Approximate a kernel map using a subset of the training data. RBFSampler : Approximate a RBF kernel feature map using random Fourier features. SkewedChi2Sampler : Approximate feature map for "skewed chi-squared" kernel. sklearn.metrics.pairwise.chi2_kernel : The exact chi squared kernel. sklearn.metrics.pairwise.kernel_metrics : List of built-in kernels. References ---------- See "Random Fourier Approximations for Skewed Multiplicative Histogram Kernels" by Fuxin Li, Catalin Ionescu and Cristian Sminchisescu. Examples -------- >>> from sklearn.kernel_approximation import SkewedChi2Sampler >>> from sklearn.linear_model import SGDClassifier >>> X = [[0, 0], [1, 1], [1, 0], [0, 1]] >>> y = [0, 0, 1, 1] >>> chi2_feature = SkewedChi2Sampler(skewedness=.01, ... n_components=10, ... random_state=0) >>> X_features = chi2_feature.fit_transform(X, y) >>> clf = SGDClassifier(max_iter=10, tol=1e-3) >>> clf.fit(X_features, y) SGDClassifier(max_iter=10) >>> clf.score(X_features, y) 1.0 Nrrrrr skewednessr"rr#r$r&c0||_||_||_dSr(r)r)rr"rs r*r+zSkewedChi2Sampler.__init__s$((r,Tr-cpt||}t|j}|jd}|||jf}dt jz t jt j t jdz |zz|_ |ddt jz|j|_ |j t j krL|j |j d|_ |j |j d|_ |j|_|S) a<Fit the model with X. Samples random projection according to n_features. Parameters ---------- X : array-like, shape (n_samples, n_features) Training data, where `n_samples` is the number of samples and `n_features` is the number of features. y : array-like, shape (n_samples,) or (n_samples, n_outputs), default=None Target values (None for unsupervised transformations). Returns ------- self : object Returns the instance itself. rryr$rwrr%Frz)rrrr7rr"rGrlogtanrrrrrr<)r)r=r>rr?rs r*r@zSkewedChi2Sampler.fits* $ " ")$*;<< WQZ &&Z9J,K&LL"RU{RVBF253;;P4Q4Q-R-RR*221a"%idFW2XX 7bj $(#7#>#>qwU#>#S#SD "&"5"<"e    $/! ! & & ( ( TRSS S T_ q! $Q(<== d))  z:&&&bgcllRWT->%?%??? r,cdt}ddg|j_|S)Nrr)r_r`rrrcs r*r`z"SkewedChi2Sampler.__sklearn_tags__;s-ww''))1:I0F- r,r(rfrns@r*rrsFFR xdDCCCD!(AtFCCCD'($$D &)s))))) \555###65#J<r,rceZdZUdZeedddgeeddddgdZee d<d ddd Z e d dd Z dZ ddZedZedZfdZxZS)AdditiveChi2Samplera Approximate feature map for additive chi2 kernel. Uses sampling the fourier transform of the kernel characteristic at regular intervals. Since the kernel that is to be approximated is additive, the components of the input vectors can be treated separately. Each entry in the original space is transformed into 2*sample_steps-1 features, where sample_steps is a parameter of the method. Typical values of sample_steps include 1, 2 and 3. Optimal choices for the sampling interval for certain data ranges can be computed (see the reference). The default values should be reasonable. Read more in the :ref:`User Guide `. Parameters ---------- sample_steps : int, default=2 Gives the number of (complex) sampling points. sample_interval : float, default=None Sampling interval. Must be specified when sample_steps not in {1,2,3}. Attributes ---------- n_features_in_ : int Number of features seen during :term:`fit`. .. versionadded:: 0.24 feature_names_in_ : ndarray of shape (`n_features_in_`,) Names of features seen during :term:`fit`. Defined only when `X` has feature names that are all strings. .. versionadded:: 1.0 See Also -------- SkewedChi2Sampler : A Fourier-approximation to a non-additive variant of the chi squared kernel. sklearn.metrics.pairwise.chi2_kernel : The exact chi squared kernel. sklearn.metrics.pairwise.additive_chi2_kernel : The exact additive chi squared kernel. Notes ----- This estimator approximates a slightly different version of the additive chi squared kernel then ``metric.additive_chi2`` computes. This estimator is stateless and does not need to be fitted. However, we recommend to call :meth:`fit_transform` instead of :meth:`transform`, as parameter validation is only performed in :meth:`fit`. References ---------- See `"Efficient additive kernels via explicit feature maps" `_ A. Vedaldi and A. Zisserman, Pattern Analysis and Machine Intelligence, 2011 Examples -------- >>> from sklearn.datasets import load_digits >>> from sklearn.linear_model import SGDClassifier >>> from sklearn.kernel_approximation import AdditiveChi2Sampler >>> X, y = load_digits(return_X_y=True) >>> chi2sampler = AdditiveChi2Sampler(sample_steps=2) >>> X_transformed = chi2sampler.fit_transform(X, y) >>> clf = SGDClassifier(max_iter=5, random_state=0, tol=1e-3) >>> clf.fit(X_transformed, y) SGDClassifier(max_iter=5, random_state=0) >>> clf.score(X_transformed, y) 0.9499... rNrrr sample_stepssample_intervalr#r%c"||_||_dSr(r)r)rrs r*r+zAdditiveChi2Sampler.__init__s(.r,Tr-cjt||dd}|j|jdvrtd|S)aOnly validates estimator's parameters. This method allows to: (i) validate the estimator's parameters and (ii) be consistent with the scikit-learn transformer API. Parameters ---------- X : array-like, shape (n_samples, n_features) Training data, where `n_samples` is the number of samples and `n_features` is the number of features. y : array-like, shape (n_samples,) or (n_samples, n_outputs), default=None Target values (None for unsupervised transformations). Returns ------- self : object Returns the transformer. rvT)r2ensure_non_negativeN)rr%HIf sample_steps is not in [1, 2, 3], you need to provide sample_interval)rrrrM)r)r=r>s r*r@zAdditiveChi2Sampler.fitsN, $D Q Q Q   'D,=Y,N,N7   r,c$t||ddd}tj|}|j9|jdkrd}n2|jdkrd }n$|jd krd }nt d |j}|r|jn|j}|||j|S) aApply approximate feature map to X. Parameters ---------- X : {array-like, sparse matrix}, shape (n_samples, n_features) Training data, where `n_samples` is the number of samples and `n_features` is the number of features. Returns ------- X_new : {ndarray, sparse matrix}, shape = (n_samples, n_features * (2*sample_steps - 1)) Whether the return value is an array or sparse matrix depends on the type of the input X. rvFT)r2rCrNrg?r%rxrg?r)rrIrJrrrM_transform_sparse_transform_dense)r)r=rbrtransfs r*r]zAdditiveChi2Sampler.transforms  !54   Q   '  A%%"%"a''"%"a''"% ; #2O ,2L''t7Lva*O<<z=AdditiveChi2Sampler.get_feature_names_out..s*KKKD//D///KKKr,rc$g|] }d|d S)r_cosrrrrrVs r*rz=AdditiveChi2Sampler.get_feature_names_out../PPPH44t4444PPPr,c$g|] }d|d S)r_sinrrs r*rz=AdditiveChi2Sampler.get_feature_names_out..rr,)r) rrrerglowerrOrextendrGasarrayobject)r)input_features names_list cos_names sin_namesrrVs @@r*get_feature_names_outz)AdditiveChi2Sampler.get_feature_names_outs )9::::0 .   >*0022KKKKNKKK q$+,, 5 5APPPPPPPPIPPPPPPPPI   i)3 4 4 4 4z*F3333r,c|dk}||}tj|}tj||z||<|g}|tj|z}d|z|z}t d|D]} tj|tjtj| z|zz } tj|}| tj| |zz||<||tj|}| tj | |zz||<||tj |S)Nrrr%r) rG zeros_likerHrrOcoshrrappendsinrK) r=rrnon_zeroX_nzX_stepX_new log_step_nzstep_nzrV factor_nzs r*rz$AdditiveChi2Sampler._transform_denses48{q!!74/#9::x%t 4 d(_,q,'' ! !A"'"%!)o2M*N*N NOOI]1%%F(26!k/+B+BBF8  LL ]1%%F(26!k/+B+BBF8  LL yr,cP|j}|j}tj|j|z}t j|||f|j|j d}|g}|tj |jz}d|jz|z} td|D]} tj| tj tj | z|zz } | tj| |zz}t j|||f|j|j d}||| tj| |zz}t j|||f|j|j d}||t j|S)NF)r7rr{r%r)indicesr{indptrrGrHdatarI csr_matrixr7rrrOrrrrrrK) r=rrrr data_steprrrrrVrs r*rz%AdditiveChi2Sampler._transform_sparse s)..""GAF_455   (qwU   %qv6 af*.q,'' ! !A"'"%!)o2M*N*N NOOI!BF1{?$;$;;I]GV,AG17QVF LL !BF1{?$;$;;I]GV,AG17QVF LL yr,ct}d|_d|j_d|j_|S)NFT)r_r` requires_fitra positive_onlyrbrcs r*r`z$AdditiveChi2Sampler.__sklearn_tags__?s9ww''))!(,%!% r,r()rgrhrirjrrrr#rkrlr+r r@r]r staticmethodrrr`rmrns@r*rrAsCLL^"(AtFCCCD$HT1d6BBBDI$$D ()$/////\55565>,=,=,=\4444>  \ 2  \ <r,rc beZdZUdZeeejdhzege e ddddge e ddddge e ddddge dge e dddgd ge dgd Z e ed < dddddd ddddZedddZdZdZfdZxZS)NystroemaApproximate a kernel map using a subset of the training data. Constructs an approximate feature map for an arbitrary kernel using a subset of the data as basis. Read more in the :ref:`User Guide `. .. versionadded:: 0.13 Parameters ---------- kernel : str or callable, default='rbf' Kernel map to be approximated. A callable should accept two arguments and the keyword arguments passed to this object as `kernel_params`, and should return a floating point number. gamma : float, default=None Gamma parameter for the RBF, laplacian, polynomial, exponential chi2 and sigmoid kernels. Interpretation of the default value is left to the kernel; see the documentation for sklearn.metrics.pairwise. Ignored by other kernels. coef0 : float, default=None Zero coefficient for polynomial and sigmoid kernels. Ignored by other kernels. degree : float, default=None Degree of the polynomial kernel. Ignored by other kernels. kernel_params : dict, default=None Additional parameters (keyword arguments) for kernel function passed as callable object. n_components : int, default=100 Number of features to construct. How many data points will be used to construct the mapping. random_state : int, RandomState instance or None, default=None Pseudo-random number generator to control the uniform sampling without replacement of `n_components` of the training data to construct the basis kernel. Pass an int for reproducible output across multiple function calls. See :term:`Glossary `. n_jobs : int, default=None The number of jobs to use for the computation. This works by breaking down the kernel matrix into `n_jobs` even slices and computing them in parallel. ``None`` means 1 unless in a :obj:`joblib.parallel_backend` context. ``-1`` means using all processors. See :term:`Glossary ` for more details. .. versionadded:: 0.24 Attributes ---------- components_ : ndarray of shape (n_components, n_features) Subset of training points used to construct the feature map. component_indices_ : ndarray of shape (n_components) Indices of ``components_`` in the training set. normalization_ : ndarray of shape (n_components, n_components) Normalization matrix needed for embedding. Square root of the kernel matrix on ``components_``. n_features_in_ : int Number of features seen during :term:`fit`. .. versionadded:: 0.24 feature_names_in_ : ndarray of shape (`n_features_in_`,) Names of features seen during :term:`fit`. Defined only when `X` has feature names that are all strings. .. versionadded:: 1.0 See Also -------- AdditiveChi2Sampler : Approximate feature map for additive chi2 kernel. PolynomialCountSketch : Polynomial kernel approximation via Tensor Sketch. RBFSampler : Approximate a RBF kernel feature map using random Fourier features. SkewedChi2Sampler : Approximate feature map for "skewed chi-squared" kernel. sklearn.metrics.pairwise.kernel_metrics : List of built-in kernels. References ---------- * Williams, C.K.I. and Seeger, M. "Using the Nystroem method to speed up kernel machines", Advances in neural information processing systems 2001 * T. Yang, Y. Li, M. Mahdavi, R. Jin and Z. Zhou "Nystroem Method vs Random Fourier Features: A Theoretical and Empirical Comparison", Advances in Neural Information Processing Systems 2012 Examples -------- >>> from sklearn import datasets, svm >>> from sklearn.kernel_approximation import Nystroem >>> X, y = datasets.load_digits(n_class=9, return_X_y=True) >>> data = X / 16. >>> clf = svm.LinearSVC() >>> feature_map_nystroem = Nystroem(gamma=.2, ... random_state=1, ... n_components=300) >>> data_transformed = feature_map_nystroem.fit_transform(data) >>> clf.fit(data_transformed, y) LinearSVC() >>> clf.score(data_transformed, y) 0.9987... precomputedrNrrrrrkernelrr!r kernel_paramsr"rn_jobsr#rbfr&)rr!r rr"rrcv||_||_||_||_||_||_||_||_dSr(r) r)rrr!r rr"rrs r*r+zNystroem.__init__sC    *(( r,Tr-c^t||d}t|j}|jd}|j|kr|}t jdn|j}t||}||}|d|}||}t|f|j d|j d| } t| \} } } tj| d} tj| tj| z | |_||_||_||_|S) asFit estimator to data. Samples a subset of training points, computes kernel on these and computes normalization matrix. Parameters ---------- X : array-like, shape (n_samples, n_features) Training data, where `n_samples` is the number of samples and `n_features` is the number of features. y : array-like, shape (n_samples,) or (n_samples, n_outputs), default=None Target values (None for unsupervised transformations). Returns ------- self : object Returns the instance itself. rvr1rzn_components > n_samples. This is not possible. n_components was set to n_samples, which results in inefficient evaluation of the full kernel.NTmetric filter_paramsrg-q=)rrrr7r"warningswarnmin permutationrrr_get_kernel_paramsrrGmaximumdotrHnormalization_ components_component_indices_r<) r)r=r>rnd n_samplesr"inds basis_indsbasis basis_kernelUSVs r*r@z Nystroem.fitsJ, $ 7 7 7 !233GAJ   y ( ($L MA     ,L9l33 y))-<-( * '  ;;   %%''   l##1a Jq%  fQ^Q77 ",+ r,ct|t||dd}|}t||jf|jd|jd|}tj||j j S)aApply feature map to X. Computes an approximate feature map using the kernel between some training points and X. Parameters ---------- X : array-like of shape (n_samples, n_features) Data to transform. Returns ------- X_transformed : ndarray of shape (n_samples, n_components) Transformed data. rvFrBTr) rrrrrrrrGrrT)r)r=rembeddeds r*r]zNystroem.transforms  $e D D D//11 #   ;;      vh 3 5666r,c|j}|i}t|jsD|jdkr9t|jD]%}t ||t ||||<&n$|j|j|jtd|S)NrzWDon't pass gamma, coef0 or degree to Nystroem if using a callable or precomputed kernel) rcallablerr getattrrr!r rM)r)paramsparams r*rzNystroem._get_kernel_params8s# >F $$  )E)E&t{3 9 94''3$+D%$8$8F5M 9  &:);* ,  r,c|t}d|j_ddg|j_|Srrrcs r*r`zNystroem.__sklearn_tags__Nrr,)rr()rgrhrirjrsetrkeysrrrrkrr#rlr+r r@r]rr`rmrns@r*rrGsqqj Jss949;;<< N O O  (4D888$?(4tI>>>E8D!T&9994@!(AtFCCCD'(T" $ $D    *\555999659v777<,r,r)(rjrnumbersrrnumpyrG scipy.sparserbrI scipy.fftrr scipy.linalgrbaser r r r metrics.pairwiser rrutilsrutils._param_validationrr utils.extmathrutils.validationrrrrrprrrrr,r*rsfUU """""""" YXXXXXXXXX%%%%%%99999999******RRRRR#%5}RRRjjjjjj02BMjjjZ]]]]]#%5}]]]@CCCCC*MCCCLKKKKK.0@-KKKKKr,