Curs 12

Invățarea nesupervizată
Clustering
Slide-uri adaptate după Andrew Ng
 Sumar

1. Algoritmul K-means clustering

2. Principal Component Analysis (PCA)
Invățarea nesupervizată - Clustering

Invățam din date ne etichetate

Algoritmii găsesc o stuctură in date -

Clustering
Aplicații Clustering
K – means Clustering algoritm
 K – means Clustering algoritm
Algoritm iterativ
Input:
Setul de date de antrenare {x(1),x(2), x(3)…x(m)} – vector n dimensional
K numarul de clustere

Initializez random K centroizi ai clusterelor -

Repet{
for i =1 to m (pentru fiecare data de antrenare)
c(i):= indexul centroidului clusterului cel mai aproape de x(i)
for k =1 to K
μk:= media punctelor asignate culsterului k
}

c(i) e de fapt k care min || xi- μk||2 - ia valori de la 1 la K

Daca avem un centroid cu nici un pct asignat atunci eliminam acest cluster
sau putem reinitializa random acel centroid al clusterului
 K – means ptr clustere neseparabile

Exemplu de segmentarea pietii: - un producător de tricouri vrea să

proiecteze și să vânda tricouri de trei dimensiuni, S, M și L.

K-means va separa datele în mai multe segmente și se vor putea

proiecta produse separate S, M și L.
 K-means Obiectiv de optimizare/ Functia de Cost
Stiind care este obiectivul de optimizare al k-means:
- ne va ajuta să depanăm algoritmul de învățare și să ne asigurăm că k-
means rulează corect.
- putem folosi acest lucru pentru a ajuta k-means să găsească costuri mai
bune și să evite optimul local.

In k-means trebuie sa tinem cont de doua seturi de variabile:

c(i):= indexul/numarul clusterului (1,2...K) unde un datele x (i) se vor asigna
μk:= locatia centroidul culsterului k
x(i)= 5 c(i) =5 μc(i)= μ5
 Cum initializam centroizii clusterelor ?
Initializare random :
K (nr de centroizi ai clusterelor) < m (dim setului de date de antrenare)
Aleg random K date de antrenare
Setez μ1, μ2, ... μk sa fie egale cu aceste K date

Exemple: K=2 μ1= x(i) , μ2= x(j)

Algoritmul va converge catre solutii diferite in functie de initializare

 Cum initializam centroizii clusterelor ?
Initializare random “fericită” - optim global

Algoritmul va converge catre solutii diferite – initializare “nefericită” -

omptim local prost al functiei J
 Soluția- cum initializam centroizii clusterelor ?
Pentru ca algoritmul K-means sa gaseasca cea mai buna clusterizare
trebuie sa incercam multiple initializari random si sa rulam algoritmul
de mai multe ori :

For i=1 to 100 {

Initializez random.
Rulez K-means, aflu valorile
Calculez Functia de Cost ( Distortion Cost Function)
J( )
}

O sa avem 100 de moduri diferite de a face clusterizarea datelor ( si 100

de valori ale functiei J ) o sa alegem varianta care are cea mai mica
valoare a Functiei de Cost J → clusterizarea optima

Nr mic de clustere K intre 2 si 10 - multiple initializari random

K > 10 o singura initializare random ne va da o solutie destul de buna
Expectation-Maximization K – means
 Detalii de implementare Scikit-Learn
Dacă se întâmplă să știți aproximativ unde ar trebui să fie centroizii (de
exemplu, dacă ați rulat un alt algoritm de clustering), puteți seta
hiperparametru init la un NumPy array ce conține lista de centroizi și
setați n_init la 1:

good_init = np.array([[-3, 3], [-3, 2], [-3, 1], [-1, 2], [0, 2]])
kmeans = KMeans(n_clusters=5, init=good_init, n_init=1)

Hiperparametrul n_init controleaza numărul aleatoriu de initializari :

implicit este 10, ceea ce înseamnă că întreg algoritmul rulează de 10
ori când apelați fit() , iar Scikit-Learn păstrează cea mai bună soluție.

Cea mai buna solutie, cea mai mica valoare a Functiei de Cost care in
Scikit este parametrul inertia

In[]: kmeans.inertia_
Out[]: 211.59853725816856
 Cum alegem numarul de clustere, K ?

Vizualizand datele numarul de clustere este ambiguu K=4 ? sau K=2 ?

Nu avem un raspuns “corect” - trebuie sa facem procesul automatic

 Alegem valoarea lui K - Metoda Elbow

Metoda Elbow (K=3) ambiguu 3? sau 5 ?

Functia de Cost (Inerția) nu este o măsură bună de performanță când

încercam să alegem k pentru că continuă să scadă pe măsură ce cre ștem k.
Cu cât sunt mai multe clustere, cu atât fiecare instanță va fi mai aproape
de cel mai apropiat centroid și inerția va fi mai mică.
 Alegem valoarea lui K
Rulam K-means cu un anumit scop, evaluam ptr o anumită măsură

K=3 ( S, M, L) sau K=5 (XS, S, M, L, XL)

K-means ptr compresia imaginilor. Cum aleg K in functie de calitatea

imaginilor? sau cat de bine fac compresia ?
 Alegem valoarea lui K – Silhouette Analysis
Calculam silhouette score ca media coeficientului silhouette din toate
instantele
coeficientul silhouette ptr o instanta = (b-a)/max(a,b)
a- este distanța medie față de celălalte instanțe din același cluster
(the mean intra-cluster distance)
b- este distanța medie până la instanțele celui mai apropiat cluster
(the mean nearest-cluster distance)

Coeficientul silhouette ia valori [-1, 1 ]:

- apropiat de +1 înseamnă că instanța este bine în interiorul propriului
cluster și departe de alte clustere
- apropiat de 0 înseamnă că este aproape de granița unui cluster
- apropiat de –1 înseamnă că este posibil ca instanța să fi fost atribuită
unui cluster greșit.

In[]: from sklearn.metrics import silhouette_score

In[]: silhouette_score(X, kmeans.labels_)
Out[]: 0.6819938690643478
 Alegem valoarea lui K – Silhouette Analysis

O vizualizare și mai informativă se obține cu Silhouette Diagram -

trasam coeficientul siluetei pentru fiecare instanța sortat după clusterul
căruia îi este alocat si prin valoarea coeficientului.

Fiecare diagramă conține o formă de cuțit per grup:

-înălțimea formei indică numărul de instanțe pe care le conține clusterul
-lățimea reprezintă coeficienții siluetei sortați ai instanțelor din cluster
(mai lat este mai bine).
-linia întreruptă verticală reprezintă scorul silhouettei = mean silhouette
coefficient
 Alegem valoarea lui K – Silhouette Analysis

k=3 si k=6 “bad ”(coeficient < scorul) instante prea apropiate de alte
clustere
K=4 si k=5 “good” (instantele trec de linia verticala→1) il aleg pe k=5
clusterele au aceeasi dimensiune
 Reducerea dimensionalității

Compresia datelor
- reducem reduntanta caracteristicilor
- crestem viteza de calcul al algoritmilor de invatare

Vizualizarea datelor
 Reducerea dimensionalității
Date 2D → 1D reducem reduntanta caracteristicilor

Gasim directia de proiectie a datelor : x(1), x(2)...x(m) - R2 z(1),z(2)...z(m) - R

- gasim locatia/pozitia datelor pe linia de proiectie (1D)
 Reducerea dimensionalității 3D → 2D

Gasim directia de proiectie a datelor : x(1), x(2)...x(m) - R3 z(1),z(2)...z(m) - R2

- gasim locatia/pozitia datelor pe planul de proiectie (2D : z1 si z2)
 Reducerea dimensionalității
Set de date imens pentru fiecare tara avem 50 de features x(i)- R50

Gasim directia de proiectie a datelor : x(1), x(2)...x(m) - R50 z(1),z(2)...z(m) R2

- gasim locatia/pozitia datelor pe planul de proiectie
 Reducerea dimensionalității
Reducem cele 50 de features x(i)- R50 la z(i) [z1, z2] – R2 50D → 2D

Singapore
USA

Noile features (axe de reprezentare)

z1 – dimensiunea tarii- actibvitatea economica GDP
z – GDP per persoana
 Principal Component Analysis (PCA)

Eroare de proiectie

PCA gaseste o suprafata de dimensiune redusa (linie) pe care se

proiecteaza datele astfel incat suma erorilor de proiectie sa fie
minima.

Inainte de PCA trebuie sa facem : mean normalization si feature scaling

 Principal Component Analysis (PCA)

2D → 1D PCA gaseste directia – vectorul u(i) pe care se proiecteaza

datele astfel incat suma erorilor de proiectie sa fie minima.

3D → 2D PCA gaseste directia planului de proiectie a datelor.

Reducerea de la n-dimensiuni la k-dimensiuni PCA gaseste suprafata

definita de k-vectori u(1), u(2)...u(k) (subspatiul liniar definit de k veectori)
 Principal Component Analysis (PCA)
PCA identifică un set de axe ortogonale, axe ce reprezintă cea mai mare
cantitate de variație în setul de date antrenament (directiile dominante ).

Cum alegem directia hyperplanului de proiectie?

Alegem prima axa care reprezinta variatia maxima a datelor proiectate
(c1) si urmatoarea (c2) pe directia ortogonala pe prima axa si tot asa.

Axa (i) – componenta principala PC (i) → SVD

 Singular Value Decomposition (SVD)
Metoda SVD este data-driven si ofera o descompunere matriceala stabila
numeric (ptr orice matrice reala R sau complexa C ) - generalizează
descompunerea in vectori si valori proprii (eigenvectors/eigenvalues)

SVD oferă o reprezentare ierarhică a datelor în termenii unui nou sistem de

coordonate pentru a reprezenta date corelate de dimensiuni mari.

Xn x m = [ x1 x2 xk ...xm] - matrice complexa Xn x m = UΣV*

(* =conjugata complexa)

Un xn – matrice unitara UU*= I – left singular vector a matricii X

Σn x m – matrice diagonala cu valori pozitive pe diagonala principala –
valori singulare
Vm x m - matrice unitara VV*= I - right singular vector a matricii X

Ptr X matrice reala U*=UT si V*=VT Xn x m = UΣVT U si V au coloane

ortonormale.
 Singular Value Decomposition (SVD)
EconomySVD n> m, Σ are m valori nonzero pe diagonala principala
 Singular Value Decomposition (SVD)
SVD legat de matricea de corelare – produsul scalar (dot product)
X X* - pe linii X*X - pe coloane

Coloanele matricii U reprezinta eigenvectorii matricii de corelare X X* -

captează corelarea pe coloane

Coloanele matricii V reprezinta eigenvectorii matricii de corelare X*X -

captează corelarea pe linii
 Principal Component Analysis (PCA)
Algoritmul PCA -gasim/calculam componentele principale:
1. Centram datele: ne asiguram ca fiecare features are media zero ( facem
media pe linii si o scadem din X , X = X- xmean()

2. Calculam “matricea de covariantă” sigma =

3. Calculam eigenvectorii matricii sigma: [U , S , V] = svd(sigma)

4. Obtinem datele reduse z =XVk sau z= UkTX # proiectia pe hyperplan
Uk, Vk -primele k coloane din matricea U sau V definesc spatiul redus k-
dimensional Ureduced =Uk=U(:, 1:k)
In[]: import numpy as np
In[]: X_centrat = X - X.mean(axis=0)
In[]: U, S, Vt = np.linalg.svd(X_centered)
In[]: c1 = Vt.T[:, 0]
In[]: c2 = Vt.T[:, 1]
In[]:V2 = Vt.T[:, :2] # planul definit de primele 2 componente principale
In[]: z = X_centered.dot(V2) # z=XVk
 Principal Component Analysis (PCA)
In Scikit-Learn by default datele sunt centrate in algoritmul PCA

In[]: from sklearn.decomposition import PCA

# reduc dimensionalitatea setului de date la două dimensiuni

In[]: pca = PCA(n_components = 2)
In[]: X2D = pca.fit_transform(X)
In[]: pca.components_.T[:, 0] # vectorul primei componente principala

Atributul pca.components_ este de fapt transpusa matricii Vd

(coloanele = componentele principale PC)

In[]: pca.explained_variance_ratio_
Out[]:array([0.84248607, 0.14631839])

84.2% din variatia datelor e de-a lungul primei componente si 14.6%

variatia de-a lungul celei de-a doua componente
Reconstructia din Componentele Principale (PC)

X approx = Ureducez

dimensiune Xn = Un x k z k x 1
Cum aleg k - numarul Componentelor Principale
media patratica a erorilor de proiectie / variatia toala a datelor
aleg cel mai mic k care respecta relatia :

99% din variatia datelor e retinuta # 95% k < 0.05

Multe features sunt puternic corelate – datele se comprima mult.

[U, S, V] =svd(sigma) # S –matrice diagonala

aleg cea mai mica valoare a lui k pre care:

exemplu: k=3 (S11+S22+S 33) / (S11+S22+…..Smm) > 0.99

Atentie: Rulez PCA doar pe setul de antrenare!

 Detalii implementare PCA

Scikit-Learn folosește un algoritm stocastic numit PCA Randomizat

care găsește rapid aproximarea primelor k componente principale.

Trebuie sa setați hiperparametrul svd_solver la „randomized”

In[]: rnd_pca = PCA(n_components=154, svd_solver="randomized")

In[]: X_reduced = rnd_pca.fit_transform(X_train)

Daca doriti ca Scikit-Learn sa foloseasca full SVD, trebuie să setați

hiperparametrul svd_solver la "full" .
 Detalii implementare PCA

PCA necesita întregul set de date de antrenare să fie în memorie pentru ca

algoritmul să ruleze.

Incremental PCA (IPCA) vă permite să împărțiți setul de antrenare în

mini-seturi și să rulați algoritm IPCAcu câte un mini-set.

In[]: import numpy as np

In[]: from sklearn.decomposition import IncrementalPCA

In[]: n_sets = 100

In[]: inc_pca = IncrementalPCA(n_components=154)
In[]: for X_set in np.array_split(X_train, n_sets):
In[]: inc_pca.partial_fit(X_set) # nu . fit
In[]: X_reduce = inc_pca.transform(X_train)
 Detalii implementare PCA

Scikit-Learn folosește un algoritm stocastic numit PCA Randomizat

care găsește rapid aproximarea primelor k componente principale.

Trebuie sa setați hiperparametrul svd_solver la „randomized”

In[]: rnd_pca = PCA(n_components=154, svd_solver="randomized")

In[]: X_reduced = rnd_pca.fit_transform(X_train)

Daca doriti ca Scikit-Learn sa foloseasca full SVD, trebuie să setați

hiperparametrul svd_solver la "full" .
 Bibliografie

Andrew Ng- Machine learning -Coursera

https://www.coursera.org/learn/machine-learning/lecture/93VPG/k-m
eans-algorithm

https://scikit-learn.org/stable/auto_examples/cluster/plot_kmeans_si
lhouette_analysis.html