Aprenentatge no supervisat

• Tipologia
• Agrupament (clustering)
  • Supervisat vs. no supervisat
  • Aplicacions de l’agrupament
• Agrupació amb K-means
  • Exemple numèric pas a pas
  • Aplicació pràctica
  • Funció de cost
  • Inicialització i mínims locals
    • Inicialització de centroides
    • Problema de mínims locals
  • Selecció de \(K\)
    • Mètode del colze
    • Selecció pràctica de \(K\)
  • Implementació amb scikit-learn
• Detecció d’anomalies (anomaly detection)
  • Per què és important?
  • Aplicacions habituals
  • Isolation Forest
    • Com funciona l’algoritme
    • Implementació amb scikit-learn
    • El paràmetre de contaminació
  • Avaluació i divisió de dades
    • Mètriques d’avaluació
  • Detecció d’anomalies vs aprenentatge supervisat
    • Taula comparativa
• Anàlisi de components principals
  • La maledicció de la dimensionalitat
  • Exemple senzill: cotxes
    • Exemple 1: dues característiques
    • Exemple 2: longitud i diàmetre de rodes
    • Exemple 3: longitud i alçada
  • Exemple amb més dimensions
  • Exemple amb països
  • PCA amb scikit-learn
  • Quants components conservar
  • Resum
• Errors comuns a evitar

Imagina que tens milions de clients però cap etiqueta que et digui qui són. O que gestiones una fàbrica i vols detectar peces defectuoses sense haver vist mai abans cap defecte. O que vols visualitzar dades amb 50 variables en un simple gràfic 2D.

L’aprenentatge no supervisat resol aquests problemes: descobreix patrons en dades sense necessitat d’etiquetes prèvies. Mentre que l’aprenentatge supervisat aprèn d’exemples etiquetats (spam/no spam, gat/gos), l’aprenentatge no supervisat explora les dades per trobar estructures ocultes pel seu compte.

Tipologia

L’aprenentatge no supervisat treballa amb dades sense etiquetes, buscant patrons o estructures ocultes en les dades.

Aquests són alguns tipus d’aprenentatge no supervisat:

• Clustering (Agrupació)

  • Objectiu: Agrupar dades en dos o més grups segons similituds
  • Exemple: Segmentar clients segons el seu comportament de compra

• Detecció d’anomalies

  • Objectiu: Identificar esdeveniments o transaccions inusuals
  • Exemple: Detectar frau en transaccions bancàries

• Reducció de dimensionalitat

  • Objectiu: Comprimir dades utilitzant menys variables
  • Exemple: Reduir la complexitat d’imatges mantenint la informació essencial

Agrupament (clustering)

Un algorisme d’agrupament analitza un conjunt de punts i troba automàticament grups (clústers) de punts semblants entre si.

Supervisat vs. no supervisat

Imaginem un conjunt de dades amb dues característiques, \(x_1\) i \(x_2\).

• Aprenentatge supervisat: tenim les entrades \(x\) i les etiquetes \(y\). Podem ajustar-hi, per exemple, una regressió logística o una xarxa neuronal que aprengui una frontera de decisió entre les classes.

• Aprenentatge no supervisat: només tenim les entrades \(x\). Quan les representem, només veiem punts (●), sense colors que indiquin la classe. Com que no podem dir a l’algorisme quina és la resposta correcta, li demanem que hi trobi estructura: per exemple, que les dades provenen de dos grups diferenciats. De cada grup en pot calcular el centroide, el punt central que representa la posició mitjana dels seus punts.

Aplicacions de l’agrupament

L’agrupament ajuda a descobrir patrons ocults sense etiquetes: agrupar notícies per temàtica, segmentar clients segons el seu comportament, agrupar persones amb una expressió genètica semblant o identificar galàxies a partir de cossos celestes.

Clustering sobre embeddings de LLM. Els LLMs poden transformar textos en embeddings que capturen el significat. Sobre aquests vectors s’hi pot aplicar K-means com amb qualsevol altre conjunt de dades numèriques: textos temàticament similars acaben al mateix clúster, sense haver definit les categories abans. Un cas típic és agrupar ressenyes o tiquets de suport per descobrir de quins temes parlen els clients.

Agrupació amb K-means

K-means és el mètode d’agrupament més utilitzat. Li diem quants clústers volem (K) i repeteix dues operacions fins que res no canvia:

1. Inicialització: col·loca \(K\) centroides (\(\mu_1, \mu_2, \dots, \mu_K\)) a l’atzar. Són només una suposició inicial, i no cal que sigui bona. Cada centroide té la mateixa dimensió que les dades.
2. Assignació: cada punt s’assigna al centroide més proper (amb la distància euclidiana). Amb K = 2, per exemple, cada punt passa a ser “vermell” o “blau”.
3. Actualització: cada centroide es mou a la mitjana dels punts que té assignats, una posició més representativa del seu grup.
4. Es repeteixen els passos 2 i 3. Quan els punts ja no canvien de clúster i els centroides deixen de moure’s, diem que K-means ha convergit.

Exemple numèric pas a pas

Dades: 4 punts en 2D amb \(K=2\) clústers: \(A=(1,1)\), \(B=(2,1)\), \(C=(4,3)\), \(D=(5,4)\).

Inicialització: Escollim aleatòriament \(\mu_1=(1,1)\) i \(\mu_2=(2,1)\) com a centroides inicials.

Iteració 1:

Assignació: Calculem la distància euclidiana de cada punt als dos centroides:

Actualització: Recalculem els centroides com la mitjana dels punts assignats:

• \(\mu_1 = A = (1, 1)\)
• \(\mu_2 = \frac{B + C + D}{3} = \frac{(2,1) + (4,3) + (5,4)}{3} = (3.67, 2.67)\)

Iteració 2:

Assignació: Amb els nous centroides \(\mu_1=(1,1)\) i \(\mu_2=(3.67, 2.67)\):

Actualització: Recalculem els centroides:

• \(\mu_1 = \frac{A + B}{2} = \frac{(1,1) + (2,1)}{2} = (1.5, 1)\)
• \(\mu_2 = \frac{C + D}{2} = \frac{(4,3) + (5,4)}{2} = (4.5, 3.5)\)

Convergència: Si executem una tercera iteració, els punts no canvien de clúster. L’algorisme ha convergit amb resultat: \({A, B}\) i \({C, D}\).

Si en algun moment un clúster es queda sense cap punt assignat, s’elimina o se’n reinicialitza el centroide a l’atzar.

Aplicació pràctica

K-means s’aplica sovint a dades que no estan clarament separades.
Exemple: disseny de samarretes petites, mitjanes i grans segons alçada i pes dels clients.

• Els punts poden variar contínuament sense clústers evidents.
• K-means amb K = 3 pot agrupar els punts en tres clústers representatius.
• Els centroides resultants indiquen les mesures més representatives per a cada talla.

K-means intenta optimitzar una funció de cost específica, i aquesta és la raó per la qual convergeix després de diverses iteracions.

Funció de cost

K-means optimitza una funció de cost anomenada funció de distorsió:

\[ J = \frac{1}{m} \sum_{i=1}^{m} | x_i - \mu_{C_i} |^2 \]

Aquesta fórmula mesura la mitjana de la distància al quadrat entre cada punt i el centroide del seu clúster. Com més petita sigui \(J\), més compactes són els clústers.

Per què funciona K-means?

• El pas d’assignació minimitza \(J\) respecte a les assignacions (cada punt va al centroide més proper).
• El pas d’actualització minimitza \(J\) respecte a les posicions dels centroides (la mitjana minimitza la suma de distàncies al quadrat).

Com que cada pas redueix o manté \(J\), l’algoritme sempre convergeix.

Inicialització i mínims locals

Inicialització de centroides

El primer pas de K-means és escollir ubicacions inicials \(\mu_1, \dots, \mu_K\).
La manera més comuna és seleccionar aleatòriament \(K\) exemples del training set.

Important: \(K \le m\), on \(m\) és el nombre d’exemples.

Problema de mínims locals

Diferents inicialitzacions poden produir clústers molt diferents, atrapats en mínims locals de la funció de cost \(J\). La solució és executar múltiples inicialitzacions:

1. Repetir K-means \(N\) vegades amb inicialitzacions aleatòries.
2. Calcular la funció de cost \(J\) per cada execució.
3. Seleccionar els centroides amb el menor cost.

Normalment \(N \in [50, 1000]\). Això millora l’agrupament i minimitza la distorsió.

Resumint:

• Escollir centroides inicials és crucial.
• Múltiples inicialitzacions redueixen el risc de mínims locals.
• Escollir el conjunt amb menor distorsió (\(J\)) dona un millor resultat final.

Selecció de \(K\)

L’algorisme K-means requereix com a entrada un paràmetre \(K\), el nombre de clusters que volem identificar. Decidir el valor correcte de \(K\) és sovint ambigu, ja que diferents observadors poden interpretar les mateixes dades de manera diferent.

Mètode del colze

Una tècnica habitual és el mètode del colze:

1. Executar K-means amb diversos valors de \(K\) (per exemple, de 1 a 10).
2. Plotar la inèrcia \(J\) (eix Y) en funció de \(K\) (eix X).

A mesura que \(K\) augmenta, \(J\) disminueix (més centroides → punts més a prop del seu centroide). El colze és el punt on la corba deixa de baixar ràpidament i s’aplana. Minimitzar \(J\) directament no funciona, ja que \(J\) disminueix amb més clusters.

Selecció pràctica de \(K\)

La millor manera de triar \(K\) és segons l’ús final dels clusters.

Exemples:

• Talles de samarretes: \(K=3\) → S, M, L; \(K=5\) → XS, S, M, L, XL. La decisió depèn del trade-off entre ajust i costos de producció.
• Compressió d’imatges: \(K\) determina qualitat vs espai ocupat.

Resumint:

• Escollir \(K\) depèn del propòsit i no sempre té una resposta única.
• El mètode del colze és útil però no infal·lible.
• Comparar diferents \(K\) segons la utilitat dels clusters és la millor estratègia.

Implementació amb scikit-learn

from sklearn.cluster import KMeans
from sklearn.datasets import make_blobs
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler

# Dades d'exemple: 300 punts en 2D que formen 3 grups
X, _ = make_blobs(n_samples=300, centers=3, random_state=42)

# Escalar primer: K-means fa servir distàncies
model = make_pipeline(StandardScaler(), KMeans(n_clusters=3, n_init=10, random_state=42))
model.fit(X)

kmeans = model[-1]                 # l'objecte KMeans dins del pipeline
labels = kmeans.labels_            # clúster de cada punt: [1 1 0 2 1 2 ...]
centers = kmeans.cluster_centers_  # posició dels centroides (en l'escala transformada)
inertia = kmeans.inertia_          # valor de J (funció de cost), també anomenat "inèrcia"

# Assignar punts nous al clúster més proper
print(model.predict([[-2.5, 9.0], [4.7, 2.0]]))  # [0 2]

El nom inèrcia ve de la física: mesura com es distribueixen els punts al voltant dels centroides. Com més compactes són els clústers, menor és.

Paràmetres principals:

• n_clusters: El nombre de clústers \(K\) que volem trobar.
• n_init: Nombre d’inicialitzacions aleatòries. L’algorisme s’executa n_init vegades amb diferents centroides inicials i retorna el millor resultat (el que té menor \(J\)). Valors típics: 10-100 per problemes petits, fins a 1000 per problemes crítics.
• random_state: Llavor per reproduïbilitat dels resultats.

Resum K-means: Agrupa dades en \(K\) clústers basant-se en distàncies. Itera entre assignar punts i moure centroides fins convergir. Executa múltiples vegades amb inicialitzacions diferents. Utilitza el mètode del colze o el context del problema per escollir \(K\).

Detecció d’anomalies (anomaly detection)

La detecció d’anomalies és una tècnica d’aprenentatge automàtic no supervisat que permet identificar observacions que difereixen significativament del comportament normal esperat. A diferència dels algoritmes supervisats, no necessitem grans quantitats d’exemples anòmals etiquetats per entrenar el model.

Per què és important?

En moltes aplicacions del món real, les anomalies són rares però crítiques:

• Fabricació de motors d’avió: Un motor defectuós pot tenir conseqüències catastròfiques. Necessitem detectar qualsevol comportament anòmal abans que l’avió voli.
• Detecció de frau financer: Les transaccions fraudulentes són poc freqüents (menys del 0.1% en targetes de crèdit), però cada frau no detectat representa pèrdues econòmiques.
• Monitoratge de servidors: Un servidor compromès o amb una fallada pot mostrar patrons de comportament inusuals en memòria, CPU o xarxa.

En tots aquests casos, tenim moltes dades de funcionament normal, però molt poques (o cap) mostra d’anomalies. Això fa que els mètodes tradicionals supervisats no siguin aplicables.

Aplicacions habituals

Isolation Forest

Isolation Forest és l’algoritme més utilitzat actualment per a detecció d’anomalies en aplicacions reals. La seva idea central és molt intuïtiva: les anomalies són més fàcils d’aïllar que les observacions normals.

Imaginem que tenim un conjunt de punts en un espai 2D. La majoria estan agrupats en una regió densa, però alguns punts estan molt allunyats d’aquest cluster principal.

Si volem “aïllar” un punt normal (dins del cluster), necessitarem fer moltes divisions per separar-lo de la resta. En canvi, si volem aïllar un punt anòmal (lluny del cluster), amb poques divisions ja l’haurem separat completament.

Aquesta és exactament la lògica que utilitza Isolation Forest:

1. Construeix múltiples arbres de decisió aleatoris, com un Random Forest
2. Cada arbre intenta aïllar punts mitjançant divisions aleatòries
3. Mesura la longitud del camí necessària per aïllar cada punt
4. Camins curts → probable anomalia
5. Camins llargs → probable observació normal

Com funciona l’algoritme

Isolation Forest crea un “bosc” d’arbres d’aïllament. Cada arbre es construeix així:

1. Selecciona aleatòriament una característica \(x_j\) del conjunt de dades
2. Selecciona aleatòriament un valor de tall entre el mínim i el màxim de \(x_j\)
3. Divideix les dades en dos grups segons aquest tall
4. Repeteix recursivament per a cada subgrup fins que cada punt quedi aïllat

Exemple visual (arbre simplified):

                    [200 punts]
                         |
              x1 < 5.2? (tall aleatori)
                /              \
          [180 punts]      [20 punts] ← Grup petit (sospitós!)
              |                  |
       x2 < 3.1?          x2 < 8.5?
         /      \            /      \
    [120]    [60]        [18]     [2] ← Aïllat ràpidament!
      |         |          |        |
     ...       ...        ...    ANOMALIA

Un punt anòmal queda aïllat amb menys divisions (camí curt a l’arbre). Un punt normal requereix més divisions (camí llarg).

Implementació amb scikit-learn

from sklearn.ensemble import IsolationForest
import numpy as np

# Dades sintètiques: 200 punts normals agrupats i 10 anomalies escampades
rng = np.random.default_rng(42)
X_normal = rng.normal(size=(200, 2))
X_anomalies = rng.uniform(low=-4, high=4, size=(10, 2))
X = np.vstack([X_normal, X_anomalies])

# Entrenar Isolation Forest
clf = IsolationForest(
    contamination=0.05,  # Esperem ~5% d'anomalies
    random_state=42,
    n_estimators=100     # Nombre d'arbres al bosc
)
clf.fit(X)

# Predir: 1 = normal, -1 = anomalia
predictions = clf.predict(X)
anomalies = X[predictions == -1]

print(f"Anomalies detectades: {len(anomalies)}")                     # 11
print(f"De les 10 anomalies reals: {(predictions[-10:] == -1).sum()}")  # 8

En aquest cas sabem quines són les anomalies reals perquè les hem generat nosaltres. Dues de les deu han caigut a prop del grup normal i no es distingeixen; en canvi, tres punts normals de les vores s’han marcat com a anòmals.

El paràmetre de contaminació

El paràmetre més important d’Isolation Forest és contamination, que indica la proporció esperada d’anomalies al conjunt de dades.

• Valor per defecte: 0.1 (10%)
• Valor típic: Entre 0.01 i 0.1, depenent del problema
• Com ajustar-lo: Utilitzar un conjunt de validació amb algunes anomalies etiquetades (consulta Avaluació i divisió de dades)

Trade-off important:

• Contamination massa alt → Molts falsos positius (etiquetem normals com anòmals)
• Contamination massa baix → Molts falsos negatius (perdem anomalies reals)

Isolation Forest també dona una puntuació contínua per a cada observació (com més negativa, més anòmala), útil per prioritzar quins casos revisar primer. Com obtenir-la, i els avantatges i limitacions de l’algoritme, són a l’ampliació.

Avaluació i divisió de dades

Tot i que és una tècnica no supervisada, és molt útil tenir algunes anomalies etiquetades per mesurar el rendiment i per ajustar contamination. La divisió de les dades és diferent de l’aprenentatge supervisat:

• L’entrenament fa servir només exemples normals (o gairebé només normals).
• La validació i el test barregen normals i les poques anomalies etiquetades que tenim.

Les dues estratègies habituals per repartir-les, amb codi, són a Aprenentatge no supervisat: ampliació.

Mètriques d’avaluació

En detecció d’anomalies, la classe positiva (anomalia) és molt minoritària. Per això, la accuracy NO és una bona mètrica. Utilitzem precisió, recall i F1, que vam veure a Avaluar un classificador.

En funció del context, prioritzarem diferents mètriques:

• Detecció de frau bancari: Preferim alta recall (detectar tots els fraus), acceptant alguns falsos positius que es poden revisar manualment.
• Alertes mèdiques crítiques: Necessitem alta recall (no podem perdre cap cas greu), encara que generi falses alarmes.
• Control de qualitat manufacturera: Equilibri entre precision i recall per no descartar massa productes bons.

Detecció d’anomalies vs aprenentatge supervisat

Quan disposem d’algunes anomalies etiquetades, sorgeix una pregunta natural: per què no utilitzar aprenentatge supervisat en lloc de detecció d’anomalies?

La resposta depèn de diversos factors. Vegem-ne les diferències clau:

Taula comparativa

Quan les anomalies futures poden ser de tipus nous, o en tenim molt poques (menys d’unes 50), la detecció d’anomalies és millor opció que un classificador supervisat. Els criteris i exemples per triar, i com preparar les característiques, són a l’ampliació: quan usar detecció d’anomalies, quan usar aprenentatge supervisat i enginyeria de característiques.

Anàlisi de components principals

PCA (Principal Components Analysis) és un algoritme d’aprenentatge no supervisat que s’utilitza sovint per a la visualització i reducció de la dimensionalitat de dades. Si tens un conjunt de dades amb moltes característiques (per exemple 10, 50 o fins i tot milers), no és possible representar-lo directament en un gràfic.

El PCA busca noves característiques (anomenades components principals) que capturen la màxima variabilitat de les dades i redueixen el nombre de dimensions a dues o tres, fent possible la seva visualització i una millor comprensió.

Com es construeixen els components? Cada component principal és una barreja de les característiques originals, amb uns pesos triats perquè el primer component capturi tanta variació de les dades com sigui possible, el segon la màxima que quedi, i així successivament.

Això significa que les noves característiques no són cap de les originals, sinó mescles de totes elles, cosa que pot fer-les difícils d’interpretar.

La maledicció de la dimensionalitat

Una motivació important per usar PCA és evitar la maledicció de la dimensionalitat (curse of dimensionality).

Imagina que vols trobar el veí més proper d’un punt. En 2D, els punts estan relativament a prop i és fàcil identificar quins són similars. Però si afegeixes més dimensions, l’espai creix exponencialment: passa d’una línia a un quadrat, després a un cub, i així successivament. En aquest espai immens, les dades es tornen tan disperses que tots els punts acaben “igual de lluny” entre si. Algoritmes com K-NN o K-means, que depenen de distàncies, deixen de funcionar bé.

A més, per cobrir adequadament un espai amb moltes dimensions necessitem exponencialment més dades. I si no en tenim prou, els models troben patrons espuris que no generalitzen (sobreajust).

PCA ajuda comprimint les dades en un espai més petit i manejable, on les distàncies tornen a ser significatives.

Exemple senzill: cotxes

Suposem que tenim un conjunt de dades de cotxes de passatgers, amb moltes característiques: longitud, amplada, diàmetre de les rodes, alçada, etc.
Si volem reduir el nombre de característiques per a visualització, podem aplicar PCA.

Exemple 1: dues característiques

Suposem que tenim només dues característiques:

• \(x_1\) = longitud del cotxe
• \(x_2\) = amplada del cotxe

A la majoria de països, l’amplada dels cotxes varia poc perquè han de cabre a les carreteres de carril únic. Per exemple, als Estats Units, la majoria de cotxes tenen aproximadament 1,8 m d’amplada.

Si representem gràficament la longitud i l’amplada dels cotxes, trobarem que:

• \(x_1\) varia molt (hi ha cotxes curts i llargs)
• \(x_2\) varia poc

En aquest cas, el PCA automàticament decidiria prioritzar \(x_1\), ja que conté la major part de la informació rellevant.

Exemple 2: longitud i diàmetre de rodes

Ara \(x_1\) és la longitud del cotxe i \(x_2\) és el diàmetre de les rodes.
Encara que \(x_2\) variï una mica, PCA probablement decidirà que \(x_1\) és suficient per representar la variació principal.

Exemple 3: longitud i alçada

Ara \(x_1\) = longitud i \(x_2\) = alçada del cotxe.
Ambdues característiques varien força i contenen informació útil.

En lloc de triar només \(x_1\) o només \(x_2\), PCA crea un nou eix combinat, que anomenarem \(z\).
Aquest eix \(z\) és una combinació lineal de \(x_1\) i \(x_2\) que captura la major part de la variació de les dades:

\[ z = w_1 x_1 + w_2 x_2 \]

La coordenada d’un cotxe sobre l’eix \(z\) resumeix aproximadament la “grandària total” del cotxe, sense perdre informació rellevant.

Exemple amb més dimensions

Suposem que tenim un conjunt de dades tridimensional amb \(x_1, x_2, x_3\).
Encara que les dades estiguin en 3D, sovint viuen sobre una superfície gairebé bidimensional.
PCA permet reduir de 3 característiques a 2 noves coordenades \(z_1, z_2\) per a visualitzar les dades en un gràfic 2D.

Exemple amb països

Si tenim dades de molts països amb característiques com:

• \(x_1\) = PIB total
• \(x_2\) = PIB per càpita
• \(x_3\) = Índex de Desenvolupament Humà
• …fins a 50 característiques

No podem representar-ho directament en un gràfic.
PCA redueix aquestes 50 característiques a dues o tres:

\[ Z_1, Z_2 = \text{PCA}(X_1, X_2, \dots, X_{50}) \]

Per exemple:

• \(Z_1\) podria correspondre aproximadament a la grandària del país o PIB total
• \(Z_2\) podria correspondre a la riqueza per persona

Això permet visualitzar països grans i petits, amb PIB alt o baix, en un gràfic 2D fàcil d’interpretar.

PCA amb scikit-learn

from sklearn.datasets import load_wine
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler

X, _ = load_wine(return_X_y=True)  # 178 vins, 13 mesures químiques

# Escalar (imprescindible per a PCA: si no, manen les mesures amb valors grans)
X_scaled = StandardScaler().fit_transform(X)

# Reduir de 13 a 2 dimensions
pca = PCA(n_components=2)
X_reduced = pca.fit_transform(X_scaled)
print(X_reduced.shape)                # (178, 2)

# Variància explicada per cada component
print(pca.explained_variance_ratio_.round(2))  # [0.36 0.19]

El primer component captura el 36% de la variació i el segon el 19%: amb 2 dimensions conservem una mica més de la meitat de la informació. N’hi ha prou per dibuixar els vins en un pla i veure si formen grups, però no per substituir les 13 mesures en un model.

Quants components conservar

L’atribut explained_variance_ratio_ diu quina part de la variació de les dades captura cada component, de més a menys. Si els valors són [0.72, 0.15, 0.08, ...], amb dos components ja conservem el 87% de la informació.

• Per visualitzar: 2 o 3 components.
• Per comprimir o preparar les dades per a un altre model: els components necessaris per conservar el 90-99% de la variació. PCA(n_components=0.95) els tria sol.

Els criteris amb més detall són a Aprenentatge no supervisat: ampliació.

Resum

PCA és un algoritme potent per reduir la dimensionalitat:

• Pren dades amb moltes característiques (alta dimensionalitat)
• Les redueix a 2 o 3 característiques principals
• Permet visualitzar i entendre millor les dades

És especialment útil per explorar conjunts de dades complexos, detectar patrons i anomalies, i preparar les dades per altres algorismes d’aprenentatge automàtic.

Errors comuns a evitar

Aquests són alguns errors freqüents quan s’apliquen tècniques d’aprenentatge no supervisat:

K-means:

• Escollir \(K\) arbitràriament sense usar el mètode del colze o considerar el context
• No normalitzar les característiques (les variables amb escales grans dominaran)
• Executar l’algoritme només una vegada (pot quedar atrapat en mínims locals)

Detecció d’anomalies:

• Configurar malament el paràmetre de contaminació (massa falsos positius o falsos negatius)
• No escalar o preparar adequadament les característiques quan tenen escales molt diferents
• Interpretar l’anomaly score com una probabilitat

PCA:

• Oblidar normalitzar les dades abans d’aplicar PCA (imprescindible!)
• Reduir a massa poques dimensions i perdre informació important
• Interpretar els components principals com si fossin les variables originals