Lidsky řečeno
Dostaneš krabici smíchaných ponožek a nikdo ti neřekl, kolik je v ní druhů. Začneš je třídit na hromádky podle toho, co se podobá. Žádný štítek ti nevysvětlil, co je „sportovní“ nebo „vlněná“, hromádky vznikly jen z podobnosti. A když ti někdo dá tabulku se sto sloupci, protože se mu to „může hodit“, zjistíš, že pár sloupců říká skoro totéž. Zbytek můžeš shrnout do dvou tří čísel a o moc nepřijdeš. První úkol je shlukování, druhý PCA. Oba patří do učení bez učitele.
Data bez štítků
Dosud jsme měli dva sloupce různého druhu: příznaky X a správnou odpověď y. Model se učil, jak z X odhadnout y. Tomu se říká učení s učitelem, protože odpovědi hlídá někdo, kdo je zná.
V praxi je správná odpověď často drahá nebo neexistuje. Nikdo ti předem nerozdělil zákazníky do skupin, nikdo neoznačil, které články mají podobné téma. Učení bez učitele pracuje jen s X a hledá v něm tvar. Má dva hlavní úkoly:
- Shlukování (clustering) rozdělí řádky do skupin podobných si případů.
- Snižování rozměru (dimensionality reduction) shrne mnoho sloupců do několika, aby se ztratilo co nejméně informace.
S učitelem, nebo bez?
Roztřiď úlohy podle toho, jestli k trénování potřebuješ správné odpovědi.
K-means: hromádky kolem středů
K-means je nejznámější shlukovací algoritmus. Předem mu řekneš, kolik shluků chceš (k), a on opakuje dva kroky:
- Přiřazení: každý bod se přidá ke shluku, jehož střed (centroid) je mu nejblíž.
- Přepočet: každý střed se přesune do průměru bodů, které k němu právě patří.
Začíná se náhodnými středy a opakuje se, dokud se přiřazení mění. Algoritmus se vždy zastaví, protože každý krok součet čtverců vzdáleností k přiřazeným středům jen zmenšuje nebo nechává stejný.
Nejdřív malé tipnutí na druhý krok. Střed je obyčejný průměr po sloupcích.
import numpy as np
body = np.array([[1, 1], [2, 3], [9, 9]])
print(body[:2].mean(axis=0))
[1.5 2. ]
Teď celý algoritmus v NumPy. Řádek se body[:, None, :] - stredy[None, :, :] využívá broadcasting: z (n, 2) a (k, 2) vyrobí (n, k, 2), tedy rozdíl každého bodu od každého středu najednou.
import numpy as np
rng = np.random.default_rng(3)
skutecne_stredy = np.array([[0.0, 0.0], [5.0, 0.0], [2.5, 4.5]])
body = np.vstack([c + rng.normal(0, 0.8, size=(40, 2)) for c in skutecne_stredy])
def kmeans(body, k, seed=0, max_iter=50):
gen = np.random.default_rng(seed)
stredy = body[gen.choice(len(body), k, replace=False)]
for krok in range(max_iter):
vzdalenosti = np.linalg.norm(body[:, None, :] - stredy[None, :, :], axis=2)
stitky = vzdalenosti.argmin(axis=1)
nove = np.array([
body[stitky == j].mean(axis=0) if np.any(stitky == j) else stredy[j]
for j in range(k)
])
if np.allclose(nove, stredy):
break
stredy = nove
return stitky, stredy, krok + 1
stitky, stredy, kroku = kmeans(body, 3)
print("kroků do ustálení:", kroku)
print("velikosti shluků:", np.bincount(stitky))
print("nalezené středy:")
print(np.round(stredy, 2))
kroků do ustálení: 4 velikosti shluků: [40 40 40] nalezené středy: [[ 5.09 0.01] [-0.05 -0.1 ] [ 2.38 4.68]]
Středy vyšly blízko těm, ze kterých jsme data vyráběli, i když je algoritmus neznal. Čísla shluků (0, 1, 2) jsou ale jen pořadí. Při jiném náhodném startu mohou být prohozená, a tak se dívej na to, co patří k sobě, ne na samotná čísla.
Nejbližší střed
Napiš funkci prirad(body, stredy), která vrátí pole s číslem nejbližšího středu pro každý bod. Vzdálenost je obyčejná eukleidovská.
import numpy as np
def prirad(body, stredy):
return np.zeros(len(body), dtype=int)
Součet čtverců vzdáleností
Kvalitu shlukování měří inertie: součet druhých mocnin vzdáleností každého bodu od středu jeho shluku. Napiš funkci inertie(body, stitky, stredy).
import numpy as np
def inertie(body, stitky, stredy):
return 0.0
Střed, který není bod
Funkce má z přiřazených štítků spočítat nové středy. Na jednorozměrných datech vypadala správně, na plošných vrací jedno číslo na shluk místo dvou souřadnic.
Slož jeden krok k-means
Slož funkci, která z bodů a aktuálních středů udělá štítky a nové středy.
Krok po kroku sleduj, jak se body přebarvují a středy putují. Zkus jiný počet shluků a jiný náhodný start.
Kolik shluků
K-means se musíš na k zeptat předem a algoritmus sám nepozná, jestli je správně. Nejde minimalizovat inertii: s víc shluky vždycky klesá a při k rovném počtu bodů je nulová. Používají se dvě pomůcky:
- Loket (elbow): nakresli inertii pro rostoucí
ka hledej místo, od kterého už klesá jen pozvolna. - Silhouette: pro každý bod
(b − a) / max(a, b), kdeaje průměrná vzdálenost k bodům vlastního shluku abprůměrná vzdálenost k nejbližšímu cizímu shluku. Vyjde číslo mezi −1 a 1. Průměr přes všechny body dává jedno skóre, čím vyšší, tím jasněji jsou shluky oddělené.
from sklearn.cluster import KMeans
from sklearn.datasets import make_blobs
from sklearn.metrics import silhouette_score
X, _ = make_blobs(n_samples=300, centers=4, cluster_std=0.9, random_state=7)
print(" k inertie silhouette")
for k in range(2, 9):
km = KMeans(n_clusters=k, n_init=10, random_state=0).fit(X)
print(f"{k:>2} {km.inertia_:7.1f} {silhouette_score(X, km.labels_):10.2f}")
k inertie silhouette 2 8941.6 0.60 3 2402.8 0.78 4 462.8 0.83 5 414.0 0.72 6 370.8 0.58 7 326.5 0.46 8 282.6 0.36
Inertie klesá pořád, ale po čtvrtém shluku se zlom zmírní a silhouette je právě u k = 4 nejvyšší. Data jsme vyrobili se čtyřmi středy, takže víme, že to sedí. V praxi to nevíš. Loket bývá rozmazaný a silhouette jen dobré vodítko. Poslední slovo má vždy otázka, jestli shluky dávají obchodní smysl: pokud z nich nejde nic udělat, je jedno, že mají pěkné skóre.
Pasti k-means
K-means má tři slabiny, které ti rozbijí výsledek, i když kód poběží bez chyby.
První: měřítko. Algoritmus počítá vzdálenosti. Příjem v korunách se pohybuje v desítkách tisíc, věk jen v desítkách, takže věk skoro nevadí. Ukázka rozdělí zákazníky do dvou skupin, přičemž skutečné skupiny dělí jen věk. Skóre shoda je podíl správně zařazených bodů (číslování shluků je libovolné, proto bereme lepší ze dvou přiřazení).
import numpy as np
from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler
rng = np.random.default_rng(0)
vek = np.concatenate([rng.normal(25, 3, 100), rng.normal(55, 3, 100)])
prijem = rng.normal(40000, 12000, 200)
X = np.column_stack([vek, prijem])
skutecne = np.repeat([0, 1], 100)
def shoda(stitky):
return max(np.mean(stitky == skutecne), np.mean(stitky != skutecne))
bez = KMeans(2, n_init=10, random_state=0).fit_predict(X)
se = KMeans(2, n_init=10, random_state=0).fit_predict(StandardScaler().fit_transform(X))
print(f"bez standardizace: {shoda(bez):.2f}")
print(f"se standardizací: {shoda(se):.2f}")
bez standardizace: 0.56 se standardizací: 1.00
Druhá: tvar. Střed a vzdálenost dávají kulaté shluky podobné velikosti. Dva proplétané půlměsíce jsou pro k-means problém. Proti tomu se používá DBSCAN, který nehledá středy, ale husté oblasti: bod s dost sousedy v okruhu eps je jádro a zapojuje do shluku všechny, kdo se k němu dají dosáhnout. Samotáři nepatří nikam a dostanou štítek -1. Počet shluků si DBSCAN zjistí sám. Výsledek porovnáváme se skutečným rozdělením pomocí adjusted Rand indexu (ARI): 1 je shoda, kolem 0 náhoda.
from sklearn.cluster import DBSCAN, KMeans
from sklearn.datasets import make_moons
from sklearn.metrics import adjusted_rand_score
X, y = make_moons(300, noise=0.06, random_state=0)
modely = [
("k-means", KMeans(2, n_init=10, random_state=0)),
("DBSCAN", DBSCAN(eps=0.2, min_samples=5)),
]
for nazev, model in modely:
stitky = model.fit_predict(X)
print(f"{nazev:8} ARI {adjusted_rand_score(y, stitky):.2f}")
k-means ARI 0.23 DBSCAN ARI 1.00
Třetí: náhodný start. Podle počátečních středů vyjde jiné rozdělení, protože algoritmus uvízne v nejbližším lokálním minimu. Proto má scikit-learn parametr n_init, který celé shlukování zopakuje a nechá nejlepší výsledek (nejnižší inertii). Výchozí inicializace k-means++ navíc vybírá počáteční středy daleko od sebe.
Máš tabulku zákazníků: věk, roční útrata v korunách a počet návštěv za měsíc. Co uděláš před k-means?
K-means počítá vzdálenosti, takže sloupec s největšími čísly rozhoduje o skoro všem. Standardizace dá všem příznakům srovnatelnou váhu.
Co vrátí DBSCAN u bodu, který nepatří do žádné husté oblasti?
Samotné body se neřadí k žádnému shluku a dostanou -1. To se hodí třeba při hledání odlehlých hodnot.
PCA: nové osy podle rozptylu
Teď druhý úkol. Představ si výšku a váhu lidí. Obě čísla spolu souvisí: vyšší lidé bývají těžší. Mrak bodů tvoří protáhlou elipsu. PCA (analýza hlavních komponent) najde osy, které ten tvar sledují:
- První komponenta míří tam, kde se data rozptylují nejvíc.
- Druhá komponenta je kolmá na první a bere největší zbytek rozptylu.
- A tak dál. Komponenty jsou seřazené podle toho, kolik rozptylu vysvětlí.
Když ponecháš jen první komponentu, zahodíš sloupec, který nesl málo informace, a zbytek zůstane. Takto se dá z mnoha příznaků udělat několik.
Výpočet je krátký, když máš SVD (rozklad na singulární čísla). Data se nejdřív vycentrují (odečte se průměr každého sloupce), pak np.linalg.svd vrátí v řádcích Vt směry os a v s jejich „sílu“. Podíl rozptylu komponenty je s² / součet s².
import numpy as np
rng = np.random.default_rng(1)
n = 200
vyska = rng.normal(175, 8, n)
vaha = 0.9 * (vyska - 175) + 75 + rng.normal(0, 4, n)
X = np.column_stack([vyska, vaha])
Xc = X - X.mean(axis=0)
U, s, Vt = np.linalg.svd(Xc, full_matrices=False)
podil = s**2 / np.sum(s**2)
print("osy komponent (řádky, bez znaménka):")
print(np.round(np.abs(Vt), 2))
print("podíl rozptylu:", np.round(podil, 3))
z = Xc @ Vt[0]
zpet = np.outer(z, Vt[0]) + X.mean(axis=0)
chyba = np.mean(np.sum((X - zpet) ** 2, axis=1))
print(f"chyba po zahození 2. komponenty: {chyba:.2f}")
print(f"s[1]**2 / n: {s[1]**2 / n:.2f}")
osy komponent (řádky, bez znaménka): [[0.69 0.72] [0.72 0.69]] podíl rozptylu: [0.943 0.057] chyba po zahození 2. komponenty: 6.53 s[1]**2 / n: 6.53
Poslední dva řádky se rovnají, a to není náhoda. Chyba, kterou přineseš zahozením komponent, je přesně rozptyl, který v nich byl. Z toho plyne praktické pravidlo: zahazuj komponenty, dokud ti zbytek vysvětluje dost rozptylu (například 90 až 95 %).
Znaménko komponenty je libovolné: osa v i −v označuje tutéž přímku. Různé knihovny vrací různá znaménka, proto jsme výše vypsali absolutní hodnoty.
Podíl rozptylu komponent
Napiš funkci podil_rozptylu(X), která vrátí pole s podílem rozptylu pro každou komponentu. Nejdřív data vycentruj, pak použij SVD.
import numpy as np
def podil_rozptylu(X):
return np.zeros(X.shape[1])
Čtyři kroky PCA
Doplň rozklad a promítnutí dat na první dvě komponenty.
Otáčej osami nad mrakem bodů. První komponenta je ta poloha, kde je rozptyl promítnutých bodů největší.
PCA se scikit-learn a číslice
Ve scikit-learn je PCA třída s fit a transform, takže zapadá do pipeline. Data centruje sama, ale neškáluje je. Zkusíme ji na datech o rukou psaných číslicích: každý obrázek má 8 × 8 = 64 pixelů. Kolik komponent stačí, abychom si ponechali dané množství rozptylu?
import numpy as np
from sklearn.datasets import load_digits
from sklearn.decomposition import PCA
X, y = load_digits(return_X_y=True)
pca = PCA().fit(X)
kumulativne = np.cumsum(pca.explained_variance_ratio_)
for cil in [0.80, 0.90, 0.95, 0.99]:
print(f"{cil:.0%} rozptylu: {int(np.searchsorted(kumulativne, cil)) + 1} komponent z {X.shape[1]}")
zkracene = PCA(n_components=0.95).fit(X)
print("PCA(0.95) samo vybralo:", zkracene.n_components_)
80% rozptylu: 13 komponent z 64 90% rozptylu: 21 komponent z 64 95% rozptylu: 29 komponent z 64 99% rozptylu: 41 komponent z 64 PCA(0.95) samo vybralo: 29
Zkratka PCA(n_components=0.95) nechá libovolně komponent tak, aby se zachovalo 95 % rozptylu. Menší rozměr přináší menší a rychlejší modely, ale hlavně jde obrázek vykreslit, když si necháš dvě komponenty.
Pozor, kam PCA patří. Počítá se z dat, takže když ji naučíš na celé tabulce před rozdělením na trénink a test, dojde k úniku dat stejně jako u výběru příznaků v lekci Pipelines a únik dat. Patří dovnitř pipeline:
from sklearn.datasets import load_digits
from sklearn.decomposition import PCA
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import cross_val_score
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
X, y = load_digits(return_X_y=True)
modely = {
"všech 64 pixelů": make_pipeline(StandardScaler(), LogisticRegression(max_iter=2000)),
"PCA na 20 komponent": make_pipeline(StandardScaler(), PCA(20), LogisticRegression(max_iter=2000)),
"PCA na 5 komponent": make_pipeline(StandardScaler(), PCA(5), LogisticRegression(max_iter=2000)),
}
for nazev, model in modely.items():
skore = cross_val_score(model, X, y, cv=5)
print(f"{nazev:22} {skore.mean():.3f}")
všech 64 pixelů 0.920 PCA na 20 komponent 0.899 PCA na 5 komponent 0.771
Dvacet komponent z 64 stojí jen asi dvě procenta přesnosti, pět už je znát hodně. Obě techniky se dají spojit: nejdřív PCA odstraní šum a zmenší rozměr, potom k-means dělí do skupin. Tady nás zajímá, jestli algoritmus bez znalosti štítků znovu objeví deset číslic. Shodu se skutečností měříme opět indexem ARI.
from sklearn.cluster import KMeans
from sklearn.datasets import load_digits
from sklearn.decomposition import PCA
from sklearn.metrics import adjusted_rand_score
X, y = load_digits(return_X_y=True)
Z = PCA(n_components=20, random_state=0).fit_transform(X)
stitky = KMeans(10, n_init=10, random_state=0).fit_predict(Z)
print(f"ARI shluků proti skutečným číslicím: {adjusted_rand_score(y, stitky):.2f}")
ARI shluků proti skutečným číslicím: 0.67
Žádné štítky, a přesto algoritmus významně převyšuje náhodu. Neznamená to, že ví, co je „trojka“. Našel skupiny, které si jsou obrázky podobné, a někdy se shodují s číslicemi, jindy je pletou.
Pod kapotou · PCA, SVD a co dál
PCA je totéž co vlastní vektory kovarianční matice Xcᵀ Xc / (n − 1). SVD je ale numericky stabilnější, protože nemusí matici vůbec násobit, a proto ho používá i scikit-learn. Vysvětlený rozptyl komponenty je s² / (n − 1).
PCA je lineární: hledá přímky a roviny. Když data leží na zakřivené ploše (třeba spirále), lineární projekce ji zploští. Pro vizualizaci takových dat se používají t-SNE a UMAP, které zachovávají okolí bodů, ne rozptyl. Mají ale důležité omezení: vzdálenosti mezi vzdálenými shluky v obrázku nic neznamenají, a tak z nich nedělej závěry o velikosti či blízkosti skupin. Cíl k-means (inertie) má mnoho lokálních minim, proto se spouští víckrát. Pokud potřebuješ skupiny různých tvarů a velikostí, zkus Gaussian mixture (sklearn.mixture.GaussianMixture), která shluk popisuje rozdělením a každému bodu dá pravděpodobnost příslušnosti místo tvrdého štítku.
Který pojem k čemu patří?
Spoj pojem s tím, co dělá.