Siirry pääsisältöön
Suomi— Valitse kieli
Valikko

Visualisoi upotukset

Oppitunti 5 / 22 Päivitetty 29. heinäkuuta 2026 Kehittäjä
Tällä sivulla
  1. Tavoitteet
  2. Haaste: 3 072 ulottuvuutta
  3. Dimensioitten vähentäminen t-SNE:llä
  4. Vähentäminen UMAPilla
  5. Interaktiivinen 3D-visuaalisointi
  6. Dimensioitten vähentämisen vaikutuksen visualisointi
  7. Keskeiset asiat

Tavoitteet

  • Pienennä suurulotteisia vektoreita 2D/3D-visuaalisointia varten
  • Käytä t-SNE:tä ja UMAP:ia visualisointiin
  • Tulkitse visuaalisia klustereita

Haaste: 3 072 ulottuvuutta

Upotukset elävät 3 072-ulotteisessa avaruudessa, jota kukaan ei pysty visualisoimaan suoraan. Niiden tarkastelu vaatii projisoimista kahteen tai kolmeen ulottuvuuteen. Tämä hyväksyy jonkin verran tiedon menetystä, mutta säilyttää oleellisen rakenteen: lähekkäin olleet pisteet pysyvät lähekkäin. Tämä on tehokas diagnostiikkatyökalu. Eriytyvä klusteri tai päällekkäiset teemat hyppäävät silmään heti, kun taas aggregoidut mittarit saattavat missata ne kokonaan.

Dimensioitten vähentäminen t-SNE:llä

t-SNE (t-distributed Stochastic Neighbor Embedding) on klassinen menetelmä. Se löytää 2D-asettelun, jossa jokainen piste säilyttää alkuperäisen naapurustonsa. Alla oleva esimerkki rakentaa tarkoituksella korpuksen, jossa on kolme erillistä teemaa – tekoäly, ruoanlaitto ja urheilu – jotta voit varmistaa projektion palauttavan odotetun rakenteen.

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

Kolme parametria ohjaavat tulosta. perplexity tasapainottaa paikallista ja globaalia rakennetta; tyypilliset arvot ovat 5–50. Tässä se on asetettu arvoon 4, koska korpuksessa on vain kaksitoista pistettä, ja naapureita suurempi perplexity tuottaisi epäjohdonmukaisen projektion. n_iter määrittää optimointikierrosten määrän; minimi on 250, mutta ihanteellisesti yli 1 000. random_state varmistaa toistettavuuden: ilman sitä kaksi peräkkäistä ajoa tuottaisi erilaiset kuviot, mikä tekisi vertailun mahdottomaksi.

Vähentäminen UMAPilla

UMAP (Uniform Manifold Approximation and Projection) on usein suositumpi kuin t-SNE, koska se on nopeampi ja säilyttää globaalin rakenteen paremmin. Toisin sanoen kahden klusterin välinen etäisyys UMAP-kuvaajassa merkitsee jotain, kun taas t-SNE:ssä se on mielivaltainen.

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

Seuraava taulukko tiivistää näiden kahden menetelmän kompromissit.

Kriteriumit-SNEUMAP
NopeusHidas (O(n²))Nopea
Globaali rakenneSäilyy heikostiSäilyy hyvin
ToistettavuusVaihtelevaVakaa
Parametritperplexityn_neighbors, min_dist

Interaktiivinen 3D-visuaalisointi

Muutaman sadan pisteen korpuksessa staattinen kuva muuttuu lukukelvottomaksi: etiketit menevät päällekkäin, etkä pysty erottamaan, mikä teksti vastaa mitäkin pistettä. Plotly ratkaisee tämän siirtämällä tiedot työkaluvihjeisiin ja mahdollistamalla pistepilven pyörittämisen.

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

Tuloksena oleva HTML-tiedosto on valmis jaettavaksi. Se on erinomainen tapa näyttää liiketoimintatiimille, miten heidän dokumenttinsa jakautuvat, ilman että tarvitsee kirjoittaa riviäkään koodia.

Dimensioitten vähentämisen vaikutuksen visualisointi

Luvussa 2 todettiin, että vektorin typistäminen 256 ulottuvuuteen säilyttää noin 88 % sen laadusta. Tämä luku pysyy abstraktina, kunnes näet sen käytännössä. Generoimalla saman korpuksen neljällä eri koolla ja projisoimalla jokainen versio havaitset suoraan, milloin klusterit alkavat koskettaa toisiaan. Tämä antaa sinulle mahdollisuuden tehdä päätöksiä näyttöön perustuen yleisen säännön sijaan.

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

Varoitus ennen näiden kuvioiden tulkitsemista: projektio vääristää aina. Graafissa eristynyt piste ei välttämättä ole eristynyt alkuperäisessä avaruudessa, ja kaksi 2D:ssä yhteen liimautunutta klusteria voivat olla täysin erillään 3 072 ulottuvuudessa. Visualisointi auttaa muodostamaan hypoteesin, mutta ei koskaan validoimaan sitä. Validointi perustuu mittareihin, joita käsittelemme luvussa 10.

Keskeiset asiat

  • t-SNE ja UMAP projisoivat upotukset 2D/3D-muotoon visualisointia varten
  • UMAP on yleensä suositumpi nopeutensa ja uskollisuutensa ansiosta
  • Plotly mahdollistaa interaktiiviset 3D-visuaalisoinnit
  • Visualisointi auttaa validoimaan upotusten laatua ja havaitsemaan poikkeavuuksia