Visualizar embeddings
Nesta página
Objetivos
- Reduzir vetores de alta dimensionalidade para visualização 2D/3D
- Utilizar t-SNE e UMAP para visualização
- Interpretar agrupamentos visuais
O desafio: 3.072 dimensões
Os embeddings existem num espaço de 3.072 dimensões que ninguém consegue visualizar diretamente. Para os inspecionar, tem de os projetar em duas ou três dimensões. Isto implica alguma perda de informação, mas preserva a estrutura essencial: pontos que estavam próximos devem permanecer próximos. Esta é uma ferramenta de diagnóstico poderosa. Um agrupamento dividido ou temas sobrepostos saltam à vista, enquanto métricas agregadas podem não os detetar de todo.
Redução de dimensionalidade com t-SNE
O t-SNE (t-distributed Stochastic Neighbor Embedding) é o método clássico. Encontra um layout 2D onde cada ponto mantém a sua vizinhança original. O exemplo abaixo construi deliberadamente um corpus com três temas distintos — IA, culinária e desporto — para que possa verificar se a projeção recupera a estrutura esperada.
from openai import OpenAI
from sklearn.manifold import TSNE
import matplotlib.pyplot as plt
import numpy as np
client = OpenAI()
# Example corpus
textes = [
# AI Cluster
"Deep learning uses neural networks",
"Machine learning transforms data science",
"Transformers revolutionized NLP",
"GPT-5 is a large language model",
# Cooking Cluster
"Chocolate cake recipe",
"How to prepare ratatouille",
"Basics of French pastry",
"Oven baking techniques",
# Sports Cluster
"Paris Marathon attracts thousands of runners",
"Interval training for running",
"Soccer rules explained",
"Sports nutrition and performance",
]
categories = (["AI"] * 4 + ["Cooking"] * 4 + ["Sports"] * 4)
# Generate embeddings
response = client.embeddings.create(
input=textes,
model="text-embedding-3-large"
)
embeddings = np.array([d.embedding for d in response.data])
# t-SNE reduction to 2D
tsne = TSNE(n_components=2, random_state=42, perplexity=4)
coords = tsne.fit_transform(embeddings)
# Visualization
couleurs = {"AI": "#2563eb", "Cooking": "#dc2626", "Sports": "#16a34a"}
fig, ax = plt.subplots(figsize=(10, 8))
for cat in couleurs:
mask = [c == cat for c in categories]
ax.scatter(
coords[mask, 0], coords[mask, 1],
c=couleurs[cat], label=cat, s=100, alpha=0.8
)
for i, (x, y) in enumerate(coords[mask]):
idx = [j for j, m in enumerate(mask) if m][i]
ax.annotate(
textes[idx][:30] + "...",
(x, y), fontsize=7, alpha=0.7
)
ax.legend()
ax.set_title("t-SNE Visualization of Embeddings")
plt.tight_layout()
plt.savefig("tsne_embeddings.png", dpi=150)
plt.show()
Três parâmetros conduzem o resultado. A perplexidade equilibra a estrutura local versus global, com valores típicos entre 5 e 50; aqui está definida como 4 porque o corpus contém apenas doze pontos, e uma perplexidade superior ao número de vizinhos disponíveis produziria uma projeção incoerente. O n_iter define o número de iterações de otimização, com um mínimo de 250 e, idealmente, mais de 1.000. O random_state garante a reprodutibilidade: sem ele, duas execuções sucessivas geram figuras diferentes, tornando a comparação impossível.
Redução com UMAP
O UMAP (Uniform Manifold Approximation and Projection) é frequentemente preferido ao t-SNE porque é mais rápido e preserva melhor a estrutura global. Por outras palavras, a distância entre dois agrupamentos num gráfico UMAP tem significado, enquanto com o t-SNE é arbitrária.
import umap
# UMAP reduction to 2D
reducer = umap.UMAP(n_components=2, random_state=42, n_neighbors=5)
coords_umap = reducer.fit_transform(embeddings)
fig, ax = plt.subplots(figsize=(10, 8))
for cat in couleurs:
mask = [c == cat for c in categories]
ax.scatter(
coords_umap[mask, 0], coords_umap[mask, 1],
c=couleurs[cat], label=cat, s=100, alpha=0.8
)
ax.legend()
ax.set_title("UMAP Visualization of Embeddings")
plt.tight_layout()
plt.savefig("umap_embeddings.png", dpi=150)
plt.show()
A tabela seguinte resume as compensações entre os dois métodos.
| Critério | t-SNE | UMAP |
|---|---|---|
| Velocidade | Lenta (O(n²)) | Rápida |
| Estrutura global | Mal preservada | Bem preservada |
| Reprodutibilidade | Variável | Estável |
| Parâmetros | perplexity | n_neighbors, min_dist |
Visualização interativa 3D
Num corpus de algumas centenas de pontos, uma figura estática torna-se ilegível: os rótulos sobrepõem-se e não consegue distinguir qual o texto correspondente a cada ponto. O Plotly resolve isto ao mover a informação para dicas de contexto (tooltips) e permitir-lhe rodar a nuvem de pontos.
import plotly.express as px
import pandas as pd
# Reduction to 3D
reducer_3d = umap.UMAP(n_components=3, random_state=42, n_neighbors=5)
coords_3d = reducer_3d.fit_transform(embeddings)
df = pd.DataFrame({
"x": coords_3d[:, 0],
"y": coords_3d[:, 1],
"z": coords_3d[:, 2],
"category": categories,
"text": [t[:50] for t in textes]
})
fig = px.scatter_3d(
df, x="x", y="y", z="z",
color="category",
hover_data=["text"],
title="3D Embeddings"
)
fig.write_html("embeddings_3d.html")
fig.show()
O ficheiro HTML resultante está pronto para ser partilhado. É uma excelente forma de mostrar a uma equipa de negócios como os seus documentos estão distribuídos, sem escrever uma única linha de código.
Visualizar o efeito da redução de dimensionalidade
A Lição 2 afirmava que truncar um vetor para 256 dimensões retém cerca de 88% da sua qualidade. Esse número permanece abstrato até o ver. Ao gerar o mesmo corpus em quatro tamanhos diferentes e projetar cada versão, observa diretamente quando os agrupamentos começam a tocar-se. Isto permite-lhe decidir com base em evidências e não numa regra geral.
dimensions_a_tester = [256, 512, 1536, 3072]
fig, axes = plt.subplots(1, 4, figsize=(24, 5))
for ax, dim in zip(axes, dimensions_a_tester):
resp = client.embeddings.create(
input=textes,
model="text-embedding-3-large",
dimensions=dim
)
embs = np.array([d.embedding for d in resp.data])
tsne = TSNE(n_components=2, random_state=42, perplexity=4)
coords = tsne.fit_transform(embs)
for cat in couleurs:
mask = [c == cat for c in categories]
ax.scatter(coords[mask, 0], coords[mask, 1],
c=couleurs[cat], label=cat, s=60)
ax.set_title(f"{dim} dimensions")
ax.legend(fontsize=7)
plt.tight_layout()
plt.savefig("comparaison_dimensions.png", dpi=150)
plt.show()
Um aviso antes de interpretar estas figuras: a projeção distorce sempre. Um ponto isolado no gráfico não está necessariamente isolado no espaço original, e dois agrupamentos colados em 2D podem estar perfeitamente separados em 3.072 dimensões. A visualização ajuda-o a formular uma hipótese, nunca a validá-la. A validação depende das métricas que abordaremos na Lição 10.
Pontos-chave
- O t-SNE e o UMAP projetam embeddings em 2D/3D para visualização
- O UMAP é geralmente preferido pela sua velocidade e fidelidade
- O Plotly permite visualizações 3D interativas
- A visualização ajuda a validar a qualidade dos embeddings e a detetar anomalias