U ֽ|e[ @sRddlmZddlZddlmZddlZddlmZddlm Z ddl m Z m Z ddl mZddlmZdd lmZdd lmZz ddlZWn ek rdd lmZYnXddlZddlZdd lmZmZddl Zddl!Z!ddl"m#Z$ddl%m&Z&dd l'm(Z(m)Z)m*Z*m+Z+ddl,m-Z-ddl.m/Z/m0Z0m1Z1ddl2m3Z3ddl4m5Z6ddl7m8Z9e:ej;dedZ?ed?ZWd'd3did'fd@dAZXd]dCdDZYdEdFZZdGdHZ[e$j\dIid$d d dfdJdKZ]e!KdLdMZ^dNdOZ_e!KdPdQZ`dRdSZaGdTdUdUe ZbdS)^)print_functionN)warn) curve_fit) BaseEstimator)check_random_state check_array)check_is_fitted)pairwise_distances) normalize)KDTree)joblib)triltriu) submatrixts csr_uniquefast_knn_indices)spectral_layout)optimize_layout_euclideanoptimize_layout_genericoptimize_layout_inverse) NNDescent)named_distances)sparse_named_distancesCgh㈵>MbP?) correlationcosine hellingerjaccarddiceccs8|D].}t|ttfr,t|D] }|Vqq|VqdSN) isinstancelisttuple flatten_iter) containerijr+G/var/www/website-v5/atlas_env/lib/python3.8/site-packages/umap/umap_.pyr'Es   r'cCs tt|Sr#)r&r')r(r+r+r, flattenedNsr-c Csg}|g}i}d||<tj}|g}|r|d}|||tjkr\t||kr\t|}||d|kr"||j} | D]0} | |krz|| || ||d|| <qzq"t|SNrr) npinfpopappendlenmaxvaluesindicesarray) adjmatstart min_verticesZexploredqueuelevelsZ max_levelZvisitednode neighborsZ neighbourr+r+r,breadth_first_searchRs&      r?皙?FcCs||dk@|dk@r,td|d|dnZ|dk|||k@r^td|d|d|dn(|||krtd|d|d |d d S) zDA simple wrapper function to avoid large amounts of code repetition.rzDisconnection_distance = z has removed z@ edges. This is not a problem as no vertices were disconnected.zuA few of your vertices were disconnected from the manifold. This shouldn't cause problems. Disconnection_distance = z' edges. It has only fully disconnected zC vertices. Use umap.utils.disconnected_vertices() to identify them.z^A large number of your vertices were disconnected from the manifold. Disconnection_distance = z" edges. It has fully disconnected z vertices. You might consider using find_disconnected_points() to find and remove these points from your data. Use umap.utils.disconnected_vertices() to identify them.N)printr) edges_removedvertices_disconnecteddisconnection_distanceZ total_rowsZ thresholdverboser+r+r,raise_disconnected_warningls   rF)psumlomidhiT)localsfastmath@?c Cs:t||}tj|jdtjd}tj|jdtjd}t|}t|jdD]} d} t} d} || } | | dk}|jd|krtt |}||}|dkr||d|| <|t kr|| |||||d7<n||d|| <n|jddkrt ||| <t|D]}d}td|jdD]B}|| |f|| }|dkrj|t ||  7}n|d7}q2t ||t krq||kr| } | | d} n$| } | tkr| d9} n | | d} q| || <|| dkrt| }|| t|kr0t||| <qR|| t|krRt||| <qR||fS)aCompute a continuous version of the distance to the kth nearest neighbor. That is, this is similar to knn-distance but allows continuous k values rather than requiring an integral k. In essence we are simply computing the distance such that the cardinality of fuzzy set we generate is k. Parameters ---------- distances: array of shape (n_samples, n_neighbors) Distances to nearest neighbors for each samples. Each row should be a sorted list of distances to a given samples nearest neighbors. k: float The number of nearest neighbors to approximate for. n_iter: int (optional, default 64) We need to binary search for the correct distance value. This is the max number of iterations to use in such a search. local_connectivity: int (optional, default 1) The local connectivity required -- i.e. the number of nearest neighbors that should be assumed to be connected at a local level. The higher this value the more connected the manifold becomes locally. In practice this should be not more than the local intrinsic dimension of the manifold. bandwidth: float (optional, default 1) The target bandwidth of the kernel, larger values will produce larger return values. Returns ------- knn_dist: array of shape (n_samples,) The distance to kth nearest neighbor, as suitably approximated. nn_dist: array of shape (n_samples,) The distance to the 1st nearest neighbor for each point. rdtyperNr@r)r/log2zerosshapefloat32meanrange NPY_INFINITYintfloorSMOOTH_K_TOLERANCEr4expfabsMIN_K_DIST_SCALE) distanceskZn_iterlocal_connectivityZ bandwidthtargetrhoresultZmean_distancesr)rHrJrIZ ith_distancesZnon_zero_distsindexZ interpolationnrGr*dZmean_ith_distancesr+r+r,smooth_knn_dists\0           ric Cs| rttd|dkrbt||} |t|jddddf| f} | tjk} d| | <d} nltddt t |jddd }t dt t t |jd}t |||||||d ||| d d } | j\} } | rttd | | | fS)aYCompute the ``n_neighbors`` nearest points for each data point in ``X`` under ``metric``. This may be exact, but more likely is approximated via nearest neighbor descent. Parameters ---------- X: array of shape (n_samples, n_features) The input data to compute the k-neighbor graph of. n_neighbors: int The number of nearest neighbors to compute for each sample in ``X``. metric: string or callable The metric to use for the computation. metric_kwds: dict Any arguments to pass to the metric computation function. angular: bool Whether to use angular rp trees in NN approximation. random_state: np.random state The random state to use for approximate NN computations. low_memory: bool (optional, default True) Whether to pursue lower memory NNdescent. verbose: bool (optional, default False) Whether to print status data during the computation. Returns ------- knn_indices: array of shape (n_samples, n_neighbors) The indices on the ``n_neighbors`` closest points in the dataset. knn_dists: array of shape (n_samples, n_neighbors) The distances to the ``n_neighbors`` closest points in the dataset. rp_forest: list of trees The random projection forest used for searching (if used, None otherwise) zFinding Nearest Neighbors precomputedrNrjrM?g4@<F) n_neighborsmetric metric_kwds random_staten_treesn_itersZmax_candidates low_memoryn_jobsrE compressedz Finished Nearest Neighbor Search)rArrr/arangerUcopyr0minrZroundr4rSrneighbor_graph)Xrorprqangularrrruuse_pynndescentrvrE knn_indices knn_distsdisconnected_indexknn_search_indexrsrtr+r+r,nearest_neighborss85  ( $  r)rsigmasrhosval)rKparallelrLcCs`|jd}|jd}tj|jtjd}tj|jtjd} tj|jtjd} |rbtj|jtjd} nd} t|D]} t|D]} || | fdkrqz|dk|| | f| k@rd}nN|| | f|| dks|| dkrd}n$t|| | f|| ||  }| || || <|| | f| | || <|| | || <|rz|| | f| | || <qzqn|| | | fS) a3Construct the membership strength data for the 1-skeleton of each local fuzzy simplicial set -- this is formed as a sparse matrix where each row is a local fuzzy simplicial set, with a membership strength for the 1-simplex to each other data point. Parameters ---------- knn_indices: array of shape (n_samples, n_neighbors) The indices on the ``n_neighbors`` closest points in the dataset. knn_dists: array of shape (n_samples, n_neighbors) The distances to the ``n_neighbors`` closest points in the dataset. sigmas: array of shape(n_samples) The normalization factor derived from the metric tensor approximation. rhos: array of shape(n_samples) The local connectivity adjustment. return_dists: bool (optional, default False) Whether to return the pairwise distance associated with each edge bipartite: bool (optional, default False) Does the nearest neighbour set represent a bipartite graph? That is are the nearest neighbour indices from the same point set as the row indices? Returns ------- rows: array of shape (n_samples * n_neighbors) Row data for the resulting sparse matrix (coo format) cols: array of shape (n_samples * n_neighbors) Column data for the resulting sparse matrix (coo format) vals: array of shape (n_samples * n_neighbors) Entries for the resulting sparse matrix (coo format) dists: array of shape (n_samples * n_neighbors) Distance associated with each entry in the resulting sparse matrix rrrONrjFrQrN)rUr/rTsizeint32rVrXr])rrrr return_dists bipartite n_samplesrorowscolsvalsdistsr)r*rr+r+r,compute_membership_strengths]s.:    $$rc  Cs<|dks|dkr,t||||||| d\}}} |tj}t|t|t| d\}}t||||| \}}}}tjj |||ff|j d|j dfd}| | r| }| |}||||d||}| | dkr|||fS| r(tjj |||ff|j d|j dfd}|| }nd}||||fSdS)aDGiven a set of data X, a neighborhood size, and a measure of distance compute the fuzzy simplicial set (here represented as a fuzzy graph in the form of a sparse matrix) associated to the data. This is done by locally approximating geodesic distance at each point, creating a fuzzy simplicial set for each such point, and then combining all the local fuzzy simplicial sets into a global one via a fuzzy union. Parameters ---------- X: array of shape (n_samples, n_features) The data to be modelled as a fuzzy simplicial set. n_neighbors: int The number of neighbors to use to approximate geodesic distance. Larger numbers induce more global estimates of the manifold that can miss finer detail, while smaller values will focus on fine manifold structure to the detriment of the larger picture. random_state: numpy RandomState or equivalent A state capable being used as a numpy random state. metric: string or function (optional, default 'euclidean') The metric to use to compute distances in high dimensional space. If a string is passed it must match a valid predefined metric. If a general metric is required a function that takes two 1d arrays and returns a float can be provided. For performance purposes it is required that this be a numba jit'd function. Valid string metrics include: * euclidean (or l2) * manhattan (or l1) * cityblock * braycurtis * canberra * chebyshev * correlation * cosine * dice * hamming * jaccard * kulsinski * ll_dirichlet * mahalanobis * matching * minkowski * rogerstanimoto * russellrao * seuclidean * sokalmichener * sokalsneath * sqeuclidean * yule * wminkowski Metrics that take arguments (such as minkowski, mahalanobis etc.) can have arguments passed via the metric_kwds dictionary. At this time care must be taken and dictionary elements must be ordered appropriately; this will hopefully be fixed in the future. metric_kwds: dict (optional, default {}) Arguments to pass on to the metric, such as the ``p`` value for Minkowski distance. knn_indices: array of shape (n_samples, n_neighbors) (optional) If the k-nearest neighbors of each point has already been calculated you can pass them in here to save computation time. This should be an array with the indices of the k-nearest neighbors as a row for each data point. knn_dists: array of shape (n_samples, n_neighbors) (optional) If the k-nearest neighbors of each point has already been calculated you can pass them in here to save computation time. This should be an array with the distances of the k-nearest neighbors as a row for each data point. angular: bool (optional, default False) Whether to use angular/cosine distance for the random projection forest for seeding NN-descent to determine approximate nearest neighbors. set_op_mix_ratio: float (optional, default 1.0) Interpolate between (fuzzy) union and intersection as the set operation used to combine local fuzzy simplicial sets to obtain a global fuzzy simplicial sets. Both fuzzy set operations use the product t-norm. The value of this parameter should be between 0.0 and 1.0; a value of 1.0 will use a pure fuzzy union, while 0.0 will use a pure fuzzy intersection. local_connectivity: int (optional, default 1) The local connectivity required -- i.e. the number of nearest neighbors that should be assumed to be connected at a local level. The higher this value the more connected the manifold becomes locally. In practice this should be not more than the local intrinsic dimension of the manifold. verbose: bool (optional, default False) Whether to report information on the current progress of the algorithm. return_dists: bool or None (optional, default None) Whether to return the pairwise distance associated with each edge. Returns ------- fuzzy_simplicial_set: coo_matrix A fuzzy simplicial set represented as a sparse matrix. The (i, j) entry of the matrix represents the membership strength of the 1-simplex between the ith and jth sample points. NrErbrrUrN)rastyper/rVrifloatrscipysparse coo_matrixrUeliminate_zeros transposemultiplyZmaximumZtodok)r}rorrrprqrrr~set_op_mix_ratiorbZapply_set_operationsrEr_rrrrrrrer prod_matrixdmatr+r+r,fuzzy_simplicial_sets\z        r@c Cst|jdD]n}||}||}||dks:||dkrT||t| 9<q||||kr||t| 9<qdS)a9Under the assumption of categorical distance for the intersecting simplicial set perform a fast intersection. Parameters ---------- rows: array An array of the row of each non-zero in the sparse matrix representation. cols: array An array of the column of each non-zero in the sparse matrix representation. values: array An array of the value of each non-zero in the sparse matrix representation. target: array of shape (n_samples) The categorical labels to use in the intersection. unknown_dist: float (optional, default 1.0) The distance an unknown label (-1) is assumed to be from any point. far_dist float (optional, default 5.0) The distance between unmatched labels. Returns ------- None rrjNrXrUr/r]) rrr5rc unknown_distfar_distnzr)r*r+r+r,fast_intersectionis rc Cs\t|jdD]H}||}||} ||||| f|} ||t||  9<qdS)a)Under the assumption of categorical distance for the intersecting simplicial set perform a fast intersection. Parameters ---------- rows: array An array of the row of each non-zero in the sparse matrix representation. cols: array An array of the column of each non-zero in the sparse matrix representation. values: array of shape An array of the values of each non-zero in the sparse matrix representation. discrete_space: array of shape (n_samples, n_features) The vectors of categorical labels to use in the intersection. metric: numba function The function used to calculate distance over the target array. scale: float A scaling to apply to the metric. Returns ------- None rNr) rrr5discrete_spacerpZ metric_argsscalerr)r*distr+r+r,fast_metric_intersections "r c Cst|}d}t}d}t|D]}d}t|jdD]} |t|| |7}q4t||tkrbq||kr||}||d}q|}|tkr|d9}q||d}qt||S)NrQrNrrRr) r/rSrYrXrUpowr^r\power) Z probabilitiesrartrcrHrJrIrgrGr*r+r+r, reprocess_rows$   rcCsLt|jddD]4}t|||||d|||||d<qdSr.)rXrUr)Zsimplicial_set_indptrZsimplicial_set_datar)r+r+r,reset_local_metricss rcCsXt|dd}|r.|}t|j|j|}|}||}|||}||S)aWReset the local connectivity requirement -- each data sample should have complete confidence in at least one 1-simplex in the simplicial set. We can enforce this by locally rescaling confidences, and then remerging the different local simplicial sets together. Parameters ---------- simplicial_set: sparse matrix The simplicial set for which to recalculate with respect to local connectivity. Returns ------- simplicial_set: sparse_matrix The recalculated simplicial set, now with the local connectivity assumption restored. r4Znorm) r tocsrrindptrdatatocoorrr)simplicial_setZreset_local_metricrrr+r+r,reset_local_connectivitys   rc Csz|}|dk rR|tjkr&tj|}ntdt|j|j|j||t| |nt |j|j|j|||| t |S)aCombine a fuzzy simplicial set with another fuzzy simplicial set generated from discrete metric data using discrete distances. The target data is assumed to be categorical label data (a vector of labels), and this will update the fuzzy simplicial set to respect that label data. TODO: optional category cardinality based weighting of distance Parameters ---------- simplicial_set: sparse matrix The input fuzzy simplicial set. discrete_space: array of shape (n_samples) The categorical labels to use in the intersection. unknown_dist: float (optional, default 1.0) The distance an unknown label (-1) is assumed to be from any point. far_dist: float (optional, default 5.0) The distance between unmatched labels. metric: str (optional, default None) If not None, then use this metric to determine the distance between values. metric_scale: float (optional, default 1.0) If using a custom metric scale the distance values by this value -- this controls the weighting of the intersection. Larger values weight more toward target. Returns ------- simplicial_set: sparse matrix The resulting intersected fuzzy simplicial set. Nz.Discrete intersection metric is not recognized) rrr ValueErrorrrowcolrr&r5rrr)rrrrrp metric_kws metric_scaleZ metric_funcr+r+r,+discrete_metric_simplicial_set_intersections0,     rrmc Cs`|r|}n ||}|}|}tj|j|j|j|j|j|j|j|j|j||d |S)N)Z mix_weightright_complement) rrrZgeneral_sset_intersectionrr6rrr)simplicial_set1simplicial_set2weightrreleftrightr+r+r,#general_simplicial_set_intersectionUs&  rc CsL||}|}|}t|j|j|j|j|j|j|j|j|j |Sr#) rrrZgeneral_sset_unionrr6rrr)rrrerrr+r+r,general_simplicial_set_unionqs  rcCsJdtj|jdtjd}|||}t|||dk||dk<|S)aGiven a set of weights and number of epochs generate the number of epochs per sample for each weight. Parameters ---------- weights: array of shape (n_1_simplices) The weights ofhow much we wish to sample each 1-simplex. n_epochs: int The total number of epochs we want to train for. Returns ------- An array of number of epochs per sample, one for each 1-simplex. grrO)r/ZonesrUZfloat64r4r)weightsn_epochsrerr+r+r,make_epochs_per_samplesr euclideanc8Cs.|}||jd}|jddkr.d}nd}| r>|d7}|dkrJ|}|dkrrd|j|j|jt|k<nd|j|j|jt|k<|t| tr| d kr| j d d |jd|fd  t j }nt| tr<| d krmumu_sumRrad_origrorderT)rrEdensmap densmap_kwds tqdm_kwds move_other)rErrz Computing embedding densitiesrorFr)rErrad_emb)*rZsum_duplicatesrUrr4rrr$struniformrr/rVrabsZnormalr7r3uniquer queryrWrrrrandint INT32_MIN INT32_MAXint64rArrTrXlogZstdrzrrr&r5rr)8rgraph n_componentsZ initial_alphaabgammanegative_sample_raterinitrrrprqrr output_dens output_metricoutput_metric_kwdsZeuclidean_outputrrErZ n_verticesZdefault_epochs embeddingZinitialisationZ expansionZ init_datatreerZindZnndistepochs_per_sampleheadtailr rng_stateaux_datarrror)r*raDrepsilonrrrZ rp_forestZ emb_graphZ emb_sigmasZemb_rhosZ emb_distsrer+r+r,simplicial_set_embeddingsh}                rc Cstj|jd|jdftjd}t|jdD]\}t|jdD]H}t|jdD]4}|||f|||f||||f|f7<qRq@q.|S)aGiven indices and weights and an original embeddings initialize the positions of new points relative to the indices and weights (of their neighbors in the source data). Parameters ---------- indices: array of shape (n_new_samples, n_neighbors) The indices of the neighbors of each new sample weights: array of shape (n_new_samples, n_neighbors) The membership strengths of associated 1-simplices for each of the new samples. embedding: array of shape (n_samples, dim) The original embedding of the source data. Returns ------- new_embedding: array of shape (n_new_samples, dim) An initial embedding of the new sample points. rrrO)r/rTrUrVrX)r6rrrer)r*rhr+r+r,init_transforms  6rc Cstj|jd|jdftjd}t|jdD]}t||j}|dkrTtj||<q.t||}||jD]t}|||fdkr||ddf||ddf<q.t|jdD]0}|||f|||f||||f7<qqlq.|S)aXGiven a bipartite graph representing the 1-simplices and strengths between the new points and the original data set along with an embedding of the original points initialize the positions of new points relative to the strengths (of their neighbors in the source data). If a point is in our original data set it embeds at the original points coordinates. If a point has no neighbours in our original dataset it embeds as the np.nan vector. Otherwise a point is the weighted average of it's neighbours embedding locations. Parameters ---------- graph: csr_matrix (n_new_samples, n_samples) A matrix indicating the the 1-simplices and their associated strengths. These strengths should be values between zero and one and not normalized. One indicating that the new point was identical to one of our original points. embedding: array of shape (n_samples, dim) The original embedding of the source data. Returns ------- new_embedding: array of shape (n_new_samples, dim) An initial embedding of the new sample points. rrrON) r/rTrUrVrXr3r6nansum)rrreZ row_indexZnum_neighboursZrow_sumZ col_indexrhr+r+r,init_graph_transform s     rc Cst||jdD]}d}t|jdD]T}t|jdD]@}|||f|kr8|d7}|||f||||f|f7<q8q&t|jdD]}|||f|<qqdSr.)rXrU)Z current_initZn_original_samplesr6r)rgr*rhr+r+r, init_update5s(rcCsvdd}td|dd}t|j}d|||k<t|||k| ||||k<t|||\}}|d|dfS)zFit a, b params for the differentiable curve used in lower dimensional fuzzy simplicial complex construction. We want the smooth curve (from a pre-defined family with simple gradient) that best matches an offset exponential decay. cSsdd||d|S)NrNrr+)xrrr+r+r,curveKszfind_ab_params..curverri,rNr)r/ZlinspacerTrUr]r)spreadmin_distr ZxvZyvparamsZcovarr+r+r,find_ab_paramsDs  $r c'@seZdZdZd1ddZddZd2ddZddZddZdd Z d!d"Z d3d#d$Z d%d&Z d4d'd(Z d)d*Zd+d,Zd-d.Zd/d0ZdS)5UMAPaF/Uniform Manifold Approximation and Projection Finds a low dimensional embedding of the data that approximates an underlying manifold. Parameters ---------- n_neighbors: float (optional, default 15) The size of local neighborhood (in terms of number of neighboring sample points) used for manifold approximation. Larger values result in more global views of the manifold, while smaller values result in more local data being preserved. In general values should be in the range 2 to 100. n_components: int (optional, default 2) The dimension of the space to embed into. This defaults to 2 to provide easy visualization, but can reasonably be set to any integer value in the range 2 to 100. metric: string or function (optional, default 'euclidean') The metric to use to compute distances in high dimensional space. If a string is passed it must match a valid predefined metric. If a general metric is required a function that takes two 1d arrays and returns a float can be provided. For performance purposes it is required that this be a numba jit'd function. Valid string metrics include: * euclidean * manhattan * chebyshev * minkowski * canberra * braycurtis * mahalanobis * wminkowski * seuclidean * cosine * correlation * haversine * hamming * jaccard * dice * russelrao * kulsinski * ll_dirichlet * hellinger * rogerstanimoto * sokalmichener * sokalsneath * yule Metrics that take arguments (such as minkowski, mahalanobis etc.) can have arguments passed via the metric_kwds dictionary. At this time care must be taken and dictionary elements must be ordered appropriately; this will hopefully be fixed in the future. n_epochs: int (optional, default None) The number of training epochs to be used in optimizing the low dimensional embedding. Larger values result in more accurate embeddings. If None is specified a value will be selected based on the size of the input dataset (200 for large datasets, 500 for small). learning_rate: float (optional, default 1.0) The initial learning rate for the embedding optimization. init: string (optional, default 'spectral') How to initialize the low dimensional embedding. Options are: * 'spectral': use a spectral embedding of the fuzzy 1-skeleton * 'random': assign initial embedding positions at random. * A numpy array of initial embedding positions. min_dist: float (optional, default 0.1) The effective minimum distance between embedded points. Smaller values will result in a more clustered/clumped embedding where nearby points on the manifold are drawn closer together, while larger values will result on a more even dispersal of points. The value should be set relative to the ``spread`` value, which determines the scale at which embedded points will be spread out. spread: float (optional, default 1.0) The effective scale of embedded points. In combination with ``min_dist`` this determines how clustered/clumped the embedded points are. low_memory: bool (optional, default True) For some datasets the nearest neighbor computation can consume a lot of memory. If you find that UMAP is failing due to memory constraints consider setting this option to True. This approach is more computationally expensive, but avoids excessive memory use. set_op_mix_ratio: float (optional, default 1.0) Interpolate between (fuzzy) union and intersection as the set operation used to combine local fuzzy simplicial sets to obtain a global fuzzy simplicial sets. Both fuzzy set operations use the product t-norm. The value of this parameter should be between 0.0 and 1.0; a value of 1.0 will use a pure fuzzy union, while 0.0 will use a pure fuzzy intersection. local_connectivity: int (optional, default 1) The local connectivity required -- i.e. the number of nearest neighbors that should be assumed to be connected at a local level. The higher this value the more connected the manifold becomes locally. In practice this should be not more than the local intrinsic dimension of the manifold. repulsion_strength: float (optional, default 1.0) Weighting applied to negative samples in low dimensional embedding optimization. Values higher than one will result in greater weight being given to negative samples. negative_sample_rate: int (optional, default 5) The number of negative samples to select per positive sample in the optimization process. Increasing this value will result in greater repulsive force being applied, greater optimization cost, but slightly more accuracy. transform_queue_size: float (optional, default 4.0) For transform operations (embedding new points using a trained model_ this will control how aggressively to search for nearest neighbors. Larger values will result in slower performance but more accurate nearest neighbor evaluation. a: float (optional, default None) More specific parameters controlling the embedding. If None these values are set automatically as determined by ``min_dist`` and ``spread``. b: float (optional, default None) More specific parameters controlling the embedding. If None these values are set automatically as determined by ``min_dist`` and ``spread``. 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`. metric_kwds: dict (optional, default None) Arguments to pass on to the metric, such as the ``p`` value for Minkowski distance. If None then no arguments are passed on. angular_rp_forest: bool (optional, default False) Whether to use an angular random projection forest to initialise the approximate nearest neighbor search. This can be faster, but is mostly on useful for metric that use an angular style distance such as cosine, correlation etc. In the case of those metrics angular forests will be chosen automatically. target_n_neighbors: int (optional, default -1) The number of nearest neighbors to use to construct the target simplcial set. If set to -1 use the ``n_neighbors`` value. target_metric: string or callable (optional, default 'categorical') The metric used to measure distance for a target array is using supervised dimension reduction. By default this is 'categorical' which will measure distance in terms of whether categories match or are different. Furthermore, if semi-supervised is required target values of -1 will be trated as unlabelled under the 'categorical' metric. If the target array takes continuous values (e.g. for a regression problem) then metric of 'l1' or 'l2' is probably more appropriate. target_metric_kwds: dict (optional, default None) Keyword argument to pass to the target metric when performing supervised dimension reduction. If None then no arguments are passed on. target_weight: float (optional, default 0.5) weighting factor between data topology and target topology. A value of 0.0 weights predominantly on data, a value of 1.0 places a strong emphasis on target. The default of 0.5 balances the weighting equally between data and target. transform_seed: int (optional, default 42) Random seed used for the stochastic aspects of the transform operation. This ensures consistency in transform operations. verbose: bool (optional, default False) Controls verbosity of logging. tqdm_kwds: dict (optional, defaul None) Key word arguments to be used by the tqdm progress bar. unique: bool (optional, default False) Controls if the rows of your data should be uniqued before being embedded. If you have more duplicates than you have n_neighbour you can have the identical data points lying in different regions of your space. It also violates the definition of a metric. For to map from internal structures back to your data use the variable _unique_inverse_. densmap: bool (optional, default False) Specifies whether the density-augmented objective of densMAP should be used for optimization. Turning on this option generates an embedding where the local densities are encouraged to be correlated with those in the original space. Parameters below with the prefix 'dens' further control the behavior of this extension. dens_lambda: float (optional, default 2.0) Controls the regularization weight of the density correlation term in densMAP. Higher values prioritize density preservation over the UMAP objective, and vice versa for values closer to zero. Setting this parameter to zero is equivalent to running the original UMAP algorithm. dens_frac: float (optional, default 0.3) Controls the fraction of epochs (between 0 and 1) where the density-augmented objective is used in densMAP. The first (1 - dens_frac) fraction of epochs optimize the original UMAP objective before introducing the density correlation term. dens_var_shift: float (optional, default 0.1) A small constant added to the variance of local radii in the embedding when calculating the density correlation objective to prevent numerical instability from dividing by a small number output_dens: float (optional, default False) Determines whether the local radii of the final embedding (an inverse measure of local density) are computed and returned in addition to the embedding. If set to True, local radii of the original data are also included in the output for comparison; the output is a tuple (embedding, original local radii, embedding local radii). This option can also be used when densmap=False to calculate the densities for UMAP embeddings. disconnection_distance: float (optional, default np.inf or maximal value for bounded distances) Disconnect any vertices of distance greater than or equal to disconnection_distance when approximating the manifold via our k-nn graph. This is particularly useful in the case that you have a bounded metric. The UMAP assumption that we have a connected manifold can be problematic when you have points that are maximally different from all the rest of your data. The connected manifold assumption will make such points have perfect similarity to a random set of other points. Too many such points will artificially connect your space. precomputed_knn: tuple (optional, default (None,None,None)) If the k-nearest neighbors of each point has already been calculated you can pass them in here to save computation time. The number of nearest neighbors in the precomputed_knn must be greater or equal to the n_neighbors parameter. This should be a tuple containing the output of the nearest_neighbors() function or attributes from a previously fit UMAP object; (knn_indices, knn_dists,knn_search_index). rrrNrNrr@Trjrl@F categoricalrm*rrR333333?NNNc((Cs||_||_||_||_||_||_||_| |_||_||_ ||_ | |_ | |_ | |_ ||_||_||_||_||_||_||_||_||_||_||_||_||_||_||_| |_|!|_|"|_|#|_|$|_ |%|_!|&|_"|'|_#| |_$||_%||_&dSr#)'rorpr target_metricrqrrrrrepulsion_strength learning_rater r rurrbrrrangular_rp_foresttransform_queue_sizetarget_n_neighborstarget_metric_kwds target_weighttransform_seedtransform_modeforce_approximation_algorithmrErrr dens_lambda dens_fracdens_var_shiftrrDprecomputed_knnrvrr)(selfrorrprqrrrrrr r rurvrrbrrrrrrrrrrrrrrrrErrrrr r!rrDr"r+r+r,__init__BsP*z UMAP.__init__cs|jdks|jdkrtd|jdkr.td|j|jkrBtd|jdkrTtdt|jtsvt|jtj svtdt|jtr|jdkrtd t|jtj r|jj d |j krtd t|j tst |j std |jd krtd|jdkrtd|jdkrtd|jdkr2|jdkr2tdt|j tst|j trVtd|j d d krntdzt|j |_ Wntk rtdYnX|j d krtd|jdk r|jd kst|jtstd|jdkri|_n|j|_|jdkri|_n|j|_|jdkr,i|_n|j|_tj|jrLd|_nd|_t |j r||j |j|j}|r|j t j!ddfdd}||_"|j |_#n|j |_"d|_#t$dn`|j dkr|j%rtdt$d |j |_"d|_#n*|j d!kr|j&d krtd"n|j t'j(kr|jrd|j tj)krRtj)|j |_"ntd#*|j nt'j(|j |_"zt'j+|j |_#Wn,t,k rt$d$*|j d|_#YnXnl|j t-kr|jr|j t.krt.|j |_"ntd#*|j n t-|j |_"t$d$*|j d|_#ntd%t |j/rV||j/|j}|rL|j/|_0ntd&n\|j/dkrltd'nF|j/t'j+krt'j+|j/|_0n(|j/t'j(krtd(*|j/ntd)|j d*krd|_1|j2dks|j2d krtd+|j3dkrtd,|j4dks|j4dkrtd-|j5dkr,td.|j6r:|j3nd|j6rJ|j4nd|j5|jd/|_7|j6rx|j/d0krxtd1|j8dkrt9:|j tj;|_dkri|_>nt|j>t?dkrtd3d4|j>kr d5|j>d4<d6|j>kr$d7}||j>d6<t@|d8r~|jAdk r~|j%rLtd9t|jBtj sdtd:t|jAtj s|td;|jAj |jBj krtd<t|jCtDstd=|jAj d |jkrt$d>d|_Bd|_Ad|_Cn|jAj d |jj d krt$d?d|_Bd|_Ad|_Cnl|jAj d d@kr6|jEs6t$dAnH|jAj d |jkr~|jBddd|jf|_B|jAddd|jf|_AdS)BNrQrNz,set_op_mix_ratio must be between 0.0 and 1.0z%repulsion_strength cannot be negativez-min_dist must be less than or equal to spreadzmin_dist cannot be negativez init must be a string or ndarray)rrz1string init values must be "spectral" or "random"rz*init ndarray must match n_components valuez!metric must be string or callablerz%negative sample rate must be positivezlearning_rate must be positiverz"n_neighbors must be greater than 1rjz)target_n_neighbors must be greater than 1zn_components must be an intz#n_components must be a whole numberz#n_components must be greater than 0z&n_epochs must be a nonnegative integerTFrLcs||f|dSNrr+rykwds_mr+r, _dist_onlysz-UMAP._validate_parameters.._dist_onlyzcustom distance metric does not return gradient; inverse_transform will be unavailable. To enable using inverse_transform method, define a distance function that returns a tuple of (distance [float], gradient [np.array])rkz0unique is poorly defined on a precomputed metricz?using precomputed metric; inverse_transform will be unavailabler z3Metric 'hellinger' does not support negative valuesz*Metric {} is not supported for sparse datazfgradient function is not yet implemented for {} distance metric; inverse_transform will be unavailablez2metric is neither callable nor a recognised stringzScustom output_metric must return a tuple of (distance [float], gradient [np.array])z&output_metric cannnot be 'precomputed'z0gradient function is not yet implemented for {}.z9output_metric is neither callable nor a recognised string)rrr"r!Z ll_dirichletr z7n_jobs must be a postive integer, or -1 (for all cores)zdens_lambda cannot be negativez%dens_frac must be between 0.0 and 1.0z!dens_var_shift cannot be negativelambdafracZ var_shiftrorl2z6Non-Euclidean output metric not supported for densMAP.z8disconnection_distance must either be None or a numeric.ztqdm_kwds must be a dictionary. Please provide valid tqdm parameters as key value pairs. Valid tqdm parameters can be found here: https://github.com/tqdm/tqdm#parametersdesczEpochs completedZ bar_formatzA{desc}: {percentage:3.0f}%| {bar} {n_fmt}/{total_fmt} [{elapsed}]rz6unique is not currently available for precomputed_knn.z*precomputed_knn[0] must be ndarray object.z*precomputed_knn[1] must be ndarray object.zPprecomputed_knn[0] and precomputed_knn[1] must be numpy arrays of the same size.zBprecomputed_knn[2] (knn_search_index) must be an NNDescent object.zprecomputed_knn has a lower number of neighbors than n_neighbors parameter. precomputed_knn will be ignored and the k-nn will be computed normally.zprecomputed_knn has a different number of samples than the data you are fitting. precomputed_knn will be ignored andthe k-nn will be computed normally.zprecomputed_knn is meant for large datasets. Since your data is small, precomputed_knn will be ignored and the k-nn will be computed normally.)Frrrr r r$rrr/ndarrayrUrrpcallabler_initial_alpharorrZrrq _metric_kwdsr_output_metric_kwdsr_target_metric_kwdsrrZisspmatrix_csr _raw_data _sparse_data_check_custom_metricnumbanjit_input_distance_func_inverse_distance_funcrrrzrrrformatnamed_distances_with_gradientsKeyErrorpynn_named_distancespynn_sparse_named_distancesr_output_distance_funcrrvrr r!r _densmap_kwdsrDDISCONNECTION_DISTANCESgetr0_disconnection_distancerrdicthasattrrrrrr)r#Zin_returns_gradr,Zout_returns_gradZbar_fr+r*r,_validate_parameterss                                        zUMAP._validate_parameterscCs|dk r(|tjd|jdd\}}ntjjddd|jfd\}}tj|rl||j |j |j |j f|}n|||f|}t |dot |dkS)Nrrirr__iter__) r/rrrUrrrrissparser6rrLr3)r#rpr)rrr(Z metric_outr+r+r,r<s  zUMAP._check_custom_metriccGstdd|D|_tdd|D|_tdd|D|_tdd|D|_tdd|D|_tdd|jDr~d|_tdd|D|_td d|D|_td d|D|_ td d|D|_ td d|D|_ td d|D|_ tdd|D|_ tdd|D|_tdd|D|_tdd|D|_tdd|D|_tdd|D|_tdd|D|_tdd|D|_tdd|D|_tdd|D|_tdd|D|_tdd|D|_tdd|D|_tdd|D|_tdd|D|_tdd|D|_tdd|D|_tdd|D|_td d|D|_td!d|D|_ td"d|D|_!td#d|D|_"td$d|D|_#td%d|D|_$dS)&NcSsg|] }|jqSr+)ro.0mr+r+r, sz2UMAP._populate_combined_params..cSsg|] }|jqSr+)rprPr+r+r,rSscSsg|] }|jqSr+)rqrPr+r+r,rSscSsg|] }|jqSr+)rrPr+r+r,rSscSs g|]}|jdk r|jndqS)Nrj)rrPr+r+r,rSscSsg|] }|dkqS)rjr+)rQrr+r+r,rSscSsg|] }|jqSr+)rrPr+r+r,rSscSsg|] }|jqSr+)rrPr+r+r,rSscSsg|] }|jqSr+)rrPr+r+r,rSscSsg|] }|jqSr+)rrPr+r+r,rSscSsg|] }|jqSr+)r rPr+r+r,rSscSsg|] }|jqSr+)r rPr+r+r,rSscSsg|] }|jqSr+)rurPr+r+r,rSscSsg|] }|jqSr+)rrPr+r+r,rSscSsg|] }|jqSr+rrPr+r+r,rSscSsg|] }|jqSr+)rrPr+r+r,rSscSsg|] }|jqSr+)rrrPr+r+r,rSscSsg|] }|jqSr+)rrPr+r+r,rSscSsg|] }|jqSr+)rrPr+r+r,rSscSsg|] }|jqSr+)rrPr+r+r,rSscSsg|] }|jqSr+)rrPr+r+r,rSscSsg|] }|jqSr+)rrPr+r+r,rSscSsg|] }|jqSr+)rrPr+r+r,rSscSsg|] }|jqSr+)rrPr+r+r,rSscSsg|] }|jqSr+)rrPr+r+r,rSscSsg|] }|jqSr+rrPr+r+r,rSscSsg|] }|jqSr+)rrPr+r+r,rSscSsg|] }|jqSr+)rrPr+r+r,rSscSsg|] }|jqSr+)rrPr+r+r,rSscSsg|] }|jqSr+)r rPr+r+r,rSscSsg|] }|jqSr+)r!rPr+r+r,rSscSsg|] }|jqSr+)rrPr+r+r,rSscSsg|] }|jqSr+)rrPr+r+r,rSscSsg|] }|jqSr+)rrPr+r+r,rSscSsg|] }|jqSr+)_arPr+r+r,rSscSsg|] }|jqSr+)_brPr+r+r,rSs)%r-rorprqrrallrrrrr r rurrbrrrrrrrrrrrrErrrr r!rrrrTrU)r#modelsr+r+r,_populate_combined_paramssR  zUMAP._populate_combined_paramscCst|dgddt|dgdd|jjd|jjdkr@tdt}|||t|j|jd|_t|jd|_tj j |jddkrt d d }nd }t |j|_t |j|_t |jt |jt |jt |jd |_|jdkrd}n t |j}td|jt |jt |jt |jt |jt |jt |j ||t!d di|j|j|jdt"t |j#|j$d\|_%}|jr|d|_&|d|_'|S)Ngraph_'Only fitted UMAP models can be combinedZ attributesmsgr7Only models with the equivalent samples can be combinedrmTrzqCombined graph is not connected but multi-component layout is unsupported. Falling back to random initialization.rrr-rrFrrErrr(rrYrUrrrXrrrrcsgraphconnected_componentsrr/anyrrr4rr r!rorGrrrzrrrWrTrUrrrboolrEr embedding_ rad_orig_rad_emb_r#otherrerrrr+r+r,__mul__sz                z UMAP.__mul__cCst|dgddt|dgdd|jjd|jjdkr@tdt}|||t|j|j|_t|jd|_tj j |jddkrt dd }nd }t |j|_t |j|_t |jt |jt |jt |jd |_|jdkrd}n t |j}td|jt |jt |jt |jt |jt |jt |j ||t!d d i|j|j|jdt"t |j#|j$d\|_%}|jr|d|_&|d|_'|S)NrYrZr[rr]TrpCombined graph is not connected but mult-component layout is unsupported. Falling back to random initialization.rrr-rrFr^rr)(rrYrUrrrXrrrrr`rarr/rbrrr4rr r!rorGrrrzrrrWrTrUrrrrcrErrdrerfrgr+r+r,__add__;sr                z UMAP.__add__cCst|dgddt|dgdd|jjd|jjdkr@tdt}|||t|j|jddd|_t|jd |_tj j |jdd krt d d }nd }t |j|_t |j|_t |jt |jt |jt |jd|_|jdkrd}n t |j}td|jt |jt |jt |jt |jt |jt |j ||t!ddi|j|j|jd t"t |j#|j$d\|_%}|jr|d|_&|d|_'|S)NrYrZr[rr]rmT)rrFrrjrrr-rrr^rrr_rgr+r+r,__sub__s|                z UMAP.__sub__c Cs( t|tjddd}||_|jdks,|jdkrDt|j|j\|_ |_ n|j|_ |j|_ t |j tj rvt|j tjdd}n|j }|j|_|jd|_|jd|_|jd |_||jrtt|t|_|jdkr|jdk rt|j|jr||jr t|\}}}n"tj|d d d dd dd \}}}|jrttd |j dd||j dt!|}td||d||||_"n$t#t$|j d}t#t$|j d}||j d|j%kr||j ddkrt&d|j'f|_(|St)d||j dd|_*|j+r|j*|j,d<n|j%|_*|jr2|j-s2|.t/|j0}|jrPtt1d|j2dkr"|jr"t3|4t5|4krt6dt7|8dkst6d|jdkrVtj&|j d|j%ftj9d|_:tj&|j:j tj;d|_} t?| |j*kr t6dt@| d|j*} | | |j:| <| | |j<| <qn|j|_:|j|_<|j<|jAk} d|j:| <tjB|j<| <| C}tD|||j%|d|jE|j:|j<|jF|jG|jHd |j|j+p|jI \|_J|_K|_L|_MtCtN|jJjCddOdk}tP|||jA|jj d|jdn||j ddkr|jQsd |_Rz2|jrT|j2n|jS}tT||fd|i|jE}Wnt6tUfk r }zr|jrtV|j2stWjX|j2}tWjY||Z||jEd}ntWjY|||jS|jEd}ntWjY|||jS|jEd}W5d}~XYnXtC||jAk}tjB|||jAk<tD||j*|d|jEdd|jF|jG|jHd |j|j+p`|jI \|_J|_K|_L|_MtCtN|jJjCddOdk}tP|||jA|jj d|jdnZd|_R|jr|j2t[kr|j2}n"|js|j2t\kr|j2}n|jS}|jdkrBt]|||j*||jE|jF||j^d |j|jd \|_:|_<|__n|j|_:|j|_<|j|__|j<|jAk} d|j:| <tjB|j<| <| C}tD|||j%|||jE|j:|j<|jF|jG|jHd |j|j+p|jI \|_J|_K|_L|_MtCtN|jJjCddOdk}tP|||jA|jj d|jd|dk r$|js,t?|n|j d}|t?|krZt6d j`|t?|d!|jad"krp||}nt|dd#|}|jad$kr|jbd%krd&d%d%|jb}nd'}tc|jJ||d(|_JnV|jatWjdkr |jbd%krd&d%d%|jb}nd'}tWe||ja}tc|jJ||ja||d)|_Jnt?|j dkr<|fdd}|jgdkrP|j*}n|jg}|j ddkrztT|fd|jai|jh}Wn.tUt6fk rtWjY||ja|jhd}YnXtD|||d|jhdddd%d%d \}}}n&tD||||ja|jhdddd%d%d \}}}ti|jJ||jb|_Jtj|jJ|_Jd |_knd|_k|j+ s:|jI rF|jM|j,d*<|j rZtt1d+|jld,k r|m|j||jn||\|_(}tN|jJjCddOdk}t?|dk rto|j'tjp|j(|<|j(||_(|jI r|d-||_q|d.||_r|j r tt1d/t|jtst|j|_u|S)0aFit X into an embedded space. Optionally use y for supervised dimension reduction. Parameters ---------- X : array, shape (n_samples, n_features) or (n_samples, n_samples) If the metric is 'precomputed' X must be a square distance matrix. Otherwise it contains a sample per row. If the method is 'exact', X may be a sparse matrix of type 'csr', 'csc' or 'coo'. y : array, shape (n_samples) A target array for supervised dimension reduction. How this is handled is determined by parameters UMAP was instantiated with. The relevant attributes are ``target_metric`` and ``target_metric_kwds``. csrrrP accept_sparserNF)rProrrrT)Z return_indexZreturn_inverseZ return_countsrz2Unique=True -> Number of data points reduced from z to zMost common duplicate isz with a count of zIn_neighbors is larger than the dataset size; truncating to X.shape[0] - 1rozConstruct fuzzy simplicial setrkz;Sparse precomputed distance matrices should be symmetrical!z.Non-zero distances from samples to themselves!rOz3Some rows contain fewer than n_neighbors distances!rjrrr3rprpr)rrvrEzELength of x = {len_x}, length of y = {len_y}, while it must be equal.)Zlen_xZlen_ystring)Z ensure_2drrNg@gmB)r)rprrrzConstruct embeddingrrrz Finished embedding)vrr/rVr:rrr r r rTrUr$rr4rr6r"rrrrMrErArr=Zget_num_threadsZ_original_n_threadsrvZset_num_threadsrr;rrUZargmaxZ_unique_inverse_r%rXrorTrrdr _n_neighborsrrGZhas_sorted_indicesZ sort_indicesrrrrrp sparse_trilZgetnnz sparse_triurrVZdiagonalrZ _knn_indicesr _knn_distsrr6r3argsortrJr0rrr7rrrbrrY_sigmas_rhosZ graph_dists_r7flattenrFr _small_datar?r TypeErrorr5rrpairwise_special_metrictoarrayrErDrru_knn_search_indexrArrrZDISCRETE_METRICSZget_discrete_paramsreshaperr9rr _supervisedr_fit_embed_datarfullrrerfr hash _input_hash) r#r}r(rrfZinversecounts most_commonrrZrow_idrow_dataZ row_indicesZrow_nn_data_indicesrrBrCr+re nn_metricZlen_XZy_rrrrZydmatZ target_graphZ target_sigmasZ target_rhosrZdisconnected_verticesr+r+r,fits                                                       zUMAP.fitcCs`t||j|j|j|j|j|j|j||||j|j |j |j |j |j |j|jdk|jdk|j|jdS)zbA method wrapper for simplicial_set_embedding that can be replaced by subclasses. r0Nr)rrYrr6rTrUrrr?r7rrGrrFr8rrrrEr)r#r}rrrrr+r+r,r s0zUMAP._fit_embed_datacCsX||||jdkr4|jr,|j|j|jfS|jSn |jdkrD|jStd|jdS)aeFit X into an embedded space and return that transformed output. Parameters ---------- X : array, shape (n_samples, n_features) or (n_samples, n_samples) If the metric is 'precomputed' X must be a square distance matrix. Otherwise it contains a sample per row. y : array, shape (n_samples) A target array for supervised dimension reduction. How this is handled is determined by parameters UMAP was instantiated with. The relevant attributes are ``target_metric`` and ``target_metric_kwds``. Returns ------- X_new : array, shape (n_samples, n_components) Embedding of the training data in low-dimensional space. or a tuple (X_new, r_orig, r_emb) if ``output_dens`` flag is set, which additionally includes: r_orig: array, shape (n_samples) Local radii of data points in the original data space (log-transformed). r_emb: array, shape (n_samples) Local radii of data points in the embedding (log-transformed). rrGUnrecognized transform mode {}; should be one of 'embedding' or 'graph'N) rrrrdrerfrYrrA)r#r}r(r+r+r, fit_transform s   zUMAP.fit_transformcCs(|jjddkrtdt|tjddd}t|}||jkrn|j dkrN|j S|j dkr^|j Std |j |j r|td t|j}|ttd tj}|jd krtd |jd|jjdksttj|rtj|jd|jftjdd}tj|tjdd}t |jdD]p}t!||j"}t#||jkrLtd|j$d||j%|d|j||<||j"|d|j||<qn8tj!|ddddd|jftj}tj&||dd}t'|dkrt'|dks2tnH|j(rz2|j)r|jn|j*} t+||jfd| i|j,} Wnt-tfk r|j)rt.|jszt/j0|j} t/j1|2|j2| |j,d} nt/j1||j|j*|j,d} nt/j1||j|j*|j,d} YnXt3| |jddd|jf}t4| ||j} t!| } t4|| |j}t4| | |j}n*|j5j6rdnd} |j5j7||j$| d\}}|jtjdd}d|||j8k<t9d|j:d}t;|t<|jt<|d\}}t=||||dd\}}}}tjj>|||ff|jd|jjdfd}|j dkr|S|?}|@tA||j }|jBdkr|jdd krd!}nd"}ntC|jBd#}d|j"|j"|j"9t<|k<|@tD|j"|}|jE}|jF}|j"}|jGd$krtH||j jtjdd%||||jd||jI|jJ||jK|jLd&|jM|jNdk|jO|jPd'}n\tQ||j jtjdd%||||jd||jI|jJ||jK|jLd&|jM|jRtS|jTU|jO|jPd'}|S)(ayTransform X into the existing embedded space and return that transformed output. Parameters ---------- X : array, shape (n_samples, n_features) New data to be transformed. Returns ------- X_new : array, shape (n_samples, n_components) Embedding of the new data in low-dimensional space. rrzHTransform unavailable when model was fit with only a single data sample.rmrrnrrrzGTransforming data into an existing embedding not supported for densMAP.rrka?Transforming new data with precomputed metric. We are assuming the input data is a matrix of distances from the new points to the points in the training set. If the input matrix is sparse, it should contain distances from the new points to their nearest neighbours or approximate nearest neighbours in the training set.rj)rPZ fill_valuezNeed at least n_neighbors (z) distances for each row!NrrQrprqgQ?gQ?)rrrNrT)rrrd@r)ryrrEr)Vr:rUrrr/rVr rrrrdrYrArNotImplementedErrorrrrrrrrrprAssertionErrorrrrOrrtrZ full_likerXryrr3ror6Ztake_along_axisrzr}r;r?r r7r~r5rrrrZ argpartitionrrZ_angular_treesrrJr4rbrirrrrrrrrZrrrrrrTrUrr6rrrrErrrFr&r8r5)r#r}Zx_hashrrrr6rr)Z data_indicesr+rZdmat_shortenedZindices_sortedrZadjusted_local_connectivityrrrrrr csr_graphrrrrrrr+r+r, transform sF       "((                zUMAP.transformcs jrtdnJ jdkr$tdn6 jr4tdn& jdkrHtdn jdkrZtdttj d d t j }| t td tj}tjj jd d d}|j|}tjj jjd jjdftdtd|jjdD]\}|j|D]L}| jjdkr|j||j| jjdkd|f<d|f<qqtjt jjd jjd  fdd|D t j r j t!j"d dfdd}|n0 j t#j$%krt#j$ j ntd& j t' j() fddt*jdDt+ fddDt+fddt*t,Dt+ fddt*t, Dt+ fddt*jdDj-\} } dd j.d j/} tjj0| | | ffjd jjdfd} t1| 2d d!} | j34jd }| j54jd } t6|| j} j7dkrN| jdd"krHd#}nd$}nt j7d%}t8| j5|}| j9}| j:}| j5}t;| j||| j< j=|| jd| j. j/| j> j?d& j@ jt' jA) jB jCd'}|S)(aTransform X in the existing embedded space back into the input data space and return that transformed output. Parameters ---------- X : array, shape (n_samples, n_components) New points to be inverse transformed. Returns ------- X_new : array, shape (n_samples, n_features) Generated data points new data in data space. z1Inverse transform not available for sparse input.Nz1Inverse transform not available for given metric.z,Inverse transform not available for densMAP.zInverse transform works best with low dimensional embeddings. Results may be poor, or this approach to inverse transform may fail altogether! If you need a high dimensional latent space and inverse transform operations consider using an autoencoder.rz.r%cs||f|dSr&r+r')_out_mr+r,_output_dist_only sz1UMAP.inverse_transform.._output_dist_onlyzUnrecognized output metric: {}c s0g|](tfddDqS)cs&g|]}j|fqSr+)rd)rQnb)r} dist_argsdist_only_funcr)r#r+r,rS sz5UMAP.inverse_transform...)r/r7)rQ)r}rr neighborhoodr#)r)r,rS s csg|]}t|dqSr#)r/ry)rQrrr+r,rS scsg|]}||qSr+r+rQr))r`idxr+r,rS scsg|]}||qSr+r+r)rrr+r,rS scs4g|],}tD]}|||f||fgqqSr+)rX)rQr)r*)dists_output_spacer6r:r+r,rS s rrl1rrrrrrr)Dr;rr@rrrrrr/rVrrrrrrrrZspatialZDelaunayrdZ simplicesZ find_simplexrZ lil_matrixrUrZrxZ csr_matrixrzr:r5rr=r>rrkeysrAr&r8r5rXr7r3TrTrUrr rr6rrrrrrrrrzr{rr6rr7rEr)r#r}rrrZdeltrir>r)r*rrrrrrZindsZinv_transformed_pointsrrrrrr+) r}rr8rrr`rrr6r:rr#r,inverse_transform s               "      zUMAP.inverse_transformc Cst|tjddd}t|j}|ttdtj }|j j d}|j dkrPt d|jr^t d|jr2|jrtj|j |g|_ nt|j |g|_ |j j dd krz.|jr|j n|j}t|j fd |i|j}Wnt tfk rd}zl|jr>t|j s&tj|j }tj|j ||jd }ntj|j |j|jd }ntj|j |j|jd }W5d}~XYnXt||j|d|jdd|j|j |j!d |j" \|_#|_$|_%t&|ddd|j'f}nd |_|jr|j t(kr|j } n"|js|j t)kr|j } n|j} t*|j |j| |j|j||j+d |j,|j"d \|_-|_.|_/t|j |j'|| |j|j-|j.|j|j |j!d |j" \|_#|_$|_%|j-}tj0|j j d|j1ftjd} |j2| d|<t3| |||j4dkrd} n|j4} t5|j |j#|j1|j6|j7|j8|j9|j:| | ||j|j|j;|j<|j=|j>|j?|j@dk|jAdk|j"|jBd\|_2} nd|j/C|j/D||j/j |_ |j/jE\|_-|_.|jr~|j t(kr~|j } n"|js|j t)kr|j } n|j} t|j |j'|| |j|j-|j.|j|j |j!d |j" \|_#|_$|_%tj0|j j d|j1ftjd} |j2| d|<t3| ||j-|j4dkr(d} n|j4} t5|j |j#|j1|j6|j7|j8|j9|j:| | ||j|j|j;|j<|j=|j>|j?|j@dk|jAdk|j"|jBd\|_2} |j=r| d|_F| d|_GdS)Nrmrrnrrrkz5Update does not currently support precomputed metricsz5Updating supervised models is not currently supportedr3rprqTFrrrOr0rrr)Hrr/rVrrrrrrrr:rUrprrr}r;rrZvstackr?r r7r~r5rrrrrrtrrrbrErYrzr{ryrorErDrrurvrwrxrrTrrdrrrr6rTrUrrrrGrrFr8rrrrprepareupdater|rerf) r#r}rrrZ original_sizer+rrrrrrrr+r+r,r_ sx              z UMAP.updatecCsnddlm}ddl}|ddddd}d|_||}|jdd||jd }|jd d ||jd }|d d |}|S)Nr)_EstimatorPrettyPrinterTr2)compactindentZindent_at_nameZn_max_elements_to_showztqdm_kwds={.*},)flagsz *  z, +z, )Zsklearn.utils._pprintrrZ _changed_onlypformatsubS)r#rrpprepr_r+r+r,__repr__8 s  z UMAP.__repr__)'rrrNrNNrNrr@rNTrjrNrNrNrlrNNNFrjrNrmrrFFNFFrRrr@FNr)N)N)N)__name__ __module__ __qualname____doc__r$rMr<rXrirkrlrrrrrrrr+r+r+r,rVs~n W 1HFH S -U)Zr)r@F)rMrNrN)TTrjF)FF)rNr)rr)F)rmF)cZ __future__rlocalewarningsrtimeZscipy.optimizerZ sklearn.baserZ sklearn.utilsrrZsklearn.utils.validationrZsklearn.metricsr Zsklearn.preprocessingr Zsklearn.neighborsr r ImportErrorZsklearn.externalsZnumpyr/Z scipy.sparserr rurrvZscipy.sparse.csgraphr=Zumap.distancesr`rZ umap.sparserZ umap.utilsrrrrZ umap.spectralrZ umap.layoutsrrrZ pynndescentrZpynndescent.distancesrrDZpynndescent.sparserrE setlocale LC_NUMERICZiinforrzrr4rr\r_r0rYrHr'r-r?rFr>typesrVrirrrrZjitrrrrrrrrrBrrrrr rr+r+r+r,s                  ! o _ V 2 * *  " O ' O ,