Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Vizualizacija ugrađenih vektora

Lekcija 5 od 22 Ažurirano 29. srpnja 2026. Programer
Na ovoj stranici
  1. Ciljevi
  2. Izazov: 3.072 dimenzije
  3. Smanjenje dimenzionalnosti s t-SNE
  4. Smanjenje s UMAP-om
  5. Interaktivna 3D vizualizacija
  6. Vizualizacija učinka smanjenja dimenzionalnosti
  7. Ključne točke

Ciljevi

  • Smanji visokodimenzionalne vektore za 2D/3D vizualizaciju
  • Koristi t-SNE i UMAP za vizualizaciju
  • Protumači vizualne klastere

Izazov: 3.072 dimenzije

Ugrađeni vektori žive u prostoru od 3.072 dimenzije koji nitko ne može izravno vizualizirati. Da bi ih pregledao, moraš ih projicirati u dvije ili tri dimenzije. To prihvaća određeni gubitak informacija, ali čuva bitnu strukturu: točke koje su bile blizu trebale bi ostati blizu. Ovo je moćan dijagnostički alat. Razdvojeni klasteri ili preklapajuće teme odmah skoče u oči, dok bi ih agregirane metrike mogle potpuno promašiti.

Smanjenje dimenzionalnosti s t-SNE

t-SNE (t-distribuirano stohastičko ugrađivanje susjeda) klasična je metoda. Ona pronalazi 2D raspored gdje svaka točka zadržava svoje izvorno susjedstvo. Primjer u nastavku namjerno gradi korpus s tri različite teme – AI, kuhanje i sport – kako bi mogao provjeriti vraća li projekcija očekivanu strukturu.

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

Tri parametra upravljaju rezultatom. perplexity balansira lokalnu i globalnu strukturu, s tipičnim vrijednostima između 5 i 50; ovdje je postavljena na 4 jer korpus sadrži samo dvanaest točaka, a perplexity veći od dostupnih susjeda proizveo bi nekoherentnu projekciju. n_iter postavlja broj iteracija optimizacije, s minimumom od 250 i idealno više od 1.000. random_state osigurava ponovljivost: bez njega, dva uzastopna pokretanja daju različite figure, što onemogućuje usporedbu.

Smanjenje s UMAP-om

UMAP (Uniform Manifold Approximation and Projection) često se preferira nad t-SNE-om jer je brži i bolje čuva globalnu strukturu. Drugim riječima, udaljenost između dva klastera na UMAP grafikonu nešto znači, dok je kod t-SNE-a proizvoljna.

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

Sljedeća tablica sažima kompromise između ove dvije metode.

Kriterijt-SNEUMAP
BrzinaSpora (O(n²))Brza
Globalna strukturaLoše očuvanaDobro očuvana
PonovljivostPromjenjivaStabilna
Parametriperplexityn_neighbors, min_dist

Interaktivna 3D vizualizacija

Na korpusu od nekoliko stotina točaka, statična figura postaje nečitljiva: oznake se preklapaju i ne možeš reći koji tekst odgovara kojoj točki. Plotly to rješava premještanjem informacija u alatne savjete i omogućavanjem rotacije oblaka točaka.

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

Rezultirajuća HTML datoteka spremna je za dijeljenje. Izvrstan je način da poslovnom timu pokažeš kako su njihovi dokumenti distribuirani, a da ne napišeš ni redak koda.

Vizualizacija učinka smanjenja dimenzionalnosti

Lekcija 2 navodila je da skraćivanje vektora na 256 dimenzija zadržava oko 88% njegove kvalitete. Ta brojka ostaje apstraktna dok je ne vidiš. Generiranjem istog korpusa u četiri različite veličine i projiciranjem svake verzije, izravno opažaš kada se klasteri počnu dodirivati. To ti omogućuje donošenje odluka na temelju dokaza, a ne općeg 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()

Upozorenje prije tumačenja ovih figura: projekcija uvijek iskrivljuje. Izolirana točka na grafikonu nije nužno izolirana u izvornom prostoru, a dva klastera zalijepljena zajedno u 2D mogu biti savršeno odvojena u 3.072 dimenzije. Vizualizacija ti pomaže formulirati hipotezu, nikada je validirati. Validacija se oslanja na metrike koje ćemo pokriti u Lekciji 10.

Ključne točke

  • t-SNE i UMAP projiciraju ugrađene vektore u 2D/3D za vizualizaciju
  • UMAP se općenito preferira zbog svoje brzine i vjernosti
  • Plotly omogućuje interaktivne 3D vizualizacije
  • Vizualizacija pomaže validirati kvalitetu ugrađenih vektora i otkriti anomalije