Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Vizualizacija vdelav

Lekcija 5 od 22 Posodobljeno 29. julij 2026 Razvijalec
Na tej strani
  1. Cilji
  2. Izziv: 3.072 dimenzij
  3. Zmanjšanje dimenzionalnosti s t-SNE
  4. Zmanjšanje z UMAP
  5. Interaktivna vizualizacija v 3D
  6. Vizualizacija učinka zmanjšanja dimenzionalnosti
  7. Ključne ugotovitve

Cilji

  • Zmanjšanje visokodimenzionalnih vektorjev za vizualizacijo v 2D/3D
  • Uporaba metod t-SNE in UMAP za vizualizacijo
  • Interpretacija vizualnih grozdov

Izziv: 3.072 dimenzij

Vdelave obstajajo v prostoru z 3.072 dimenzijami, ki ga nihče ne more neposredno vizualizirati. Da bi jih pregledali, jih morate projicirati v dve ali tri dimenzije. To sprejme določeno izgubo informacij, vendar ohrani bistveno strukturo: točke, ki so bile blizu, morajo ostati blizu. To je zmogljivo diagnostično orodje. Razcepljen grozd ali prekrivajoče se teme takoj skočijo v oči, medtem ko jih agregatni metrik lahko popolnoma spregleda.

Zmanjšanje dimenzionalnosti s t-SNE

t-SNE (t-distributed Stochastic Neighbor Embedding) je klasična metoda. Poišče razporeditev v 2D, kjer vsaka točka ohrani svojo prvotno sosesko. Spodnji primer namerno gradi korpus s tremi različnimi temami – umetna inteligenca, kuhanje in šport – tako da lahko preverite, ali projekcija obnovi pričakovano strukturo.

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

Rezultat poganjajo trije parametri. perplexity uravnava ravnovesje med lokalno in globalno strukturo; tipične vrednosti so med 5 in 50. Tukaj je nastavljena na 4, ker korpus vsebuje le dvanajst točk, in perplexity, višji od razpoložljivih sosedov, bi proizvedel nekoherentno projekcijo. n_iter določa število iteracij optimizacije, z minimumom 250 in idealno več kot 1.000. random_state zagotavlja ponovljivost: brez njega dva zaporedna zagona proizvedeta različne slike, kar onemogoča primerjavo.

Zmanjšanje z UMAP

UMAP (Uniform Manifold Approximation and Projection) je pogosto prednostna izbira pred t-SNE, ker je hitrejši in bolje ohranja globalno strukturo. Z drugimi besedami, razdalja med dvema grozdoma na grafu UMAP nekaj pomeni, medtem ko je pri t-SNE poljubna.

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

Naslednja tabela povzema kompromise med obema metodama.

Merilot-SNEUMAP
HitrostPočasno (O(n²))Hitro
Globalna strukturaSlabo ohranjenaDobro ohranjena
PonovljivostSpremenljivaStabilna
Parametriperplexityn_neighbors, min_dist

Interaktivna vizualizacija v 3D

Pri korpusu z nekaj sto točkami postane statična slika neberljiva: oznake se prekrivajo in ne morete ugotoviti, katero besedilo ustreza kateri točki. Plotly to reši s premikom informacij v opisne oblake (tooltips) in omogoča vrtenje oblaka točk.

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

Nastala datoteka HTML je pripravljena za deljenje. To je odličen način, da poslovni ekipi pokažete, kako so razporejeni njihovi dokumenti, ne da bi napisali vrstico kode.

Vizualizacija učinka zmanjšanja dimenzionalnosti

Lekcija 2 je navajala, da okrnitev vektorja na 256 dimenzij ohrani približno 88 % njegove kakovosti. Ta številka ostane abstraktna, dokler je ne vidite. Z generiranjem istega korpusa v štirih različnih velikostih in projiciranjem vsake različice neposredno opazujete, kdaj se grozdi začnejo dotikati. To vam omogoča odločanje na podlagi dokazov in ne splošnega pravila.

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

Opozorilo pred interpretacijo teh slik: projekcija vedno popači. Osamljena točka na grafu ni nujno osamljena v izvirnem prostoru in dva grozda, ki sta v 2D zlepljena skupaj, sta lahko v 3.072 dimenzijah popolnoma ločena. Vizualizacija vam pomaga oblikovati hipotezo, nikoli pa je ne potrdi. Validacija temelji na metrikah, ki jih bomo obravnavali v lekciji 10.

Ključne ugotovitve

  • t-SNE in UMAP projicirata vdelave v 2D/3D za vizualizacijo
  • UMAP je na splošno prednostna izbira zaradi hitrosti in zvestobe
  • Plotly omogoča interaktivne vizualizacije v 3D
  • Vizualizacija pomaga potrditi kakovost vdelav in zaznati anomalije