UMAP Tutorial

Introduction to UMAP

UMAP (Uniform Manifold Approximation and Projection) is a dimension reduction technique that can be used for visualization similarly to t-SNE, but also for general non-linear dimension reduction. UMAP is based on manifold learning techniques and assumes that the data is uniformly distributed on Riemannian manifolds. It then applies local fuzzy simplicial set representations to approximate the manifold structure.

Installing UMAP

Before you can use UMAP, you need to install the umap-learn package. You can install it using pip:

Basic Example of UMAP

Let's start with a basic example of reducing the dimensions of the Iris dataset using UMAP. First, we need to import the necessary libraries:

import umap
import matplotlib.pyplot as plt
from sklearn.datasets import load_iris
                

Next, load the Iris dataset:

data = load_iris()
X = data.data
y = data.target
                

Now, create a UMAP object and fit-transform the data:

reducer = umap.UMAP()
embedding = reducer.fit_transform(X)
                

Finally, let's plot the results:

plt.scatter(embedding[:, 0], embedding[:, 1], c=y, cmap='Spectral')
plt.title('UMAP projection of the Iris dataset')
plt.show()
                

Understanding UMAP Parameters

UMAP provides several parameters to control the embedding process. The most important ones are:

• n_neighbors: This controls how UMAP balances local versus global structure in the data. Low values focus on local structure, high values capture more global structure. Default is 15.
• min_dist: This controls how tightly UMAP is allowed to pack points together. Low values result in dense clusters, high values result in more spread out data. Default is 0.1.
• n_components: The dimension of the space to embed into. Default is 2.

Here's an example with custom parameters:

reducer = umap.UMAP(n_neighbors=10, min_dist=0.05, n_components=3)
embedding = reducer.fit_transform(X)
                

Advanced Usage of UMAP

UMAP can also be used with sparse data, supervised learning, and even for clustering. Here is an example that demonstrates how to use UMAP for supervised learning:

import umap
import numpy as np
from sklearn.datasets import load_digits

# Load data
digits = load_digits()
X = digits.data
y = digits.target

# Fit UMAP using supervised learning
reducer = umap.UMAP()
embedding = reducer.fit_transform(X, y=y)

# Plot the results
plt.scatter(embedding[:, 0], embedding[:, 1], c=y, cmap='Spectral')
plt.title('Supervised UMAP projection of the Digits dataset')
plt.show()
                

Supervised UMAP takes the labels into account during the embedding process, which can result in better separation of different classes in the low-dimensional space.

Conclusion

UMAP is a powerful and versatile tool for dimensionality reduction. It can be used for data visualization, preprocessing for machine learning, and even clustering. With its ability to handle large datasets and its various parameters to fine-tune the embedding, UMAP is a valuable addition to any data scientist's toolkit.