B vd2@sddlZddlmZddlZddlZddlmZddlm Z ddlm Z ddl m Z m Z ddlmZdd lmZdd lmZdd lmZdd lmZmZdd lmZddlmZmZddlmZddlmZddlmZddlm Z m!Z!ddl"m#Z#m$Z$ddl%m&Z&ddZ'ddddddddZ(ddZ)ddddd d!d"Z*dd#d$Z+ddej,dd%d&d'Z-dd(d)Z.d*d+Z/dd,dd-d.d/Z0dd,dd-d0d1Z1dd2d3Z2ddd4d5d6Z3dd7d8Z4d9d:Z5d;d<Z6d=d>Z7e7e5e5e6e6e6d?Z8d,d@dAdBZ9ddCdDZ:ddFdGZ;ddHdIZddNdOZ?ddPdQZ@ddSdTZAe3e4e*e2e*e3e3de-dU ZBdVdWZCdXdYZDdZd[ZEdd\d]ZFd,d^d_d`dadbdcdddedfdgdhdidjdkdldmdndodpdqdrdsdtdudvdwgZGdvgZHdxdyZIddzd{ZJddd,ddd|d}d~ZKddddddZLdgdidjdldndodqdrdtg ZMe@eAe:e;e;e=e>e`. Parameters ---------- X : {array-like, sparse matrix} of shape (n_samples_X, n_features) An array where each row is a sample and each column is a feature. Y : {array-like, sparse matrix} of shape (n_samples_Y, n_features), default=None An array where each row is a sample and each column is a feature. If `None`, method uses `Y=X`. Y_norm_squared : array-like of shape (n_samples_Y,) or (n_samples_Y, 1) or (1, n_samples_Y), default=None Pre-computed dot-products of vectors in Y (e.g., ``(Y**2).sum(axis=1)``) May be ignored in some cases, see the note below. squared : bool, default=False Return squared Euclidean distances. X_norm_squared : array-like of shape (n_samples_X,) or (n_samples_X, 1) or (1, n_samples_X), default=None Pre-computed dot-products of vectors in X (e.g., ``(X**2).sum(axis=1)``) May be ignored in some cases, see the note below. Returns ------- distances : ndarray of shape (n_samples_X, n_samples_Y) Returns the distances between the row vectors of `X` and the row vectors of `Y`. See Also -------- paired_distances : Distances betweens pairs of elements of X and Y. Notes ----- To achieve a better accuracy, `X_norm_squared` and `Y_norm_squared` may be unused if they are passed as `np.float32`. Examples -------- >>> from sklearn.metrics.pairwise import euclidean_distances >>> X = [[0, 1], [1, 1]] >>> # distance between rows of X >>> euclidean_distances(X, X) array([[0., 1.], [1., 0.]]) >>> # get distance to origin >>> euclidean_distances(X, [[0, 0]]) array([[1. ], [1.41421356]]) NF)Z ensure_2drrz'Incompatible dimensions for X of shape z and X_norm_squared of shape .z'Incompatible dimensions for Y of shape z and Y_norm_squared of shape )r)r r+reshapeTr,_euclidean_distances)r r!r.r/r0Zoriginal_shaper"r"r#euclidean_distancess,L     r6cCsB|dk r(|jtjkrd}qT|dd}n,|jtjkr:d}nt|ddddtjf}||krp|dkrhdn|j}nT|dk r|jtjkrd}q|dd}n,|jtjkrd}nt|ddtjddf}|jtjkrt||||}n$dt||jdd}||7}||7}tj |d|d ||kr*t |d|r4|Stj ||d S) a'Computational part of euclidean_distances Assumes inputs are already checked. If norms are passed as float32, they are unused. If arrays are passed as float32, norms needs to be recomputed on upcast chunks. TODO: use a float64 accumulator in row_norms to avoid the latter. Nr1rT)r/) dense_outputr)out) rrrr3rnewaxisr4_euclidean_distances_upcastrmaximum fill_diagonalsqrt)r r!r0r.r/XXYY distancesr"r"r#r5Ms2        r5)r/missing_valuesr(cCs2t|r dnd}t||d||d\}}t||}||kr<|nt||}d||<d||<t||dd}||} ||} |t| |j8}|t|| j8}tj|dd|d||krt|d d |} ||kr| n|} t| | j} tj || dk<tj d | | d|| }||j d 9}|s.tj ||d|S) aCalculate the euclidean distances in the presence of missing values. Compute the euclidean distance between each pair of samples in X and Y, where Y=X is assumed if Y=None. When calculating the distance between a pair of samples, this formulation ignores feature coordinates with a missing value in either sample and scales up the weight of the remaining coordinates: dist(x,y) = sqrt(weight * sq. distance from present coordinates) where, weight = Total # of coordinates / # of present coordinates For example, the distance between ``[3, na, na, 6]`` and ``[1, na, 4, 5]`` is: .. math:: \sqrt{\frac{4}{2}((3-1)^2 + (6-5)^2)} If all the coordinates are missing or if there are no common present coordinates then NaN is returned for that pair. Read more in the :ref:`User Guide `. .. versionadded:: 0.22 Parameters ---------- X : array-like of shape=(n_samples_X, n_features) Y : array-like of shape=(n_samples_Y, n_features), default=None squared : bool, default=False Return squared Euclidean distances. missing_values : np.nan or int, default=np.nan Representation of missing value. copy : bool, default=True Make and use a deep copy of X and Y (if Y exists). Returns ------- distances : ndarray of shape (n_samples_X, n_samples_Y) See Also -------- paired_distances : Distances between pairs of elements of X and Y. Examples -------- >>> from sklearn.metrics.pairwise import nan_euclidean_distances >>> nan = float("NaN") >>> X = [[0, 1], [1, nan]] >>> nan_euclidean_distances(X, X) # distance between rows of X array([[0. , 1.41421356], [1.41421356, 0. ]]) >>> # get distance to origin >>> nan_euclidean_distances(X, [[0, 0]]) array([[1. ], [1.41421356]]) References ---------- * John K. Dixon, "Pattern Recognition with Partly Missing Data", IEEE Transactions on Systems, Man, and Cybernetics, Volume: 9, Issue: 10, pp. 617 - 621, Oct. 1979. http://ieeexplore.ieee.org/abstract/document/4310090/ z allow-nanTF)r&r'r(r)r/N)r9gr) rr)rr6rdotr4clipr=nanr<r+r>)r r!r/rBr(r'Z missing_XZ missing_YrAr?r@Z present_XZ present_YZ present_countr"r"r#nan_euclidean_distancess2I  rFcCs |jd}|jd}|jd}tj||ftjd}|dkrt|rT|jt|jnd} t|rr|jt|jnd} t| || ||| || |dd} | | |} | t| dd| d}tt |d}t ||} xt | D]\}}|| tj }|dkr4t|d d ddtjf}n||}t ||}xt |D]\}}||kr|||kr||||fj}nj|| tj }|dkrt|d d tjddf}n|dd|f}d t||jd d }||7}||7}|j tjd d|||f<qPWqW|S)aEuclidean distances between X and Y. Assumes X and Y have float32 dtype. Assumes XX and YY have float64 dtype or are None. X and Y are upcast to float64 by chunks, which size is chosen to limit memory increase by approximately 10% (at least 10MiB). rr)rN irT)r/r7)r8F)r()r+remptyrrZnnzprodmaxr>intr enumerateZastypefloat64rr:r4r)r r?r!r@Z batch_size n_samples_XZ n_samples_YZ n_featuresrAZ x_densityZ y_densityZmaxmemtmpZ x_batchesiZx_sliceX_chunkZXX_chunkZ y_batchesjZy_slicedZY_chunkZYY_chunkr"r"r#r;sD         "r;cCs,|jdd}|t|jd|f}||fS)Nr)axisr)ZargminrZaranger+)diststartindicesvaluesr"r"r#_argmin_min_reduce>s rZ euclidean)rUmetric metric_kwargscCsht||\}}|dkri}|dkr,||}}tt||ft|d|\}}t|}t|}||fS)ae Compute minimum distances between one point and a set of points. This function computes for each row in X, the index of the row of Y which is closest (according to the specified distance). The minimal distances are also returned. This is mostly equivalent to calling: (pairwise_distances(X, Y=Y, metric=metric).argmin(axis=axis), pairwise_distances(X, Y=Y, metric=metric).min(axis=axis)) but uses much less memory, and is faster for large arrays. Parameters ---------- X : {array-like, sparse matrix} of shape (n_samples_X, n_features) Array containing points. Y : {array-like, sparse matrix} of shape (n_samples_Y, n_features) Array containing points. axis : int, default=1 Axis along which the argmin and distances are to be computed. metric : str or callable, default='euclidean' Metric to use for distance computation. Any metric from scikit-learn or scipy.spatial.distance can be used. 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 as input and return one value indicating the distance between them. This works for Scipy's metrics, but is less efficient than passing the metric name as a string. Distance matrices are not supported. Valid values for metric are: - from scikit-learn: ['cityblock', 'cosine', 'euclidean', 'l1', 'l2', 'manhattan'] - from scipy.spatial.distance: ['braycurtis', 'canberra', 'chebyshev', 'correlation', 'dice', 'hamming', 'jaccard', 'kulsinski', 'mahalanobis', 'minkowski', 'rogerstanimoto', 'russellrao', 'seuclidean', 'sokalmichener', 'sokalsneath', 'sqeuclidean', 'yule'] See the documentation for scipy.spatial.distance for details on these metrics. metric_kwargs : dict, default=None Keyword arguments to pass to specified metric function. Returns ------- argmin : ndarray Y[argmin[i], :] is the row in Y that is closest to X[i, :]. distances : ndarray distances[i] is the distance between the i-th row in X and the argmin[i]-th row in Y. See Also -------- sklearn.metrics.pairwise_distances sklearn.metrics.pairwise_distances_argmin Nr) reduce_funcr\)r)zippairwise_distances_chunkedrZrZ concatenate)r r!rUr\r]rXrYr"r"r#pairwise_distances_argmin_minDsF   racCs"|dkr i}t|||||ddS)aCompute minimum distances between one point and a set of points. This function computes for each row in X, the index of the row of Y which is closest (according to the specified distance). This is mostly equivalent to calling: pairwise_distances(X, Y=Y, metric=metric).argmin(axis=axis) but uses much less memory, and is faster for large arrays. This function works with dense 2D arrays only. Parameters ---------- X : array-like of shape (n_samples_X, n_features) Array containing points. Y : array-like of shape (n_samples_Y, n_features) Arrays containing points. axis : int, default=1 Axis along which the argmin and distances are to be computed. metric : str or callable, default="euclidean" Metric to use for distance computation. Any metric from scikit-learn or scipy.spatial.distance can be used. 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 as input and return one value indicating the distance between them. This works for Scipy's metrics, but is less efficient than passing the metric name as a string. Distance matrices are not supported. Valid values for metric are: - from scikit-learn: ['cityblock', 'cosine', 'euclidean', 'l1', 'l2', 'manhattan'] - from scipy.spatial.distance: ['braycurtis', 'canberra', 'chebyshev', 'correlation', 'dice', 'hamming', 'jaccard', 'kulsinski', 'mahalanobis', 'minkowski', 'rogerstanimoto', 'russellrao', 'seuclidean', 'sokalmichener', 'sokalsneath', 'sqeuclidean', 'yule'] See the documentation for scipy.spatial.distance for details on these metrics. metric_kwargs : dict, default=None Keyword arguments to pass to specified metric function. Returns ------- argmin : numpy.ndarray Y[argmin[i], :] is the row in Y that is closest to X[i, :]. See Also -------- sklearn.metrics.pairwise_distances sklearn.metrics.pairwise_distances_argmin_min N)rUr\r]r)ra)r r!rUr\r]r"r"r#pairwise_distances_argmins @rbcCsddlm}|d||S)a_Compute the Haversine distance between samples in X and Y. The Haversine (or great circle) distance is the angular distance between two points on the surface of a sphere. The first coordinate of each point is assumed to be the latitude, the second is the longitude, given in radians. The dimension of the data must be 2. .. math:: D(x, y) = 2\arcsin[\sqrt{\sin^2((x1 - y1) / 2) + \cos(x1)\cos(y1)\sin^2((x2 - y2) / 2)}] Parameters ---------- X : array-like of shape (n_samples_X, 2) Y : array-like of shape (n_samples_Y, 2), default=None Returns ------- distance : ndarray of shape (n_samples_X, n_samples_Y) Notes ----- As the Earth is nearly spherical, the haversine formula provides a good approximation of the distance between two points of the Earth surface, with a less than 1% error on average. Examples -------- We want to calculate the distance between the Ezeiza Airport (Buenos Aires, Argentina) and the Charles de Gaulle Airport (Paris, France). >>> from sklearn.metrics.pairwise import haversine_distances >>> from math import radians >>> bsas = [-34.83333, -58.5166646] >>> paris = [49.0083899664, 2.53844117956] >>> bsas_in_radians = [radians(_) for _ in bsas] >>> paris_in_radians = [radians(_) for _ in paris] >>> result = haversine_distances([bsas_in_radians, paris_in_radians]) >>> result * 6371000/1000 # multiply by Earth radius to get kilometers array([[ 0. , 11099.54035582], [11099.54035582, 0. ]]) r)DistanceMetric haversine)ZmetricsrcZ get_metricpairwise)r r!rcr"r"r#haversine_distancess- rf)sum_over_featurescCst||\}}t|st|r|s.td|t|dd}t|dd}||t|jd|jdf}t|j |j |j |j |j |j ||S|rt ||dS|ddtjddf|tjddddf}t||}|d|jdfS) aCompute the L1 distances between the vectors in X and Y. With sum_over_features equal to False it returns the componentwise distances. Read more in the :ref:`User Guide `. Parameters ---------- X : array-like of shape (n_samples_X, n_features) Y : array-like of shape (n_samples_Y, n_features), default=None If `None`, uses `Y=X`. sum_over_features : bool, default=True If True the function returns the pairwise distance matrix else it returns the componentwise L1 pairwise-distances. Not supported for sparse matrix inputs. Returns ------- D : ndarray of shape (n_samples_X * n_samples_Y, n_features) or (n_samples_X, n_samples_Y) If sum_over_features is False shape is (n_samples_X * n_samples_Y, n_features) and D contains the componentwise L1 pairwise-distances (ie. absolute difference), else shape is (n_samples_X, n_samples_Y) and D contains the pairwise L1 distances. Notes -------- When X and/or Y are CSR sparse matrices and they are not already in canonical format, this function modifies them in-place to make them canonical. Examples -------- >>> from sklearn.metrics.pairwise import manhattan_distances >>> manhattan_distances([[3]], [[3]]) array([[0.]]) >>> manhattan_distances([[3]], [[2]]) array([[1.]]) >>> manhattan_distances([[2]], [[3]]) array([[1.]]) >>> manhattan_distances([[1, 2], [3, 4]], [[1, 2], [0, 3]]) array([[0., 2.], [4., 4.]]) >>> import numpy as np >>> X = np.ones((1, 2)) >>> y = np.full((2, 2), 2.) >>> manhattan_distances(X, y, sum_over_features=False) array([[1., 1.], [1., 1.]]) z6sum_over_features=%r not supported for sparse matricesF)r(r cityblockNr1r)r)r TypeErrorrZsum_duplicatesrzerosr+rdatarXZindptrrcdistr:absr3)r r!rgDr"r"r#manhattan_distancess$8   0 rocCsNt||}|d9}|d7}tj|dd|d||ks<|dkrJd|t|<|S)adCompute cosine distance between samples in X and Y. Cosine distance is defined as 1.0 minus the cosine similarity. Read more in the :ref:`User Guide `. Parameters ---------- X : {array-like, sparse matrix} of shape (n_samples_X, n_features) Matrix `X`. Y : {array-like, sparse matrix} of shape (n_samples_Y, n_features), default=None Matrix `Y`. Returns ------- distance matrix : ndarray of shape (n_samples_X, n_samples_Y) See Also -------- cosine_similarity scipy.spatial.distance.cosine : Dense matrices only. r1rrr)r9Ng)cosine_similarityrrDZdiag_indices_from)r r!Sr"r"r#cosine_distanceshs rrcCst||\}}t||S)aD Computes the paired euclidean distances between X and Y. Read more in the :ref:`User Guide `. Parameters ---------- X : array-like of shape (n_samples, n_features) Y : array-like of shape (n_samples, n_features) Returns ------- distances : ndarray of shape (n_samples,) )r-r)r r!r"r"r#paired_euclidean_distancessrscCsZt||\}}||}t|rDt|j|_tt|jddSt|jddSdS)a?Compute the L1 distances between the vectors in X and Y. Read more in the :ref:`User Guide `. Parameters ---------- X : array-like of shape (n_samples, n_features) Y : array-like of shape (n_samples, n_features) Returns ------- distances : ndarray of shape (n_samples,) r)rUr1N)r-rrrmrkZsqueezearraysum)r r!diffr"r"r#paired_manhattan_distancess rwcCs*t||\}}dtt|t|ddS)a Computes the paired cosine distances between X and Y. Read more in the :ref:`User Guide `. Parameters ---------- X : array-like of shape (n_samples, n_features) Y : array-like of shape (n_samples, n_features) Returns ------- distances : ndarray of shape (n_samples,) Notes ----- The cosine distance is equivalent to the half the squared euclidean distance if each sample is normalized to unit norm. g?T)r/)r-rr)r r!r"r"r#paired_cosine_distancessrx)cosiner[l2l1 manhattanrh)r\cKs~|tkrt|}|||St|rnt||\}}tt|}x*tt|D]}|||||||<qLW|Std|dS)a6 Computes the paired distances between X and Y. Computes the distances between (X[0], Y[0]), (X[1], Y[1]), etc... Read more in the :ref:`User Guide `. Parameters ---------- X : ndarray of shape (n_samples, n_features) Array 1 for distance computation. Y : ndarray of shape (n_samples, n_features) Array 2 for distance computation. metric : str or callable, default="euclidean" The metric to use when calculating distance between instances in a feature array. If metric is a string, it must be one of the options specified in PAIRED_DISTANCES, including "euclidean", "manhattan", or "cosine". 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. Returns ------- distances : ndarray of shape (n_samples,) See Also -------- pairwise_distances : Computes the distance between every pair of samples. Examples -------- >>> from sklearn.metrics.pairwise import paired_distances >>> X = [[0, 1], [1, 1]] >>> Y = [[0, 1], [2, 1]] >>> paired_distances(X, Y) array([0., 1.]) zUnknown distance %sN)PAIRED_DISTANCEScallabler-rrjlenranger,)r r!r\kwdsfuncrArQr"r"r#paired_distancess+ rcCst||\}}t||j|dS)a Compute the linear kernel between X and Y. Read more in the :ref:`User Guide `. Parameters ---------- X : ndarray of shape (n_samples_X, n_features) A feature array. Y : ndarray of shape (n_samples_Y, n_features), default=None An optional second feature array. If `None`, uses `Y=X`. dense_output : bool, default=True Whether to return dense output even when the input is sparse. If ``False``, the output is sparse if both input arrays are sparse. .. versionadded:: 0.20 Returns ------- Gram matrix : ndarray of shape (n_samples_X, n_samples_Y) The Gram matrix of the linear kernel, i.e. `X @ Y.T`. )r8)r)rr4)r r!r8r"r"r# linear_kernelsrcCsPt||\}}|dkr$d|jd}t||jdd}||9}||7}||C}|S)a Compute the polynomial kernel between X and Y:: K(X, Y) = (gamma + coef0)^degree Read more in the :ref:`User Guide `. Parameters ---------- X : ndarray of shape (n_samples_X, n_features) Y : ndarray of shape (n_samples_Y, n_features), default=None degree : int, default=3 gamma : float, default=None If None, defaults to 1.0 / n_features. coef0 : float, default=1 Returns ------- Gram matrix : ndarray of shape (n_samples_X, n_samples_Y) Ng?rT)r8)r)r+rr4)r r!degreegammacoef0Kr"r"r#polynomial_kernel4srcCsTt||\}}|dkr$d|jd}t||jdd}||9}||7}t|||S)a Compute the sigmoid kernel between X and Y:: K(X, Y) = tanh(gamma + coef0) Read more in the :ref:`User Guide `. Parameters ---------- X : ndarray of shape (n_samples_X, n_features) Y : ndarray of shape (n_samples_Y, n_features), default=None If `None`, uses `Y=X`. gamma : float, default=None If None, defaults to 1.0 / n_features. coef0 : float, default=1 Returns ------- Gram matrix : ndarray of shape (n_samples_X, n_samples_Y) Ng?rT)r8)r)r+rr4rtanh)r r!rrrr"r"r#sigmoid_kernelXs rcCsLt||\}}|dkr$d|jd}t||dd}|| 9}t|||S)a& Compute the rbf (gaussian) kernel between X and Y:: K(x, y) = exp(-gamma ||x-y||^2) for each pair of rows x in X and y in Y. Read more in the :ref:`User Guide `. Parameters ---------- X : ndarray of shape (n_samples_X, n_features) Y : ndarray of shape (n_samples_Y, n_features), default=None If `None`, uses `Y=X`. gamma : float, default=None If None, defaults to 1.0 / n_features. Returns ------- kernel_matrix : ndarray of shape (n_samples_X, n_samples_Y) Ng?rT)r/)r)r+r6rexp)r r!rrr"r"r# rbf_kernel{s  rcCsDt||\}}|dkr$d|jd}| t||}t|||S)afCompute the laplacian kernel between X and Y. The laplacian kernel is defined as:: K(x, y) = exp(-gamma ||x-y||_1) for each pair of rows x in X and y in Y. Read more in the :ref:`User Guide `. .. versionadded:: 0.17 Parameters ---------- X : ndarray of shape (n_samples_X, n_features) Y : ndarray of shape (n_samples_Y, n_features), default=None If `None`, uses `Y=X`. gamma : float, default=None If None, defaults to 1.0 / n_features. Returns ------- kernel_matrix : ndarray of shape (n_samples_X, n_samples_Y) Ng?r)r)r+rorr)r r!rrr"r"r#laplacian_kernels  rcCsHt||\}}t|dd}||kr(|}n t|dd}t||j|d}|S)aCompute cosine similarity between samples in X and Y. Cosine similarity, or the cosine kernel, computes similarity as the normalized dot product of X and Y: K(X, Y) = / (||X||*||Y||) On L2-normalized data, this function is equivalent to linear_kernel. Read more in the :ref:`User Guide `. Parameters ---------- X : {ndarray, sparse matrix} of shape (n_samples_X, n_features) Input data. Y : {ndarray, sparse matrix} of shape (n_samples_Y, n_features), default=None Input data. If ``None``, the output will be the pairwise similarities between all samples in ``X``. dense_output : bool, default=True Whether to return dense output even when the input is sparse. If ``False``, the output is sparse if both input arrays are sparse. .. versionadded:: 0.17 parameter ``dense_output`` for dense output. Returns ------- kernel matrix : ndarray of shape (n_samples_X, n_samples_Y) T)r()r8)r)rrr4)r r!r8Z X_normalizedZ Y_normalizedrr"r"r#rps#  rpcCst|st|rtdt||\}}|dkr:td||k rV|dkrVtdtj|jd|jdf|jd}t||||S)aComputes the additive chi-squared kernel between observations in X and Y. The chi-squared kernel is computed between each pair of rows in X and Y. X and Y have to be non-negative. This kernel is most commonly applied to histograms. The chi-squared kernel is given by:: k(x, y) = -Sum [(x - y)^2 / (x + y)] It can be interpreted as a weighted difference per entry. Read more in the :ref:`User Guide `. Notes ----- As the negative of a distance, this kernel is only conditionally positive definite. Parameters ---------- X : array-like of shape (n_samples_X, n_features) Y : ndarray of shape (n_samples_Y, n_features), default=None If `None`, uses `Y=X`. Returns ------- kernel_matrix : ndarray of shape (n_samples_X, n_samples_Y) See Also -------- chi2_kernel : The exponentiated version of the kernel, which is usually preferable. sklearn.kernel_approximation.AdditiveChi2Sampler : A Fourier approximation to this kernel. References ---------- * Zhang, J. and Marszalek, M. and Lazebnik, S. and Schmid, C. Local features and kernels for classification of texture and object categories: A comprehensive study International Journal of Computer Vision 2007 https://research.microsoft.com/en-us/um/people/manik/projects/trade-off/papers/ZhangIJCV06.pdf z/additive_chi2 does not support sparse matrices.rzX contains negative values.zY contains negative values.)r) rr,r)anyrrjr+rr)r r!resultr"r"r#additive_chi2_kernels0   r?cCst||}||9}t||S)aAComputes the exponential chi-squared kernel X and Y. The chi-squared kernel is computed between each pair of rows in X and Y. X and Y have to be non-negative. This kernel is most commonly applied to histograms. The chi-squared kernel is given by:: k(x, y) = exp(-gamma Sum [(x - y)^2 / (x + y)]) It can be interpreted as a weighted difference per entry. Read more in the :ref:`User Guide `. Parameters ---------- X : array-like of shape (n_samples_X, n_features) Y : ndarray of shape (n_samples_Y, n_features), default=None gamma : float, default=1. Scaling parameter of the chi2 kernel. Returns ------- kernel_matrix : ndarray of shape (n_samples_X, n_samples_Y) See Also -------- additive_chi2_kernel : The additive version of this kernel. sklearn.kernel_approximation.AdditiveChi2Sampler : A Fourier approximation to the additive version of this kernel. References ---------- * Zhang, J. and Marszalek, M. and Lazebnik, S. and Schmid, C. Local features and kernels for classification of texture and object categories: A comprehensive study International Journal of Computer Vision 2007 https://research.microsoft.com/en-us/um/people/manik/projects/trade-off/papers/ZhangIJCV06.pdf )rrr)r r!rrr"r"r# chi2_kernel-s* r) rhryr[rdrzr{r|r% nan_euclideancCstS)aValid metrics for pairwise_distances. This function simply returns the valid pairwise distance metrics. It exists to allow for a description of the mapping for each of the valid strings. The valid distance metrics, and the function they map to, are: =============== ======================================== metric Function =============== ======================================== 'cityblock' metrics.pairwise.manhattan_distances 'cosine' metrics.pairwise.cosine_distances 'euclidean' metrics.pairwise.euclidean_distances 'haversine' metrics.pairwise.haversine_distances 'l1' metrics.pairwise.manhattan_distances 'l2' metrics.pairwise.euclidean_distances 'manhattan' metrics.pairwise.manhattan_distances 'nan_euclidean' metrics.pairwise.nan_euclidean_distances =============== ======================================== Read more in the :ref:`User Guide `. )PAIRWISE_DISTANCE_FUNCTIONSr"r"r"r#distance_metricslsrcOs||||dd|f<dS)z/Write in-place to a slice of a distance matrix.Nr")Z dist_funcZ dist_matrixZslice_argskwargsr"r"r# _dist_wrappersrc sdkr t\}t|dkr6fStttjjdjdf|ddtd|dfdd tt t|Dksdkrt krt dS) zQBreak the pairwise matrix in n_jobs even slices and compute them in parallel.NrrF)rorder threading)backendn_jobsc3s&|]}||fVqdS)Nr").0s)r r!fdrrretr"r# sz%_parallel_pairwise..) r$rrrrrIr+rr r r6r=)r r!rrrrr")r r!rrrrr#_parallel_pairwises    rc Ks4t|||d\}}||krtj|jd|jdfdd}tt|jdd}x.|D]&\}}|||||f||||f<qTW||j}xt|jdD]"}||} || | f||||f<qWnptj|jd|jdfdd}t t|jdt|jd}x0|D](\}}|||||f||||f<qW|S)z:Handle the callable case for pairwise_{distances,kernels}.)r'rr)rr) r)rrjr+ itertools combinationsrr4rIproduct) r r!r\r'rr9iteratorrQrSxr"r"r#_pairwise_callables"  $rrzr{r|rhZ braycurtisZcanberraZ chebyshevZ correlationryZdiceZhammingZjaccardZ kulsinski mahalanobisZmatchingZ minkowskiZrogerstanimotoZ russellrao seuclideanZ sokalmichenerZ sokalsneathZ sqeuclideanZyuleZ wminkowskirrdcs|dkr dSt|t}|s |f}tdd|DrNtd|r>|n|dftfdd|Drtdd|D}td|r|n|dfdS) z?Checks chunk is a sequence of expected size or a tuple of same.Ncss$|]}t|tpt|d VqdS)__iter__N)rtuplehasattr)rrr"r"r#rsz$_check_chunk_size..z;reduce_func returned %r. Expected sequence(s) of length %d.rc3s|]}t|kVqdS)N)r )rr) chunk_sizer"r#rscss|]}t|VqdS)N)r )rrr"r"r#rszLreduce_func returned object of length %s. Expected same length as input: %d.)rrrrir,)Zreducedris_tupleZ actual_sizer")rr#_check_chunk_sizes rcKs|dkrRd|krRttdkr"tjnd}||krBtj|dd|d}ntdd|iS|d krd |kr||krtjt|j j }ntd d |iSiS) z:Precompute data-derived metric parameters if not provided.rVz1.5Nrr)rUZddofrzIThe 'V' parameter is required for the seuclidean metric when Y is passed.rVIzKThe 'VI' parameter is required for the mahalanobis metric when Y is passed.) rrrrNvarr,ZlinalginvZcovr4)r r!r\rrrrr"r"r#_precompute_metric_paramssr)r^r\rworking_memorycks"t|}|dkrtd|f}n,|dkr*|}tdt|||d} t|| }t||fd|i|} |jf| x|D]} | jdkr| j|kr|} n|| } t| |f||d|} ||ks|dkrt |dt krd| j | jdt|d<|dk r| j d}|| | j} t| || VqrWdS) aGenerate a distance matrix chunk by chunk with optional reduction. In cases where not all of a pairwise distance matrix needs to be stored at once, this is used to calculate pairwise distances in ``working_memory``-sized chunks. If ``reduce_func`` is given, it is run on each chunk and its return values are concatenated into lists, arrays or sparse matrices. Parameters ---------- X : ndarray of shape (n_samples_X, n_samples_X) or (n_samples_X, n_features) Array of pairwise distances between samples, or a feature array. The shape the array should be (n_samples_X, n_samples_X) if metric='precomputed' and (n_samples_X, n_features) otherwise. Y : ndarray of shape (n_samples_Y, n_features), default=None An optional second feature array. Only allowed if metric != "precomputed". reduce_func : callable, default=None The function which is applied on each chunk of the distance matrix, reducing it to needed values. ``reduce_func(D_chunk, start)`` is called repeatedly, where ``D_chunk`` is a contiguous vertical slice of the pairwise distance matrix, starting at row ``start``. It should return one of: None; an array, a list, or a sparse matrix of length ``D_chunk.shape[0]``; or a tuple of such objects. Returning None is useful for in-place operations, rather than reductions. If None, pairwise_distances_chunked returns a generator of vertical chunks of the distance matrix. metric : str or callable, default='euclidean' The metric to use when calculating distance between instances in a feature array. If metric is a string, it must be one of the options allowed by scipy.spatial.distance.pdist for its metric parameter, or a metric listed in pairwise.PAIRWISE_DISTANCE_FUNCTIONS. If metric is "precomputed", X is assumed to be a distance 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. n_jobs : int, default=None The number of jobs to use for the computation. This works by breaking down the pairwise 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. working_memory : int, default=None The sought maximum memory for temporary distance matrix chunks. When None (default), the value of ``sklearn.get_config()['working_memory']`` is used. `**kwds` : optional keyword parameters Any further parameters are passed directly to the distance function. If using a scipy.spatial.distance metric, the parameters are still metric dependent. See the scipy docs for usage examples. Yields ------ D_chunk : {ndarray, sparse matrix} A contiguous slice of distance matrix, optionally processed by ``reduce_func``. Examples -------- Without reduce_func: >>> import numpy as np >>> from sklearn.metrics import pairwise_distances_chunked >>> X = np.random.RandomState(0).rand(5, 3) >>> D_chunk = next(pairwise_distances_chunked(X)) >>> D_chunk array([[0. ..., 0.29..., 0.41..., 0.19..., 0.57...], [0.29..., 0. ..., 0.57..., 0.41..., 0.76...], [0.41..., 0.57..., 0. ..., 0.44..., 0.90...], [0.19..., 0.41..., 0.44..., 0. ..., 0.51...], [0.57..., 0.76..., 0.90..., 0.51..., 0. ...]]) Retrieve all neighbors and average distance within radius r: >>> r = .2 >>> def reduce_func(D_chunk, start): ... neigh = [np.flatnonzero(d < r) for d in D_chunk] ... avg_dist = (D_chunk * (D_chunk < r)).mean(axis=1) ... return neigh, avg_dist >>> gen = pairwise_distances_chunked(X, reduce_func=reduce_func) >>> neigh, avg_dist = next(gen) >>> neigh [array([0, 3]), array([1]), array([2]), array([0, 3]), array([4])] >>> avg_dist array([0.039..., 0. , 0. , 0.039..., 0. ]) Where r is defined per sample, we need to make use of ``start``: >>> r = [.2, .4, .4, .3, .1] >>> def reduce_func(D_chunk, start): ... neigh = [np.flatnonzero(d < r[i]) ... for i, d in enumerate(D_chunk, start)] ... return neigh >>> neigh = next(pairwise_distances_chunked(X, reduce_func=reduce_func)) >>> neigh [array([0, 3]), array([0, 1]), array([2]), array([0, 3]), array([4])] Force row-by-row generation by reducing ``working_memory``: >>> gen = pairwise_distances_chunked(X, reduce_func=reduce_func, ... working_memory=0) >>> next(gen) [array([0, 3])] >>> next(gen) [array([0, 1])] r%rN)Z row_bytesZ max_n_rowsrr\)r\rr)r slicerr rupdaterWstoppairwise_distancesrgetr6Zflatr+r)r r!r^r\rrrrOZslicesZ chunk_n_rowsparamsslrRZD_chunkrr"r"r#r`s4         r`)rr'c Ks~|tkr(t|s(|dkr(td|tf|dkrXt||d|d\}}d}t||d|S|tkrlt|}nt|rttf||d|}nt|st|rt d|t krt nd } | t kr|j t ks|d k r|j t krd |} t | tt||| |d \}}t||fd |i|} |jf| t|d krV||krVttj|fd |i|Sttjfd |i|}t||||f|S)aCompute the distance matrix from a vector array X and optional Y. This method takes either a vector array or a distance matrix, and returns a distance matrix. If the input is a vector array, the distances are computed. If the input is a distances matrix, it is returned instead. This method provides a safe way to take a distance matrix as input, while preserving compatibility with many other algorithms that take a vector array. If Y is given (default is None), then the returned matrix is the pairwise distance between the arrays from both X and Y. Valid values for metric are: - From scikit-learn: ['cityblock', 'cosine', 'euclidean', 'l1', 'l2', 'manhattan']. These metrics support sparse matrix inputs. ['nan_euclidean'] but it does not yet support sparse matrices. - From scipy.spatial.distance: ['braycurtis', 'canberra', 'chebyshev', 'correlation', 'dice', 'hamming', 'jaccard', 'kulsinski', 'mahalanobis', 'minkowski', 'rogerstanimoto', 'russellrao', 'seuclidean', 'sokalmichener', 'sokalsneath', 'sqeuclidean', 'yule'] See the documentation for scipy.spatial.distance for details on these metrics. These metrics do not support sparse matrix inputs. Note that in the case of 'cityblock', 'cosine' and 'euclidean' (which are valid scipy.spatial.distance metrics), the scikit-learn implementation will be used, which is faster and has support for sparse matrices (except for 'cityblock'). For a verbose description of the metrics from scikit-learn, see the __doc__ of the sklearn.pairwise.distance_metrics function. Read more in the :ref:`User Guide `. Parameters ---------- X : ndarray of shape (n_samples_X, n_samples_X) or (n_samples_X, n_features) Array of pairwise distances between samples, or a feature array. The shape of the array should be (n_samples_X, n_samples_X) if metric == "precomputed" and (n_samples_X, n_features) otherwise. Y : ndarray of shape (n_samples_Y, n_features), default=None An optional second feature array. Only allowed if metric != "precomputed". metric : str or callable, default='euclidean' The metric to use when calculating distance between instances in a feature array. If metric is a string, it must be one of the options allowed by scipy.spatial.distance.pdist for its metric parameter, or a metric listed in ``pairwise.PAIRWISE_DISTANCE_FUNCTIONS``. If metric is "precomputed", X is assumed to be a distance 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. n_jobs : int, default=None The number of jobs to use for the computation. This works by breaking down the pairwise 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. force_all_finite : bool or 'allow-nan', default=True Whether to raise an error on np.inf, np.nan, pd.NA in array. Ignored for a metric listed in ``pairwise.PAIRWISE_DISTANCE_FUNCTIONS``. The possibilities are: - True: Force all values of array to be finite. - False: accepts np.inf, np.nan, pd.NA in array. - 'allow-nan': accepts only np.nan and pd.NA values in array. Values cannot be infinite. .. versionadded:: 0.22 ``force_all_finite`` accepts the string ``'allow-nan'``. .. versionchanged:: 0.23 Accepts `pd.NA` and converts it into `np.nan`. **kwds : optional keyword parameters Any further parameters are passed directly to the distance function. If using a scipy.spatial.distance metric, the parameters are still metric dependent. See the scipy docs for usage examples. Returns ------- D : ndarray of shape (n_samples_X, n_samples_X) or (n_samples_X, n_samples_Y) A distance matrix D such that D_{i, j} is the distance between the ith and jth vectors of the given matrix X, if Y is None. If Y is not None, then D_{i, j} is the distance between the ith array from X and the jth array from Y. See Also -------- pairwise_distances_chunked : Performs the same calculation as this function, but returns a generator of chunks of the distance matrix, in order to limit memory usage. paired_distances : Computes the distances between corresponding elements of two arrays. r%zHUnknown metric %s. Valid metrics are %s, or 'precomputed', or a callableT)r%r'zM`pairwise_distances`. Precomputed distance need to have non-negative values.)whom)r\r'z6scipy distance metrics do not support sparse matrices.Nz+Data was converted to boolean for metric %s)rr'r\r)_VALID_METRICSr~r,r)r rrrrriPAIRWISE_BOOLEAN_FUNCTIONSboolrwarningswarnrrrrrZ squareformZpdistrlr) r r!r\rr'r_rrrmsgrr"r"r#rs>n   $  r) additive_chi2chi2linear polynomialpolyrbf laplaciansigmoidrycCstS)a8Valid metrics for pairwise_kernels. This function simply returns the valid pairwise distance metrics. It exists, however, to allow for a verbose description of the mapping for each of the valid strings. The valid distance metrics, and the function they map to, are: =============== ======================================== metric Function =============== ======================================== 'additive_chi2' sklearn.pairwise.additive_chi2_kernel 'chi2' sklearn.pairwise.chi2_kernel 'linear' sklearn.pairwise.linear_kernel 'poly' sklearn.pairwise.polynomial_kernel 'polynomial' sklearn.pairwise.polynomial_kernel 'rbf' sklearn.pairwise.rbf_kernel 'laplacian' sklearn.pairwise.laplacian_kernel 'sigmoid' sklearn.pairwise.sigmoid_kernel 'cosine' sklearn.pairwise.cosine_similarity =============== ======================================== Read more in the :ref:`User Guide `. )PAIRWISE_KERNEL_FUNCTIONSr"r"r"r#kernel_metricssrr"rrr) rrryrrrrrrr) filter_paramsrc  sddlm}dkr*t||dd\}}|St|r<j}nTtkrf|r\fddDt}n*trttfdi}n t d t ||||fS) a Compute the kernel between arrays X and optional array Y. This method takes either a vector array or a kernel matrix, and returns a kernel matrix. If the input is a vector array, the kernels are computed. If the input is a kernel matrix, it is returned instead. This method provides a safe way to take a kernel matrix as input, while preserving compatibility with many other algorithms that take a vector array. If Y is given (default is None), then the returned matrix is the pairwise kernel between the arrays from both X and Y. Valid values for metric are: ['additive_chi2', 'chi2', 'linear', 'poly', 'polynomial', 'rbf', 'laplacian', 'sigmoid', 'cosine'] Read more in the :ref:`User Guide `. Parameters ---------- X : ndarray of shape (n_samples_X, n_samples_X) or (n_samples_X, n_features) Array of pairwise kernels between samples, or a feature array. The shape of the array should be (n_samples_X, n_samples_X) if metric == "precomputed" and (n_samples_X, n_features) otherwise. Y : ndarray of shape (n_samples_Y, n_features), default=None A second feature array only if X has shape (n_samples_X, n_features). metric : str 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 rows from X as input and return the corresponding kernel value as a single number. This means that callables from :mod:`sklearn.metrics.pairwise` are not allowed, as they operate on matrices, not single samples. Use the string identifying the kernel instead. filter_params : bool, default=False Whether to filter invalid parameters or not. n_jobs : int, default=None The number of jobs to use for the computation. This works by breaking down the pairwise 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. **kwds : optional keyword parameters Any further parameters are passed directly to the kernel function. Returns ------- K : ndarray of shape (n_samples_X, n_samples_X) or (n_samples_X, n_samples_Y) A kernel matrix K such that K_{i, j} is the kernel between the ith and jth vectors of the given matrix X, if Y is None. If Y is not None, then K_{i, j} is the kernel between the ith array from X and the jth array from Y. Notes ----- If metric is 'precomputed', Y is ignored and X is returned. r)Kernelr%T)r%cs"i|]}|tkr||qSr") KERNEL_PARAMS)rk)rr\r"r# sz$pairwise_kernels..r\zUnknown kernel %r) Zgaussian_process.kernelsrr)r__call__rr~rrr,r) r r!r\rrrZGPKernelrrr")rr\r#pairwise_kernelssL    r)N)NNF)N)NNNN)N)N)N)NT)NrNr)NNr)NN)NN)NT)N)Nr)T)N)N)Nr[)Nr)Sr functoolsrrnumpyrZ scipy.spatialrZ scipy.sparserrZjoblibrrZutils.validationr r utilsr r r rrZ utils.extmathrrZ preprocessingrZ utils._maskrZ utils.fixesrrrZ_pairwise_fastrr exceptionsrr$r)r-r6r5rErFr;rZrarbrfrorrrsrwrxr}rrrrrrrprrrrrrrrZ _NAN_METRICSrrr`rrrr frozensetrrr"r"r"r# s             v&j 4t IXH 2Q &:  $ # " # 0 = 3  '#