Apprentissage non supervisé

L'apprentissage non supervisé explore des données sans labels. Le modèle découvre seul des patterns, des groupes ou des structures cachées.

Principe

┌─────────────────────────────────────────────────────────┐
│              APPRENTISSAGE NON SUPERVISÉ                 │
├─────────────────────────────────────────────────────────┤
│                                                          │
│   Entrée (X)              Pas de label !                │
│   ──────────              ──────────────                │
│   [Données clients]  →    ???                           │
│   [Images]           →    ???                           │
│   [Transactions]     →    ???                           │
│                                                          │
│   Le modèle découvre : groupes, patterns, anomalies     │
│                                                          │
└─────────────────────────────────────────────────────────┘

Pas de "bonne réponse" à apprendre : le modèle explore librement les données.

Types de problèmes

Clustering (regroupement)

Partitionner les données en groupes homogènes.

Avant                    Après clustering
  ●   ○                  ┌─────┐  ┌─────┐
●   ○  ●                 │●  ● │  │ ○ ○ │
  ●  ○   ●      →        │ ●  ●│  │○  ○ │
 ●    ○                  └─────┘  └─────┘
   ●   ○                 Cluster 1  Cluster 2

Réduction de dimension

Simplifier les données en conservant l'essentiel.

100 dimensions  →  PCA  →  2 dimensions
(complexe)              (visualisable)

Détection d'anomalies

Identifier les points qui s'écartent du comportement normal.

    ●●●●●●●●
    ●●●●●●●●         ○ ← Anomalie !
    ●●●●●●●●

Algorithmes de clustering

K-Means

Partitionne les données en K clusters autour de centroïdes.

Algorithme :
1. Choisir K centroïdes aléatoires
2. Assigner chaque point au centroïde le plus proche
3. Recalculer les centroïdes (moyenne des points)
4. Répéter 2-3 jusqu'à convergence

    Itération 1         Itération 2         Convergence
     ×     ×             ×     ×              ●     ●
    ●●●   ●●●    →      ●●●   ●●●    →      ●●●   ●●●
    ●●●   ●●●           ●●●   ●●●           ●●●   ●●●

from sklearn.cluster import KMeans

kmeans = KMeans(n_clusters=3, random_state=42)
clusters = kmeans.fit_predict(X)
centroids = kmeans.cluster_centers_

Avantages :

Simple et rapide
Fonctionne bien sur des clusters sphériques

Limites :

Doit choisir K à l'avance
Sensible à l'initialisation
Suppose des clusters de forme sphérique

Choisir K : méthode du coude

inertias = []
for k in range(1, 11):
    kmeans = KMeans(n_clusters=k)
    kmeans.fit(X)
    inertias.append(kmeans.inertia_)

# Tracer la courbe et chercher le "coude"
plt.plot(range(1, 11), inertias, marker='o')
plt.xlabel('Nombre de clusters K')
plt.ylabel('Inertie')

Inertie
  │
  │●
  │ ●
  │  ●
  │   ●──●──●──●──●  ← Coude à K=4
  └────────────────── K
        4

DBSCAN

Clustering basé sur la densité. Trouve des clusters de forme arbitraire.

Points dans un rayon ε avec min_samples voisins = cluster

    ●●●●●●                     Cluster 1
    ●●●●●●●
                    ←  DBSCAN détecte 2 clusters
         ●●●●                  + anomalies
         ●●●●●
              ○               Anomalie (bruit)

from sklearn.cluster import DBSCAN

dbscan = DBSCAN(eps=0.5, min_samples=5)
clusters = dbscan.fit_predict(X)
# -1 = anomalie (bruit)

Avantages :

Pas besoin de spécifier K
Trouve des clusters de forme arbitraire
Détecte les anomalies

Limites :

Sensible aux paramètres eps et min_samples
Difficile avec des densités variables

Clustering hiérarchique

Construit une hiérarchie de clusters (dendrogramme).

         ┌──────────┐
    ┌────┴────┐     │
  ┌─┴─┐     ┌─┴─┐   │
  A   B     C   D   E

Couper à différentes hauteurs = différents nombres de clusters

from sklearn.cluster import AgglomerativeClustering
from scipy.cluster.hierarchy import dendrogram, linkage

# Clustering
model = AgglomerativeClustering(n_clusters=3)
clusters = model.fit_predict(X)

# Visualisation dendrogramme
Z = linkage(X, method='ward')
dendrogram(Z)

Avantages :

Visualisation intuitive
Pas besoin de K à l'avance

Limites :

Coûteux en calcul (O(n²))
Non réversible

Réduction de dimension

PCA (Principal Component Analysis)

Projette les données sur les axes de variance maximale.

Données originales (2D)         Après PCA (1D)
        ●                           │
      ● ● ●                         ●●●●●●●●
    ●   ●   ●        →              │
      ● ● ●                    Composante principale
        ●

from sklearn.decomposition import PCA

# Réduire à 2 dimensions
pca = PCA(n_components=2)
X_reduced = pca.fit_transform(X)

# Variance expliquée
print(pca.explained_variance_ratio_)
# [0.72, 0.18] → 90% de la variance en 2 composantes

Applications :

Visualisation de données haute dimension
Compression avant clustering
Réduction du bruit
Accélération d'autres algorithmes

t-SNE

Visualisation en 2D/3D préservant les voisinages locaux.

from sklearn.manifold import TSNE

tsne = TSNE(n_components=2, perplexity=30, random_state=42)
X_embedded = tsne.fit_transform(X)

t-SNE est pour la visualisation uniquement. Ne pas utiliser pour la modélisation (non déterministe, ne préserve pas les distances globales).

UMAP

Alternative moderne à t-SNE, plus rapide et préserve mieux la structure globale.

import umap

reducer = umap.UMAP(n_components=2, random_state=42)
X_embedded = reducer.fit_transform(X)

Détection d'anomalies

Isolation Forest

Isole les anomalies en les séparant rapidement avec des arbres aléatoires.

Point normal : nécessite beaucoup de splits pour être isolé
Point anormal : isolé rapidement (peu de splits)

from sklearn.ensemble import IsolationForest

iso = IsolationForest(contamination=0.1, random_state=42)
predictions = iso.fit_predict(X)
# 1 = normal, -1 = anomalie

One-Class SVM

Apprend une frontière autour des données normales.

from sklearn.svm import OneClassSVM

oc_svm = OneClassSVM(nu=0.1, kernel='rbf')
predictions = oc_svm.fit_predict(X)

Autoencoders

Réseau de neurones qui compresse et décompresse. Les anomalies ont une erreur de reconstruction élevée.

Input → Encoder → Code → Decoder → Output
                   ↓
           Espace latent réduit

Erreur de reconstruction :
- Faible pour données normales
- Élevée pour anomalies

Applications pratiques

Segmentation client

# Features : récence, fréquence, montant (RFM)
from sklearn.preprocessing import StandardScaler
from sklearn.cluster import KMeans

# Normaliser
scaler = StandardScaler()
X_scaled = scaler.fit_transform(df[['recency', 'frequency', 'monetary']])

# Clustering
kmeans = KMeans(n_clusters=4, random_state=42)
df['segment'] = kmeans.fit_predict(X_scaled)

# Analyser les segments
df.groupby('segment').mean()

Segment	Profil
0	Clients VIP (haute valeur, fréquents)
1	Clients occasionnels
2	Nouveaux clients
3	Clients dormants

Compression d'images avec PCA

from sklearn.decomposition import PCA
import matplotlib.pyplot as plt

# Image 64x64 = 4096 dimensions
image = load_image()  # shape: (4096,)

# Compresser à 100 composantes
pca = PCA(n_components=100)
compressed = pca.fit_transform(images)

# Reconstruire
reconstructed = pca.inverse_transform(compressed)

Détection de fraude

from sklearn.ensemble import IsolationForest

# Entraîner sur transactions normales
iso = IsolationForest(contamination=0.01)
iso.fit(transactions_normales)

# Détecter les anomalies
nouvelles_transactions['fraude'] = iso.predict(nouvelles_transactions)
fraudes = nouvelles_transactions[nouvelles_transactions['fraude'] == -1]

Évaluation sans labels

Sans labels, l'évaluation est plus complexe :

Métriques internes

Métrique	Description	Meilleur
Silhouette	Cohésion intra-cluster vs séparation inter-cluster	Proche de 1
Inertie	Somme des distances au centroïde	Plus bas
Davies-Bouldin	Ratio de dispersion	Plus bas

from sklearn.metrics import silhouette_score, davies_bouldin_score

score = silhouette_score(X, clusters)
db_score = davies_bouldin_score(X, clusters)

Validation par expert

Souvent, la meilleure évaluation reste l'analyse humaine :

Les clusters ont-ils un sens métier ?
Les anomalies détectées sont-elles vraies ?
La réduction de dimension préserve-t-elle l'information utile ?

Apprentissage non supervisé

On this page