t-SNE for visualization in ML Python

Introduction

t-SNE helps us see complex data by turning many features into just two or three, so we can easily understand patterns and groups.

When you want to see how different groups of data look in a simple 2D or 3D picture.

When you have many features and want to find hidden clusters or groups.

When you want to check if your data points are similar or different before building a model.

When you want to explore high-dimensional data like images or text in a visual way.

Syntax

ML Python

from sklearn.manifold import TSNE

tsne = TSNE(n_components=2, perplexity=30, random_state=42)
X_embedded = tsne.fit_transform(X)

n_components sets how many dimensions you want to reduce to (usually 2 or 3 for visualization).

perplexity controls how t-SNE balances attention between local and global data structure; typical values are between 5 and 50.

Examples

Basic 2D t-SNE with default settings.

ML Python

tsne = TSNE(n_components=2)
X_embedded = tsne.fit_transform(X)

3D t-SNE with higher perplexity and fixed random state for reproducibility.

ML Python

tsne = TSNE(n_components=3, perplexity=40, random_state=0)
X_embedded = tsne.fit_transform(X)

Sample Model

This code loads the Iris flower dataset, applies t-SNE to reduce its 4 features to 2, and then plots the points colored by their species to show how t-SNE groups similar flowers.

ML Python

from sklearn.datasets import load_iris
from sklearn.manifold import TSNE
import matplotlib.pyplot as plt

# Load sample data
iris = load_iris()
X = iris.data
labels = iris.target

# Create t-SNE model
tsne = TSNE(n_components=2, perplexity=30, random_state=42)
X_embedded = tsne.fit_transform(X)

# Plot the results
plt.figure(figsize=(6,5))
for label in set(labels):
    plt.scatter(X_embedded[labels == label, 0], X_embedded[labels == label, 1], label=iris.target_names[label])
plt.legend()
plt.title('t-SNE visualization of Iris dataset')
plt.xlabel('t-SNE feature 1')
plt.ylabel('t-SNE feature 2')
plt.tight_layout()
plt.show()

Important Notes

t-SNE is good for visualization but not for general dimensionality reduction for modeling.

It can be slow on very large datasets; consider sampling or using faster alternatives if needed.

Results can vary between runs unless you set random_state for reproducibility.

Summary

t-SNE turns complex data into simple 2D or 3D pictures to help us see patterns.

It works well to find groups or clusters in data with many features.

Use it mainly for exploring and understanding data visually, not for final modeling.

Practice

1. What is the main purpose of using t-SNE in machine learning?

easy

A. To increase the number of features in the dataset

B. To train a predictive model for classification

C. To visualize high-dimensional data in 2D or 3D to find patterns

D. To clean and preprocess data by removing missing values

Solution

1. Step 1: Understand t-SNE's function

   t-SNE is a tool that reduces many features into 2 or 3 dimensions for easy visualization.

2. Step 2: Identify its main use

   It helps us see groups or clusters in complex data, not to train models or clean data.

3. Final Answer:

   To visualize high-dimensional data in 2D or 3D to find patterns -> Option C

4. Quick Check:

   t-SNE = visualization tool [OK]

Hint: t-SNE = visualize complex data simply [OK]

Common Mistakes:

• Thinking t-SNE trains prediction models
• Confusing t-SNE with data cleaning methods
• Assuming t-SNE increases feature count

2. Which of the following is the correct way to import t-SNE from scikit-learn in Python?

easy

A. from sklearn.manifold import TSNE

B. import tsne from sklearn

C. from sklearn.decomposition import TSNE

D. import TSNE from sklearn.manifold

Solution

1. Step 1: Recall correct import syntax

   scikit-learn's t-SNE is in the manifold module and imported as TSNE.

2. Step 2: Check each option

   from sklearn.manifold import TSNE uses correct Python import syntax and correct module. Others have wrong syntax or module.

3. Final Answer:

   from sklearn.manifold import TSNE -> Option A

4. Quick Check:

   Correct import = from sklearn.manifold import TSNE [OK]

Hint: t-SNE is in sklearn.manifold, import as TSNE [OK]

Common Mistakes:

• Using wrong module like sklearn.decomposition
• Incorrect import syntax causing errors
• Confusing lowercase and uppercase in TSNE

3. What will be the shape of the output from the following code snippet?

from sklearn.manifold import TSNE
import numpy as np
X = np.random.rand(100, 50)
tsne = TSNE(n_components=2, random_state=42)
X_embedded = tsne.fit_transform(X)
print(X_embedded.shape)

medium

A. (50, 2)

B. (2, 100)

C. (100, 50)

D. (100, 2)

Solution

1. Step 1: Understand input and t-SNE output

   Input X has 100 samples and 50 features. t-SNE reduces features to 2 dimensions.

2. Step 2: Determine output shape

   Output shape is (number of samples, n_components) = (100, 2).

3. Final Answer:

   (100, 2) -> Option D

4. Quick Check:

   Output shape = (samples, components) [OK]

Hint: Output shape = (samples, n_components) [OK]

Common Mistakes:

• Confusing features with samples in output shape
• Swapping rows and columns in shape
• Assuming output shape matches input shape

4. You run t-SNE on your dataset but get a ValueError: 'perplexity must be less than n_samples'. What is the likely cause and fix?

medium

A. Input data is not scaled; apply normalization

B. Perplexity is set too high; reduce it below number of samples

C. Random state is not set; set random_state parameter

D. Data contains missing values; remove or fill them

Solution

1. Step 1: Understand the error message

   The error says perplexity must be less than number of samples, so perplexity is too large.

2. Step 2: Fix by adjusting perplexity

   Reduce perplexity parameter to a value smaller than the number of samples in your data.

3. Final Answer:

   Perplexity is set too high; reduce it below number of samples -> Option B

4. Quick Check:

   Perplexity < samples [OK]

Hint: Keep perplexity less than sample count [OK]

Common Mistakes:

• Ignoring perplexity limits and increasing it
• Trying to fix by scaling data instead
• Changing unrelated parameters like random_state

5. You have a dataset with 1000 samples and 100 features. You want to visualize it with t-SNE but also keep track of clusters found by KMeans. Which approach is best?

hard

A. Run KMeans first, then apply t-SNE on original data, color points by cluster

B. Apply t-SNE first, then run KMeans on the 2D t-SNE output

C. Use t-SNE only, no clustering needed for visualization

D. Run KMeans on original data and use PCA instead of t-SNE

Solution

1. Step 1: Understand the goal

   You want to visualize data and show meaningful clusters clearly on the 2D plot.

2. Step 2: Choose correct order

   Running KMeans first on high-dimensional data finds accurate clusters, then t-SNE visualizes them by coloring points by cluster labels.

3. Step 3: Why not other options?

   Clustering on t-SNE output (B) is suboptimal as t-SNE distorts distances and is for visualization only, not modeling.

4. Final Answer:

   Run KMeans first, then apply t-SNE on original data, color points by cluster -> Option A

5. Quick Check:

   Cluster high-dim first, visualize after [OK]

Hint: Cluster original data first, then t-SNE visualize [OK]

Common Mistakes:

• Clustering t-SNE output causing distorted clusters
• Skipping clustering and missing group info
• Using PCA instead of t-SNE unnecessarily