Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Embeddingek vizualizálása

5. lecke 22 közül Frissítve 2026. július 29. Fejlesztő
Ezen az oldalon
  1. Célok
  2. A kihívás: 3072 dimenzió
  3. Dimenziócsökkentés t-SNE-nel
  4. Redukció UMAP-pel
  5. Interaktív 3D vizualizáció
  6. A dimenziócsökkentés hatásának vizualizálása
  7. Főbb megállapítások

Célok

  • Nagy dimenziójú vektorok redukálása 2D/3D-s vizualizációhoz
  • t-SNE és UMAP alkalmazása vizualizációra
  • Vizuális klaszterek értelmezése

A kihívás: 3072 dimenzió

Az embeddingek egy 3072 dimenziós térben léteznek, amelyet senki sem tud közvetlenül megjeleníteni. A vizsgálatukhoz két vagy három dimenzióba kell vetítened őket. Ez némi információvesztéssel jár, de megőrzi a lényeges szerkezetet: a közel lévő pontoknak közel kell maradniuk. Ez egy erőteljes diagnosztikai eszköz. Egy szétvált klaszter vagy az átfedő témák első pillantásra szembetűnnek, míg az aggregált metrikák ezt teljesen figyelmen kívül hagyhatják.

Dimenziócsökkentés t-SNE-nel

A t-SNE (t-distributed Stochastic Neighbor Embedding) a klasszikus módszer. Olyan 2D-s elrendezést talál, ahol minden pont megőrzi az eredeti szomszédságát. Az alábbi példa szándékosan három eltérő témájú – AI, főzés és sport – korpuszt épít fel, hogy ellenőrizhesd: a vetítés visszaadja-e a várt szerkezetet.

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()

Három paraméter határozza meg az eredményt. A perplexity egyensúlyt teremt a helyi és a globális szerkezet között; a tipikus értékek 5 és 50 között vannak. Itt 4-re állítottuk, mert a korpusz mindössze tizenkét pontot tartalmaz, és a rendelkezésre álló szomszédok számánál nagyobb perplexity inkonzisztens vetítést eredményezne. Az n_iter az optimalizációs iterációk számát szabályozza; a minimum 250, de ideális esetben 1000 felett van. A random_state biztosítja a reprodukálhatóságot: enélkül két egymást követő futtatás eltérő ábrákat ad, lehetetlenné téve az összehasonlítást.

Redukció UMAP-pel

Az UMAP (Uniform Manifold Approximation and Projection) gyakran előnyösebb a t-SNE-nél, mert gyorsabb, és jobban megőrzi a globális szerkezetet. Más szóval: két klaszter távolsága egy UMAP-ábrán jelentéssel bír, míg a t-SNE esetén ez önkényes.

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()

Az alábbi táblázat összefoglalja a két módszer közötti kompromisszumokat.

Kritériumt-SNEUMAP
SebességLassú (O(n²))Gyors
Globális szerkezetRosszul megőrzöttJól megőrzött
ReprodukálhatóságVáltozóStabil
Paraméterekperplexityn_neighbors, min_dist

Interaktív 3D vizualizáció

Néhány száz pontos korpusz esetén egy statikus ábra olvashatatlanná válik: a címkék átfedik egymást, és nem látható, melyik szöveg melyik ponthoz tartozik. A Plotly ezt úgy oldja meg, hogy az információkat eszköztippekbe helyezi, és lehetővé teszi a pontfelhő forgatását.

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()

A kapott HTML-fájl azonnal megosztható. Kiváló módja annak, hogy bemutasd egy üzleti csapatnak, hogyan oszlanak meg a dokumentumaik, anélkül, hogy egyetlen sor kódot is írnál.

A dimenziócsökkentés hatásának vizualizálása

A 2. lecke kimondta, hogy egy vektor 256 dimenzióra való csonkolása megőrzi a minőség körülbelül 88%-át. Ez az érték addig elvont marad, amíg meg nem látod. Ha ugyanazt a korpuszt négy különböző méretben generálod le, és mindegyik verziót kivetíted, közvetlenül megfigyelheted, mikor kezdik a klaszterek érinteni egymást. Így bizonyítékok alapján hozhatsz döntést, nem pedig általános szabályok alapján.

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()

Egy figyelmeztetés az ábrák értelmezése előtt: a vetítés mindig torzít. Egy izolált pont a grafikonon nem feltétlenül izolált az eredeti térben, és két, 2D-ben összeérő klaszter tökéletesen szeparált lehet 3072 dimenzióban. A vizualizáció segít hipotézist felállítani, de sosem validálja azt. A validáció a 10. leckében tárgyalt metrikákon alapul.

Főbb megállapítások

  • A t-SNE és az UMAP 2D/3D-be vetíti az embeddingeket vizualizáció céljából
  • Az UMAP általában előnyösebb a sebessége és a hűsége miatt
  • A Plotly lehetővé teszi az interaktív 3D-s vizualizációkat
  • A vizualizáció segít az embedding minőségének ellenőrzésében és az anomáliák észlelésében