Carry out dimensionality reduction of a dataset using a method similar to LargeVis (Tang et al., 2016).
lvish(X, perplexity = 50, n_neighbors = perplexity * 3,
n_components = 2, metric = "euclidean", n_epochs = -1, alpha = 1,
scale = "maxabs", init = "lvrandom", gamma = 7,
negative_sample_rate = 5, nn_method = NULL, n_trees = 50,
search_k = 2 * n_neighbors * n_trees, n_threads = max(1,
RcppParallel::defaultNumThreads()/2), grain_size = 1,
kernel = "gauss", ret_nn = FALSE, verbose = getOption("verbose",
TRUE))Input data. Can be a data.frame, matrix,
dist object or sparseMatrix.
A sparse matrix is interpreted as a distance matrix and both implicit and
explicit zero entries are ignored. Set zero distances you want to keep to
an arbitrarily small non-zero value (e.g. 1e-10). Matrix and data
frames should contain one observation per row. Data frames will have any
non-numeric columns removed.
Controls the size of the local neighborhood used for
manifold approximation. This is the analogous to n_neighbors in
umap. Change this, rather than n_neighbors.
The number of neighbors to use when calculating the
perplexity. Usually set to three times the value of the
perplexity. Must be at least as large as perplexity.
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.
Type of distance metric to use to find nearest neighbors. One of:
"euclidean" (the default)
"cosine"
"manhattan"
Only applies if nn_method = "annoy" (for nn_method = "fnn", the
distance metric is always "euclidean").
Number of epochs to use during the optimization of the embedded coordinates. The default is calculate the number of epochs dynamically based on dataset size, to give the same number of edge samples as the LargeVis defaults. This is usually substantially larger than the UMAP defaults.
Initial learning rate used in optimization of the coordinates.
Scaling to apply to X if it is a data frame or matrix:
"none" or FALSE or NULL No scaling.
"scale" or TRUE Scale each column to zero mean and variance 1.
"maxabs" Center each column to mean 0, then divide each element by the
maximum absolute value over the entire matrix.
"range" Range scale the entire matrix, so the smallest element is 0 and
the largest is 1.
For lvish, the default is "maxabs", for consistency with LargeVis.
Type of initialization for the coordinates. Options are:
"spectral" Spectral embedding using the normalized Laplacian
of the fuzzy 1-skeleton, with Gaussian noise added.
"normlaplacian". Spectral embedding using the normalized
Laplacian of the fuzzy 1-skeleton, without noise.
"random". Coordinates assigned using a uniform random
distribution between -10 and 10.
"lvrandom". Coordinates assigned using a Gaussian
distribution with standard deviation 1e-4, as used in LargeVis
(Tang et al., 2016) and t-SNE.
"laplacian". Spectral embedding using the Laplacian Eigenmap
(Belkin and Niyogi, 2002).
"pca". The first two principal components from PCA of
X if X is a data frame, and from a 2-dimensional classical
MDS if X is of class "dist".
"spca". Like "pca", but each dimension is then scaled
so the standard deviation is 1e-4, to give a distribution similar to
that used in t-SNE and LargeVis.
A matrix of initial coordinates.
Weighting applied to negative samples in low dimensional embedding optimization. Values higher than one will result in greater weight being given to negative samples.
The number of negative edge/1-simplex samples to use per positive edge/1-simplex sample in optimizing the low dimensional embedding.
Method for finding nearest neighbors. Options are:
"fnn". Use exact nearest neighbors via the
FNN package.
"annoy" Use approximate nearest neighbors via the
RcppAnnoy package.
By default, if X has less than 4,096 vertices, the exact nearest
neighbors are found. Otherwise, approximate nearest neighbors are used.
You may also pass precalculated nearest neighbor data to this argument. It
must be a list consisting of two elements:
"idx". A n_vertices x n_neighbors matrix
containing the integer indexes of the nearest neighbors in X. Each
vertex is considered to be its own nearest neighbor, i.e.
idx[, 1] == 1:n_vertices.
"dist". A n_vertices x n_neighbors matrix
containing the distances of the nearest neighbors.
The n_neighbors parameter is ignored when using precalculated
nearest neighbor data.
Number of trees to build when constructing the nearest
neighbor index. The more trees specified, the larger the index, but the
better the results. With search_k, determines the accuracy of the
Annoy nearest neighbor search. Only used if the nn_method is
"annoy". Sensible values are between 10 to 100.
Number of nodes to search during the neighbor retrieval. The
larger k, the more the accurate results, but the longer the search takes.
With n_trees, determines the accuracy of the Annoy nearest neighbor
search. Only used if the nn_method is "annoy".
Number of threads to use. Default is half that recommended
by RcppParallel. For nearest neighbor search, only applies if
nn_method = "annoy".
Minimum batch size for multithreading. If the number of
items to process in a thread falls below this number, then no threads will
be used. Used in conjunction with n_threads.
Type of kernel function to create input probabilities. Can be
one of "gauss" (the default) or "knn". "gauss" uses
the usual Gaussian weighted similarities. "knn" assigns equal
probabilities to every edge in the nearest neighbor graph, and zero
otherwise, using perplexity nearest neighbors. The n_neighbors
parameter is ignored in this case.
If TRUE, then in addition to the embedding, also return
nearest neighbor data that can be used as input to nn_method to
avoid the overhead of repeatedly calculating the nearest neighbors when
manipulating unrelated parameters (e.g. min_dist, n_epochs,
init). See the "Value" section for the names of the list items. If
FALSE, just return the coordinates. Note that the nearest neighbors
could be sensitive to data scaling, so be wary of reusing nearest neighbor
data if modifying the scale parameter.
If TRUE, log details to the console.
A matrix of optimized coordinates, or if ret_nn = TRUE,
returns the nearest neigbor data as a list containing a matrix idx
with the integer ids of the neighbors; and a matrix dist with the
distances. This list can be used as input to the nn_method
parameter.
lvish differs from the official LargeVis implementation in the
following:
Only the nearest-neighbor index search phase is multi-threaded.
Matrix input data is not normalized.
The n_trees parameter cannot be dynamically chosen based on
data set size.
Nearest neighbor results are not refined via the
neighbor-of-my-neighbor method. The search_k parameter is twice
as large than default to compensate.
Gradient values are clipped to 4.0 rather than 5.0.
Negative edges are generated by uniform sampling of vertexes rather than their degree ^ 0.75.
The default number of samples is much reduced. The default number of
epochs, n_epochs, is set to 5000, much larger than for
umap, but may need to be increased further depending on your
dataset. Using init = "spectral" can help.
Tang, J., Liu, J., Zhang, M., & Mei, Q. (2016, April). Visualizing large-scale and high-dimensional data. In Proceedings of the 25th International Conference on World Wide Web (pp. 287-297). International World Wide Web Conferences Steering Committee. https://arxiv.org/abs/1602.00370
# NOT RUN {
# Use perplexity rather than n_neighbors to control the size of the local
neighborhood iris_lvish <- umap(iris, perplexity = 50, alpha = 0.5,
init = "random")
# Default number of epochs is much larger than for UMAP, assumes random
# initialization
# If using a more global initialization, can use fewer epochs
iris_lvish_short <- umap(iris, perpelxity = 50, n_epochs = 1000)
# }
Run the code above in your browser using DataLab