Stop Guessing What Your Embeddings Mean — Visualize Them with Embedding Atlas

Image by author — Generated with ChatGPT

This story was written with the assistance of an AI writing program.

The Real Problem with Embedding Visualization

**Paper: **Embedding Atlas: Low-Friction, Interactive Embedding Visualization at Scale (https://arxiv.org/pdf/2505.06386)

Embedding projections are widely used to understand:

• model behavior
• dataset structure
• semantic clusters
• retrieval quality

But in practice, embedding visualization tools introduce friction:

Common Pain Point       | Why It Hurts
------------------------------------------------------
Tedious data wrangling  | You spend more time cleaning data than analyzing it
Scalability limits      | Many tools break or lag with large datasets
No workflow integration | Visualizations live in isolation
Limited analysis        | No coordinated metadata views
Hard adoption           | Too many steps before insights

Embedding Atlas was built specifically to remove these barriers.

🧭 What is Embedding Atlas?

Embedding Atlas is a scalable, interactive embedding visualization system designed to make working with embeddings as easy as browsing a dataset.

It combines:

• Modern web technologies
• Efficient embedding pipelines
• UMAP projections
• Density-based clustering
• Automatic labeling
• Nearest neighbor exploration
• SQL-style metadata inspection

The result is a fast, low-friction data analysis experience.

🧠 How It Works Under the Hood

Embedding Generation

Data Type      | Library Used
------------------------------
TextSentence   | Transformers
Images         | Transformers

Users can specify any compatible embedding model.

Dimensionality Reduction with UMAP

To visualize high-dimensional embeddings, Embedding Atlas uses UMAP.

Example of UMAP [Source]

UMAP (Uniform Manifold Approximation and Projection) is a nonlinear dimensionality reduction technique that:

• Preserves local structure (similar points stay close)
• Maintains global structure better than t-SNE
• Is faster and more scalable
• Is based on Riemannian geometry + graph theory

UMAP approximates data as lying on a uniform manifold, placing similar points nearby and dissimilar ones farther apart.

⚠️ Important: 2D proximity ≠ semantic equivalence. Projection distortion always exists.

🔧 Default Embedding Model

Embedding Atlas uses:

sentence-transformers/all-MiniLM-L6-v2

as the default text embedding model.

Relevant code snippet (Apple repo):

if model is None:
    model = "all-MiniLM-L6-v2"

This model is lightweight, fast, and good for general semantic similarity.

🧪 Running Embedding Atlas in Google Colab

Embedding Atlas supports according to documentation:

• CLI
• Python Notebook Widget
• Streamlit

I’ll use Colab Notebook + Widget.

📦 Step 1 — Install Dependencies

!pip install embedding-atlas anywidget duckdb datasets sentence-transformers

📊 Step 2 — Load a Dataset

I use:

**sentence-transformers/natural-questions**

from datasets import load_dataset
import pandas as pd

dataset = load_dataset(
    "sentence-transformers/natural-questions",
    "pair",
    split="train"
)
df_raw = dataset.to_pandas()

Sample data:

query  |  answer
-------------------------------------------------
when did richmond last play in a preliminary final | Richmond Football Club Richmond began 2017 with 5 straight wins…
who sang what in the world's come over you         | Jack Scott (singer)…

✂️ Step 3 — Sample and Prepare Data

df_raw = df_raw.sample(n=5000, random_state=42)

df_q = df_raw[["query"]].copy()
df_q["description"] = df_q["query"]
df_q["type"] = "query"

df_a = df_raw[["answer"]].copy()
df_a["description"] = df_a["answer"]
df_a["type"] = "answer"

df = pd.concat([df_q, df_a], ignore_index=True)

I now have:

description      | type
--------------------------------------
question text    | query
answer text      | answer

📋 Step 4 — Inspect Data with the Widget

from embedding_atlas.widget import EmbeddingAtlasWidget

EmbeddingAtlasWidget(
    df,
    text="description",
    show_embedding=False,
    show_table=True,
    show_charts=True
)

You can run SQL queries directly inside the interface to explore metadata.

Example of EmbeddingAtlasWidget table

🧠 Step 5 — Compute Embeddings + Projection

from embedding_atlas.projection import compute_text_projection

compute_text_projection(
    df,
    text="description",
    x="projection_x",
    y="projection_y",
    neighbors="neighbors"
)

This:

1. Downloads all-MiniLM-L6-v2
2. Generates embeddings
3. Runs UMAP
4. Builds nearest-neighbor graph

New columns appear:

• projection_x
• projection_y
• neighbors

Dataframe with projection and neighbors

📈 Step 6 — Interactive Visualization

widget = EmbeddingAtlasWidget(
    df,
    text="description",
    x="projection_x",
    y="projection_y",
    neighbors="neighbors",
    labels="automatic",
    show_embedding=True,
    show_table=True,
    show_charts=True
)

widget

You can:

• Click points
• Inspect raw text
• Explore nearest neighbors
• See auto cluster labels
• Filter by metadata (query vs answer)

Visualization of embedding

Embedding distane with neighbors

🧪 Using a Different Embedding Model (Qwen3)

I can bypass the default model.

1️⃣ Encode manually

from sentence_transformers import SentenceTransformer

model = SentenceTransformer("Qwen/Qwen3-Embedding-0.6B")
embeddings = model.encode(
    df["description"].tolist(),
    batch_size=32,
    normalize_embeddings=True,
    show_progress_bar=True
)
df["embedding_vectors"] = embeddings.tolist()

2️⃣ Run UMAP

import umap

reducer = umap.UMAP(
    n_neighbors=15,
    min_dist=0.1,
    metric="cosine",
    random_state=42
)
proj = reducer.fit_transform(embeddings)
df["projection_x"] = proj[:, 0]
df["projection_y"] = proj[:, 1]

3️⃣ Compute Nearest Neighbors

from sklearn.neighbors import NearestNeighbors

nn = NearestNeighbors(n_neighbors=10, metric="cosine")
nn.fit(embeddings)
distances, indices = nn.kneighbors(embeddings)
df["neighbors"] = [
    {"ids": idx.tolist(), "distances": dist.tolist()}
    for idx, dist in zip(indices, distances)
]

Dataframe with projection and neighbors with qwen3-embedding-0.6B

Then visualize the same way.

💡 What This Lets You Do

Embedding Atlas enables:

• 🔍 Inspecting semantic clusters
• 🧩 Debugging embedding failures
• 📈 Comparing embedding models
• 🧠 Understanding query–answer geometry
• 📊 Coordinated metadata analysis
• 🚀 Rapid experimentation

⚠️ Important Caveat

Points that appear close in 2D are not always semantically identical. Dimensionality reduction introduces distortion.

Use the projection as an exploration tool, not absolute truth.

🖥️ Common Issue: Graph Not Showing in Cloud

Embedding Atlas uses WebGL for rendering.

If graphs don’t show in remote environments:

👉 Test here: https://get.webgl.org/

SituationResultRotating cube visibleWebGL OKGray screenGPU acceleration disabled

Cloud VMs often lack browser GPU access.

🎯 Final Thoughts

Embedding Atlas dramatically lowers the friction of embedding visualization:

• Minimal setup
• Works inside notebooks
• Handles large datasets
• Integrates metadata
• Interactive exploration

It’s one of the first tools that makes embedding visualization feel like data analysis, not just plotting.

If you work with embeddings, retrieval systems, or LLMs — this tool is worth adding to your workflow.

If you have questions, feel free to reach out or leave a comment. Don’t forget to hit the like button and subscribe for more content! 😊