ó ‡ˆ\c@s#dZddlZddlZddlmZddlmZmZddlm Z ddl m Z dd l m Z dd lmZdd lmZd gZd ZejeƒjdZd„Zd„Zdefd„ƒYZdeefd„ƒYZd„Zd e eefd„ƒYZdS(s#Approximate nearest neighbor searchiÿÿÿÿN(tsparsei(tKNeighborsMixintRadiusNeighborsMixini(t BaseEstimator(t check_array(tcheck_random_state(tpairwise_distances(tGaussianRandomProjectiont LSHForests>u4icCs<tj|||@ƒ}tj|||Bddƒ}||fS(s³Finds indices in sorted array of integers. Most significant h bits in the binary representations of the integers are matched with the items' most significant h bits. tsidetright(tnpt searchsorted(ttreetbin_Xt left_maskt right_maskt left_indext right_index((s<lib/python2.7/site-packages/sklearn/neighbors/approximate.pyt_find_matching_indicess cCsztj|dtjƒ}|j|ƒtj|dtjƒ}tj|dtjƒ}t||||||ƒ\}} | |k} ||| <|| R@RD(((s<lib/python2.7/site-packages/sklearn/neighbors/approximate.pyRAkscCs&tjt|ƒdtƒ}||(|S(s.Creates an array of array from list of arrays.R(R temptytlentobject(tlist_of_arraysR3((s<lib/python2.7/site-packages/sklearn/neighbors/approximate.pyt_array_of_arraysŒscBseZdZdddddddd„Zd„Zd „Zd „Zd „Zdd „Z d „Z de d„Z de d„Z dd„ZRS(sžPerforms approximate nearest neighbor search using LSH forest. LSH Forest: Locality Sensitive Hashing forest [1] is an alternative method for vanilla approximate nearest neighbor search methods. LSH forest data structure has been implemented using sorted arrays and binary search and 32 bit fixed-length hashes. Random projection is used as the hash family which approximates cosine distance. The cosine distance is defined as ``1 - cosine_similarity``: the lowest value is 0 (identical point) but it is bounded above by 2 for the farthest points. Its value does not depend on the norm of the vector points but only on their relative angles. Parameters ---------- n_estimators : int (default = 10) Number of trees in the LSH Forest. radius : float, optinal (default = 1.0) Radius from the data point to its neighbors. This is the parameter space to use by default for the :meth:`radius_neighbors` queries. n_candidates : int (default = 50) Minimum number of candidates evaluated per estimator, assuming enough items meet the `min_hash_match` constraint. n_neighbors : int (default = 5) Number of neighbors to be returned from query function when it is not provided to the :meth:`kneighbors` method. min_hash_match : int (default = 4) lowest hash length to be searched when candidate selection is performed for nearest neighbors. radius_cutoff_ratio : float, optional (default = 0.9) A value ranges from 0 to 1. Radius neighbors will be searched until the ratio between total neighbors within the radius and the total candidates becomes less than this value unless it is terminated by hash length reaching `min_hash_match`. random_state : int, RandomState instance or None, optional (default=None) If int, random_state is the seed used by the random number generator; If RandomState instance, random_state is the random number generator; If None, the random number generator is the RandomState instance used by `np.random`. Attributes ---------- hash_functions_ : list of GaussianRandomProjectionHash objects Hash function g(p,x) for a tree is an array of 32 randomly generated float arrays with the same dimension as the data set. This array is stored in GaussianRandomProjectionHash object and can be obtained from ``components_`` attribute. trees_ : array, shape (n_estimators, n_samples) Each tree (corresponding to a hash function) contains an array of sorted hashed values. The array representation may change in future versions. original_indices_ : array, shape (n_estimators, n_samples) Original indices of sorted hashed values in the fitted index. References ---------- .. [1] M. Bawa, T. Condie and P. Ganesan, "LSH Forest: Self-Tuning Indexes for Similarity Search", WWW '05 Proceedings of the 14th international conference on World Wide Web, 651-660, 2005. Examples -------- >>> from sklearn.neighbors import LSHForest >>> X_train = [[5, 5, 2], [21, 5, 5], [1, 1, 1], [8, 9, 1], [6, 10, 2]] >>> X_test = [[9, 1, 6], [3, 1, 10], [7, 10, 3]] >>> lshf = LSHForest(random_state=42) # doctest: +SKIP >>> lshf.fit(X_train) # doctest: +SKIP LSHForest(min_hash_match=4, n_candidates=50, n_estimators=10, n_neighbors=5, radius=1.0, radius_cutoff_ratio=0.9, random_state=42) >>> distances, indices = lshf.kneighbors(X_test, n_neighbors=2) ... # doctest: +SKIP >>> distances # doctest: +SKIP array([[0.069..., 0.149...], [0.229..., 0.481...], [0.004..., 0.014...]]) >>> indices # doctest: +SKIP array([[1, 2], [2, 0], [4, 0]]) i gð?i2iigÍÌÌÌÌÌì?cCsS||_||_||_||_||_||_||_tjdt ƒdS(NscLSHForest has poor performance and has been deprecated in 0.19. It will be removed in version 0.21.( t n_estimatorstradiusRCt n_candidatest n_neighborstmin_hash_matchtradius_cutoff_ratiotwarningstwarntDeprecationWarning(R7RJRKRLRMRNRORC((s<lib/python2.7/site-packages/sklearn/neighbors/approximate.pyRDõs        cCsÇ|jdkr:tjddtjƒtjddtƒfStj|jƒr\|j|}n|jj|ddddƒ}t ||ddƒd}tj |ƒ}|j|ddddƒ}||fS( sÈComputes the cosine distance. Distance is from the query to points in the candidates array. Returns argsort of distances in the candidates array and sorted distances. iRtaxistmodetcliptmetrictcosine(i( RR RER.tfloatRtissparset_fit_XRRtargsort(R7tqueryt candidatest candidate_Xt distancestdistance_positions((s<lib/python2.7/site-packages/sklearn/neighbors/approximate.pyt_compute_distancess+  cCs¦td}tjtj||fdtƒƒdd…dd…f}|ddd…ddd…f}tj|ƒjdtƒ|_tj|ƒjdtƒ|_ dS(s2Creates left and right masks for all hash lengths.iRNiÿÿÿÿ( t MAX_HASH_SIZER ttriltonesR.R,R/R0t _left_maskt _right_mask(R7ttri_sizeRR((s<lib/python2.7/site-packages/sklearn/neighbors/approximate.pyt_generate_maskss  :"cCsÉ|jjd}d}tƒ}|j|j}xÄ||jkrõ||ks_t|ƒ|krõ|j|} |j|} xlt |jƒD][} t |j | || | | ƒ\} } || | 7}|j |j | | | !jƒƒq‰W|d8}q2Wtj|dt|ƒdtjƒ}|jd|kr’tjd||jfƒtjtjd|ƒ|ƒ}||jd}tj||| fƒ}n|j||jtƒƒ\}}||| || fS(s‡Performs the Synchronous ascending phase. Returns an array of candidates, their distance ranks and distances. iitcountRs•Number of candidates is not sufficient to retrieve %i neighbors with min_hash_match = %i. Candidates are filled up uniformly from unselected indices.(RZRtsetRLRJRNRFReRftrangeRttrees_tupdatetoriginal_indices_ttolistR tfromiterRRPRQt setdiff1dRt concatenateRaR-R.(R7R\t max_deptht bin_queriesRMt index_sizeRLt candidate_settmin_candidatesRRtitstarttstopR]t remainingtto_filltranksR_((s<lib/python2.7/site-packages/sklearn/neighbors/approximate.pyt_get_candidates#s<        cCsÇd}d|j}tjgdtƒ}tjgdtƒ}tjgdtƒ} xh||jkr¼||kr¼|j|} |j|} g} x^t|j ƒD]M} t |j | || | | ƒ\}}| j |j | ||!jƒƒq Wtj| |ƒ} tj|| ƒ}|j|| ƒ\}}tj||ddƒ}tj| || ƒ}tj||| || ƒ}tj| ||| ƒ} |jdt|jdƒ}|d}qUW|| fS(sªFinds radius neighbors from the candidates obtained. Their distances from query are smaller than radius. Returns radius neighbors and distances. iRR R i(ROR tarrayR.RXRNReRfRkRJRRltextendRnRoRqtappendRaR tinsertR(R7R\RsRtRKtratio_within_radiust thresholdttotal_candidatesttotal_neighborsttotal_distancesRRR]RxRyRzR}R_tmt positions((s<lib/python2.7/site-packages/sklearn/neighbors/approximate.pyt_get_radius_neighborsTs:         c Cst|ddƒ|_g|_g|_g|_t|jƒ}tjtj ƒj }xt |j ƒD]Œ}t t|jd|ƒƒ}|j|jƒdd…df}tj|ƒ}||} |jj|ƒ|jj| ƒ|jj|ƒqdW|jƒ|S(s{Fit the LSH forest on the data. This creates binary hashes of input data points by getting the dot product of input points and hash_function then transforming the projection into a binary string array based on the sign (positive/negative) of the projection. A sorted array of binary hashes is created. Parameters ---------- X : array_like or sparse (CSR) matrix, shape (n_samples, n_features) List of n_features-dimensional data points. Each row corresponds to a single data point. Returns ------- self : object t accept_sparsetcsriN(RRZthash_functions_RlRnRRCR tiinfotint32tmaxRkRJRARbtrandintR:R[RRh( R7R8R9trngtint_maxRxthasherthashestoriginal_indext bin_hashes((s<lib/python2.7/site-packages/sklearn/neighbors/approximate.pyR5ys"   "  cCs¸tjg|jD]%}|j|ƒdd…df^qƒ}tj|dƒ}gt|jtj|dƒƒD]*\}}t||t|j |j ƒ^qo}|tj |ddƒfS(s0Performs descending phase to find maximum depth.NiiRS( R tasarrayRR6trollaxistzipRlR)RbReRfR(R7R8R”RtR t tree_queriestdepths((s<lib/python2.7/site-packages/sklearn/neighbors/approximate.pyt_query©s 5 Cc Cst|dƒstdƒ‚n|dkr6|j}nt|ddƒ}gg}}|j|ƒ\}}xbt|jdƒD]M}|j||g|||||ƒ\} } |j | ƒ|j | ƒq~W|rñt j |ƒt j |ƒfSt j |ƒSdS(s²Returns n_neighbors of approximate nearest neighbors. Parameters ---------- X : array_like or sparse (CSR) matrix, shape (n_samples, n_features) List of n_features-dimensional data points. Each row corresponds to a single query. n_neighbors : int, optional (default = None) Number of neighbors required. If not provided, this will return the number specified at the initialization. return_distance : boolean, optional (default = True) Returns the distances of neighbors if set to True. Returns ------- dist : array, shape (n_samples, n_neighbors) Array representing the cosine distances to each point, only present if return_distance=True. ind : array, shape (n_samples, n_neighbors) Indices of the approximate nearest points in the population matrix. Rsestimator should be fitted.R‹RŒiN( thasattrR+R@RMRRRkRR~RR R( R7R8RMtreturn_distancet neighborsR_RtRsRxtneighstdists((s<lib/python2.7/site-packages/sklearn/neighbors/approximate.pyt kneighbors¸s     c Csùt|dƒstdƒ‚n|dkr6|j}nt|ddƒ}gg}}|j|ƒ\}}xbt|jdƒD]M}|j||g|||||ƒ\} } |j | ƒ|j | ƒq~W|rët |ƒt |ƒfSt |ƒSdS(sÁFinds the neighbors within a given radius of a point or points. Return the indices and distances of some points from the dataset lying in a ball with size ``radius`` around the points of the query array. Points lying on the boundary are included in the results. The result points are *not* necessarily sorted by distance to their query point. LSH Forest being an approximate method, some true neighbors from the indexed dataset might be missing from the results. Parameters ---------- X : array_like or sparse (CSR) matrix, shape (n_samples, n_features) List of n_features-dimensional data points. Each row corresponds to a single query. radius : float Limiting distance of neighbors to return. (default is the value passed to the constructor). return_distance : boolean, optional (default = False) Returns the distances of neighbors if set to True. Returns ------- dist : array, shape (n_samples,) of arrays Each element is an array representing the cosine distances to some points found within ``radius`` of the respective query. Only present if ``return_distance=True``. ind : array, shape (n_samples,) of arrays Each element is an array of indices for neighbors within ``radius`` of the respective query. Rsestimator should be fitted.R‹RŒiN( RžR+R@RKRRRkRRŠRRI( R7R8RKRŸR R_RtRsRxR¡R¢((s<lib/python2.7/site-packages/sklearn/neighbors/approximate.pytradius_neighborsés%    cCst|ddƒ}t|dƒs.|j|ƒS|jd|jjdkrZtdƒ‚n|jd}|jjd}x©t|jƒD]˜}|j|j |ƒdd…df}|j |j |ƒ}t j |j |||ƒ|j |R@RDRaRhR~RŠR5RtTrueR£R¤R©(((s<lib/python2.7/site-packages/sklearn/neighbors/approximate.pyR“s`    1 % 0 1;(R>tnumpyR RPtscipyRtbaseRRRtutils.validationRtutilsRtmetrics.pairwiseRtrandom_projectionRt__all__R0RtitemsizeRbRR)RGR*RARIR(((s<lib/python2.7/site-packages/sklearn/neighbors/approximate.pyts&    %"