Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Vizualizē iegultnes

Nodarbība 5 no 22 Atjaunota 2026. gada 29. jūlijs Programmētājs
Šajā lapā
  1. Mērķi
  2. Izaicinājums: 3072 dimensijas
  3. Dimensiju samazināšana ar t-SNE
  4. Samazināšana ar UMAP
  5. Interaktīva 3D vizualizācija
  6. Dimensiju samazināšanas efekta vizualizācija
  7. Galvenās atziņas

Mērķi

  • Samazināt augstas dimensijas vektorus 2D/3D vizualizācijai
  • Izmantot t-SNE un UMAP vizualizācijai
  • Interpretēt vizuālos kopas

Izaicinājums: 3072 dimensijas

Iegultnes eksistē 3072 dimensiju telpā, ko neviens nevar vizualizēt tieši. Lai tās pārbaudītu, tev tās jāprojektē divās vai trīs dimensijās. Tas pieļauj zināmu informācijas zudumu, bet saglabā būtisko struktūru: punktiem, kas bija tuvu viens otram, jāpaliek tuvu. Tas ir spēcīgs diagnostikas rīks. Sadalīta kopa vai pārklājušās tēmas ir acīmredzamas ar vienu skatienu, savukārt agregēti rādītāji tās varētu pilnībā nepamanīt.

Dimensiju samazināšana ar t-SNE

t-SNE (t-distributed Stochastic Neighbor Embedding) ir klasiskā metode. Tā atrod 2D izkārtojumu, kurā katrs punkts saglabā savu sākotnējo apkārtni. Zemāk redzamajā piemērā apzināti tiek veidots korpuss ar trim atšķirīgām tēmām — AI, ēdiena gatavošana un sports —, lai tu varētu pārbaudīt, vai projekcija atjauno paredzamo struktūru.

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

Rezultātu nosaka trīs parametri. perplexity līdzsvaro lokālo un globālo struktūru; tipiskas vērtības ir robežās no 5 līdz 50. Šeit tā ir iestatīta uz 4, jo korpusā ir tikai divpadsmit punkti, un perplexity vērtība, kas pārsniedz pieejamo kaimiņu skaitu, radītu nesakarīgu projekciju. n_iter nosaka optimizācijas iterāciju skaitu; minimums ir 250, bet ideālā gadījumā vairāk nekā 1000. random_state nodrošina reproducējamību: bez tā divi secīgi izpildījumi radīs atšķirīgus attēlus, padarot salīdzināšanu neiespējamu.

Samazināšana ar UMAP

UMAP (Uniform Manifold Approximation and Projection) bieži tiek dots priekšroka salīdzinājumā ar t-SNE, jo tas ir ātrāks un labāk saglabā globālo struktūru. Citiem vārdiem sakot, attālums starp divām kopām UMAP grafikam kaut ko nozīmē, savukārt ar t-SNE tas ir patvaļīgs.

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

Zemāk esošajā tabulā apkopoti kompromisi starp abām metodēm.

Kritērijst-SNEUMAP
ĀtrumsLēns (O(n²))Ātrs
Globālā struktūraSlikti saglabātaLabi saglabāta
ReproducējamībaMainīgaStabila
Parametriperplexityn_neighbors, min_dist

Interaktīva 3D vizualizācija

Korpusā ar dažiem simtiem punktu statisks attēls kļūst nelasāms: etiķetes pārklājas, un nevar noteikt, kurš teksts atbilst kuram punktam. Plotly šo problēmu atrisina, pārvietojot informāciju uz rīka padomiem (tooltips) un ļaujot pagriezt punktu mākonī.

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

Iegūtais HTML fails ir gatavs kopīgošanai. Tas ir lielisks veids, kā parādīt uzņēmuma komandai, kā ir sadalīti viņu dokumenti, nerakstot nevienu koda rindiņu.

Dimensiju samazināšanas efekta vizualizācija

  1. nodarbībā tika minēts, ka vektora saīsināšana līdz 256 dimensijām saglabā aptuveni 88% no tā kvalitātes. Šis skaitlis paliek abstrakts, kamēr to neredzi. Ģenerējot to pašu korpusu četros dažādos izmēros un projektējot katru versiju, tu vari tieši novērot, kad kopas sāk saskarties. Tas ļauj pieņemt lēmumus, balstoties uz pierādījumiem, nevis vispārīgiem noteikumiem.
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()

Brīdinājums pirms šo attēlu interpretācijas: projekcija vienmēr sagrozī. Izolēts punkts grafikā ne vienmēr ir izolēts sākotnējā telpā, un divas kopas, kas 2D ir salipušas kopā, 3072 dimensijās var būt perfekti atdalītas. Vizualizācija palīdz formulēt hipotēzi, bet nekad to apstiprināt. Apstiprināšana balstās uz metrikām, ko aplūkosim 10. nodarbībā.

Galvenās atziņas

  • t-SNE un UMAP projektē iegultnes 2D/3D vizualizācijai
  • UMAP parasti ir vēlamāks tā ātruma un precizitātes dēļ
  • Plotly ļauj veidot interaktīvas 3D vizualizācijas
  • Vizualizācija palīdz validēt iegultņu kvalitāti un noteikt anomālijas