Przejdź do głównej treści
Polski— Wybierz język
Menu

Wizualizacja osadzeń

Lekcja 5 z 22 Zaktualizowano 29 lipca 2026 Programista
Na tej stronie
  1. Cele
  2. Wyzwanie: 3072 wymiary
  3. Redukcja wymiarowości za pomocą t-SNE
  4. Redukcja za pomocą UMAP
  5. Interaktywna wizualizacja 3D
  6. Wizualizacja wpływu redukcji wymiarowości
  7. Kluczowe wnioski

Cele

  • Redukcja wektorów wysokowymiarowych do wizualizacji 2D/3D
  • Wykorzystanie t-SNE i UMAP do wizualizacji
  • Interpretacja wizualnych skupisk

Wyzwanie: 3072 wymiary

Osadzenia istnieją w przestrzeni 3072-wymiarowej, której nikt nie jest w stanie bezpośrednio zwizualizować. Aby je przeanalizować, musisz rzutować je na dwa lub trzy wymiary. Wiąże się to z pewną utratą informacji, ale zachowuje istotną strukturę: punkty, które były blisko siebie, powinny pozostać blisko. Jest to potężne narzędzie diagnostyczne. Rozdzielone skupiska lub nakładające się tematy rzucają się w oczy natychmiast, podczas gdy metryki agregujące mogą je całkowicie przeoczyć.

Redukcja wymiarowości za pomocą t-SNE

t-SNE (t-distributed Stochastic Neighbor Embedding) to klasyczna metoda. Znajduje ona układ 2D, w którym każdy punkt zachowuje swoje oryginalne sąsiedztwo. Poniższy przykład celowo buduje korpus z trzema odrębnymi tematami – AI, gotowanie i sport – abyś mógł zweryfikować, czy rzutowanie odtwarza oczekiwaną strukturę.

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

Trzy parametry sterują wynikiem. perplexity balansuje między strukturą lokalną a globalną; typowe wartości mieszczą się między 5 a 50. Tutaj ustawiono ją na 4, ponieważ korpus zawiera tylko dwanaście punktów, a perplexity wyższa niż liczba dostępnych sąsiadów doprowadziłaby do niespójnego rzutowania. n_iter określa liczbę iteracji optymalizacji, z minimum 250, a idealnie ponad 1000. random_state zapewnia powtarzalność: bez niego dwa kolejne uruchomienia dadzą różne wykresy, uniemożliwiając porównanie.

Redukcja za pomocą UMAP

UMAP (Uniform Manifold Approximation and Projection) jest często preferowany nad t-SNE, ponieważ jest szybszy i lepiej zachowuje strukturę globalną. Innymi słowy, odległość między dwoma skupiskami na wykresie UMAP coś oznacza, podczas gdy w przypadku t-SNE jest ona arbitralna.

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

Poniższa tabela podsumowuje kompromisy między obiema metodami.

Kryteriumt-SNEUMAP
SzybkośćWolna (O(n²))Szybka
Struktura globalnaSłabo zachowanaDobrze zachowana
PowtarzalnośćZmiennaStabilna
Parametryperplexityn_neighbors, min_dist

Interaktywna wizualizacja 3D

W przypadku korpusu liczącego kilkaset punktów statyczny wykres staje się nieczytelny: etykiety nachodzą na siebie i nie można określić, który tekst odpowiada któremu punktowi. Plotly rozwiązuje ten problem, przenosząc informacje do dymków (tooltipów) i pozwalając obracać chmurę punktów.

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

Powstały plik HTML jest gotowy do udostępnienia. To doskonały sposób, aby pokazać zespołowi biznesowemu, jak rozłożone są ich dokumenty, bez pisania ani jednej linii kodu.

Wizualizacja wpływu redukcji wymiarowości

Lekcja 2 stwierdziła, że skrócenie wektora do 256 wymiarów zachowuje około 88% jego jakości. Liczba ta pozostaje abstrakcyjna, dopóki jej nie zobaczysz. Generując ten sam korpus w czterech różnych rozmiarach i rzutując każdą wersję, bezpośrednio obserwujesz, kiedy skupiska zaczynają się stykać. Pozwala to podjąć decyzję w oparciu o dowody, a nie ogólną regułę.

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

Ostrzeżenie przed interpretacją tych wykresów: rzutowanie zawsze zniekształca. Izolowany punkt na wykresie niekoniecznie jest izolowany w oryginalnej przestrzeni, a dwa skupiska sklejone ze sobą w 2D mogą być idealnie rozdzielone w 3072 wymiarach. Wizualizacja pomaga sformułować hipotezę, nigdy jej nie potwierdza. Walidacja opiera się na metrykach, które omówimy w Lekcji 10.

Kluczowe wnioski

  • t-SNE i UMAP rzutują osadzenia na 2D/3D w celu wizualizacji
  • UMAP jest zazwyczaj preferowany ze względu na szybkość i wierność odwzorowania
  • Plotly umożliwia interaktywne wizualizacje 3D
  • Wizualizacja pomaga zweryfikować jakość osadzeń i wykryć anomalie