Nous allons réutiliser les données synthétiques de l'exemple K-Means (3 clusters normaux + 1 cluster d'attaque) et appliquer le clustering agglomératif. Nous illustrons ensuite comment obtenir un dendrogramme et des étiquettes de clusters.

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

# Perform agglomerative clustering (bottom-up) on the data
agg = AgglomerativeClustering(n_clusters=None, distance_threshold=0, linkage='ward')
# distance_threshold=0 gives the full tree without cutting (we can cut manually)
agg.fit(X)

print(f"Number of merge steps: {agg.n_clusters_ - 1}")  # should equal number of points - 1
# Create a dendrogram using SciPy for visualization (optional)
Z = linkage(X, method='ward')
# Normally, you would plot the dendrogram. Here we'll just compute cluster labels for a chosen cut:
clusters_3 = AgglomerativeClustering(n_clusters=3, linkage='ward').fit_predict(X)
print(f"Labels with 3 clusters: {np.unique(clusters_3)}")
print(f"Cluster sizes for 3 clusters: {np.bincount(clusters_3)}")

from sklearn.cluster import DBSCAN

# Generate synthetic data: 2 normal clusters and 5 outlier points
cluster1 = rng.normal(loc=[100, 1000], scale=[5, 100], size=(100, 2))
cluster2 = rng.normal(loc=[120, 2000], scale=[5, 100], size=(100, 2))
outliers = rng.uniform(low=[50, 50], high=[180, 3000], size=(5, 2))  # scattered anomalies
data = np.vstack([cluster1, cluster2, outliers])

# Run DBSCAN with chosen eps and MinPts
eps = 15.0   # radius for neighborhood
min_pts = 5  # minimum neighbors to form a dense region
db = DBSCAN(eps=eps, min_samples=min_pts).fit(data)
labels = db.labels_  # cluster labels (-1 for noise)

# Analyze clusters and noise
num_clusters = len(set(labels) - {-1})
num_noise = np.sum(labels == -1)
print(f"DBSCAN found {num_clusters} clusters and {num_noise} noise points")
print("Cluster labels for first 10 points:", labels[:10])

Dans cet extrait, nous avons ajusté eps et min_samples pour convenir à notre échelle de données (15,0 en unités de caractéristiques, et nécessitant 5 points pour former un cluster). DBSCAN devrait trouver 2 clusters (les clusters de trafic normal) et signaler les 5 valeurs aberrantes injectées comme bruit. Nous affichons le nombre de clusters par rapport aux points de bruit pour vérifier cela. Dans un cadre réel, on pourrait itérer sur ε (en utilisant une heuristique de graphique de distance k pour choisir ε) et MinPts (souvent fixé autour de la dimensionnalité des données + 1 comme règle générale) pour trouver des résultats de clustering stables. La capacité à étiqueter explicitement le bruit aide à séparer les données d'attaque potentielles pour une analyse plus approfondie.

Analyse en Composantes Principales (ACP)

L'ACP est une technique de réduction de dimensionnalité qui trouve un nouvel ensemble d'axes orthogonaux (composantes principales) qui capturent la variance maximale dans les données. En termes simples, l'ACP fait pivoter et projette les données sur un nouveau système de coordonnées de sorte que la première composante principale (PC1) explique la plus grande variance possible, la deuxième PC (PC2) explique la plus grande variance orthogonale à PC1, et ainsi de suite. Mathématiquement, l'ACP calcule les vecteurs propres de la matrice de covariance des données – ces vecteurs propres sont les directions des composantes principales, et les valeurs propres correspondantes indiquent la quantité de variance expliquée par chacune. Elle est souvent utilisée pour l'extraction de caractéristiques, la visualisation et la réduction du bruit.

Notez que cela est utile si les dimensions du jeu de données contiennent des dépendances ou des corrélations linéaires significatives.

L'ACP fonctionne en identifiant les composantes principales des données, qui sont les directions de variance maximale. Les étapes impliquées dans l'ACP sont :

1. Standardisation : Centrer les données en soustrayant la moyenne et en les mettant à l'échelle à une variance unitaire.
2. Matrice de Covariance : Calculer la matrice de covariance des données standardisées pour comprendre les relations entre les caractéristiques.
3. Décomposition en Valeurs Propres : Effectuer une décomposition en valeurs propres sur la matrice de covariance pour obtenir les valeurs propres et les vecteurs propres.
4. Sélection des Composantes Principales : Trier les valeurs propres par ordre décroissant et sélectionner les K vecteurs propres correspondants aux plus grandes valeurs propres. Ces vecteurs propres forment le nouvel espace de caractéristiques.
5. Transformer les Données : Projeter les données originales sur le nouvel espace de caractéristiques en utilisant les composantes principales sélectionnées. L'ACP est largement utilisée pour la visualisation des données, la réduction du bruit et comme étape de prétraitement pour d'autres algorithmes d'apprentissage automatique. Elle aide à réduire la dimensionnalité des données tout en conservant sa structure essentielle.

Valeurs Propres et Vecteurs Propres

Une valeur propre est un scalaire qui indique la quantité de variance capturée par son vecteur propre correspondant. Un vecteur propre représente une direction dans l'espace des caractéristiques le long de laquelle les données varient le plus.

Imaginez qu'A est une matrice carrée, et v est un vecteur non nul tel que : A * v = λ * v où :

• A est une matrice carrée comme [ [1, 2], [2, 1]] (par exemple, matrice de covariance)
• v est un vecteur propre (par exemple, [1, 1])

Alors, A * v = [ [1, 2], [2, 1]] * [1, 1] = [3, 3] qui sera la valeur propre λ multipliée par le vecteur propre v, rendant la valeur propre λ = 3.

Valeurs Propres et Vecteurs Propres dans l'ACP

Expliquons cela avec un exemple. Imaginez que vous avez un ensemble de données avec beaucoup d'images en niveaux de gris de visages de 100x100 pixels. Chaque pixel peut être considéré comme une caractéristique, donc vous avez 10 000 caractéristiques par image (ou un vecteur de 10 000 composants par image). Si vous souhaitez réduire la dimensionnalité de cet ensemble de données en utilisant l'ACP, vous suivriez ces étapes :

1. Standardisation : Centrer les données en soustrayant la moyenne de chaque caractéristique (pixel) de l'ensemble de données.
2. Matrice de Covariance : Calculer la matrice de covariance des données standardisées, qui capture comment les caractéristiques (pixels) varient ensemble.

• Notez que la covariance entre deux variables (pixels dans ce cas) indique combien elles changent ensemble, donc l'idée ici est de découvrir quels pixels ont tendance à augmenter ou diminuer ensemble avec une relation linéaire.
• Par exemple, si le pixel 1 et le pixel 2 ont tendance à augmenter ensemble, la covariance entre eux sera positive.
• La matrice de covariance sera une matrice de 10 000x10 000 où chaque entrée représente la covariance entre deux pixels.

3. Résoudre l'équation des valeurs propres : L'équation des valeurs propres à résoudre est C * v = λ * v où C est la matrice de covariance, v est le vecteur propre, et λ est la valeur propre. Elle peut être résolue en utilisant des méthodes comme :

• Décomposition en Valeurs Propres : Effectuer une décomposition en valeurs propres sur la matrice de covariance pour obtenir les valeurs propres et les vecteurs propres.
• Décomposition en Valeurs Singulières (SVD) : Alternativement, vous pouvez utiliser la SVD pour décomposer la matrice de données en valeurs et vecteurs singuliers, ce qui peut également donner les composantes principales.

4. Sélection des Composantes Principales : Trier les valeurs propres par ordre décroissant et sélectionner les K vecteurs propres correspondants aux plus grandes valeurs propres. Ces vecteurs propres représentent les directions de variance maximale dans les données.

Hypothèses et Limitations

L'ACP suppose que les axes principaux de variance sont significatifs – c'est une méthode linéaire, donc elle capture les corrélations linéaires dans les données. Elle est non supervisée car elle utilise uniquement la covariance des caractéristiques. Les avantages de l'ACP incluent la réduction du bruit (les composants de petite variance correspondent souvent au bruit) et la décorrélation des caractéristiques. Elle est efficace sur le plan computationnel pour des dimensions modérément élevées et souvent une étape de prétraitement utile pour d'autres algorithmes (pour atténuer le fléau de la dimensionnalité). Une limitation est que l'ACP est limitée aux relations linéaires – elle ne capturera pas de structures non linéaires complexes (tandis que les autoencodeurs ou t-SNE pourraient le faire). De plus, les composants de l'ACP peuvent être difficiles à interpréter en termes de caractéristiques originales (ce sont des combinaisons de caractéristiques originales). En cybersécurité, il faut être prudent : une attaque qui ne cause qu'un changement subtil dans une caractéristique à faible variance pourrait ne pas apparaître dans les principales composantes (puisque l'ACP priorise la variance, pas nécessairement l'« intérêt »).

from sklearn.decomposition import PCA

# Create synthetic 4D data (3 clusters similar to before, but add correlated features)
# Base features: duration, bytes (as before)
base_data = np.vstack([normal1, normal2, normal3])  # 1500 points from earlier normal clusters
# Add two more features correlated with existing ones, e.g. packets = bytes/50 + noise, errors = duration/10 + noise
packets = base_data[:, 1] / 50 + rng.normal(scale=0.5, size=len(base_data))
errors = base_data[:, 0] / 10 + rng.normal(scale=0.5, size=len(base_data))
data_4d = np.column_stack([base_data[:, 0], base_data[:, 1], packets, errors])

# Apply PCA to reduce 4D data to 2D
pca = PCA(n_components=2)
data_2d = pca.fit_transform(data_4d)
print("Explained variance ratio of 2 components:", pca.explained_variance_ratio_)
print("Original shape:", data_4d.shape, "Reduced shape:", data_2d.shape)
# We can examine a few transformed points
print("First 5 data points in PCA space:\n", data_2d[:5])

Modèles de Mélange Gaussien (GMM)

Un Modèle de Mélange Gaussien suppose que les données sont générées à partir d'un mélange de plusieurs distributions gaussiennes (normales) avec des paramètres inconnus. En essence, c'est un modèle de clustering probabiliste : il essaie d'assigner en douceur chaque point à l'un des K composants gaussiens. Chaque composant gaussien k a un vecteur moyen (μ_k), une matrice de covariance (Σ_k) et un poids de mélange (π_k) qui représente la prévalence de ce cluster. Contrairement à K-Means qui fait des assignations "dures", GMM donne à chaque point une probabilité d'appartenir à chaque cluster.

L'ajustement de GMM se fait généralement via l'algorithme d'Expectation-Maximization (EM) :

• Initialisation : Commencer avec des estimations initiales pour les moyennes, les covariances et les coefficients de mélange (ou utiliser les résultats de K-Means comme point de départ).

• Étape E (Expectation) : Étant donné les paramètres actuels, calculer la responsabilité de chaque cluster pour chaque point : essentiellement r_nk = P(z_k | x_n) où z_k est la variable latente indiquant l'appartenance au cluster pour le point x_n. Cela se fait en utilisant le théorème de Bayes, où nous calculons la probabilité a posteriori de chaque point appartenant à chaque cluster en fonction des paramètres actuels. Les responsabilités sont calculées comme :

r_{nk} = \frac{\pi_k \mathcal{N}(x_n | \mu_k, \Sigma_k)}{\sum_{j=1}^{K} \pi_j \mathcal{N}(x_n | \mu_j, \Sigma_j)}

où :

• ( \pi_k ) est le coefficient de mélange pour le cluster k (probabilité a priori du cluster k),

• ( \mathcal{N}(x_n | \mu_k, \Sigma_k) ) est la fonction de densité de probabilité gaussienne pour le point ( x_n ) donné la moyenne ( \mu_k ) et la covariance ( \Sigma_k ).

• Étape M (Maximization) : Mettre à jour les paramètres en utilisant les responsabilités calculées dans l'étape E :

• Mettre à jour chaque moyenne μ_k comme la moyenne pondérée des points, où les poids sont les responsabilités.

• Mettre à jour chaque covariance Σ_k comme la covariance pondérée des points assignés au cluster k.

• Mettre à jour les coefficients de mélange π_k comme la responsabilité moyenne pour le cluster k.

• Itérer les étapes E et M jusqu'à convergence (les paramètres se stabilisent ou l'amélioration de la vraisemblance est inférieure à un seuil).

Le résultat est un ensemble de distributions gaussiennes qui modélisent collectivement la distribution globale des données. Nous pouvons utiliser le GMM ajusté pour le clustering en assignant chaque point au gaussien avec la plus haute probabilité, ou conserver les probabilités pour l'incertitude. On peut également évaluer la vraisemblance de nouveaux points pour voir s'ils s'intègrent dans le modèle (utile pour la détection d'anomalies).

Hypothèses et Limitations

GMM est une généralisation de K-Means qui incorpore la covariance, de sorte que les clusters peuvent être ellipsoïdaux (pas seulement sphériques). Il gère des clusters de tailles et de formes différentes si la covariance est complète. Le clustering doux est un avantage lorsque les frontières des clusters sont floues – par exemple, en cybersécurité, un événement pourrait avoir des traits de plusieurs types d'attaques ; GMM peut refléter cette incertitude avec des probabilités. GMM fournit également une estimation de densité probabiliste des données, utile pour détecter des valeurs aberrantes (points avec une faible vraisemblance sous tous les composants du mélange).

En revanche, GMM nécessite de spécifier le nombre de composants K (bien qu'on puisse utiliser des critères comme BIC/AIC pour le sélectionner). EM peut parfois converger lentement ou vers un optimum local, donc l'initialisation est importante (souvent, on exécute EM plusieurs fois). Si les données ne suivent pas réellement un mélange de gaussiennes, le modèle peut être un mauvais ajustement. Il y a aussi un risque qu'un gaussien se rétrécisse pour ne couvrir qu'une valeur aberrante (bien que la régularisation ou les limites de covariance minimales puissent atténuer cela).

from sklearn.mixture import GaussianMixture

# Fit a GMM with 3 components to the normal traffic data
gmm = GaussianMixture(n_components=3, covariance_type='full', random_state=0)
gmm.fit(base_data)  # using the 1500 normal data points from PCA example

# Print the learned Gaussian parameters
print("GMM means:\n", gmm.means_)
print("GMM covariance matrices:\n", gmm.covariances_)

# Take a sample attack-like point and evaluate it
sample_attack = np.array([[200, 800]])  # an outlier similar to earlier attack cluster
probs = gmm.predict_proba(sample_attack)
log_likelihood = gmm.score_samples(sample_attack)
print("Cluster membership probabilities for sample attack:", probs)
print("Log-likelihood of sample attack under GMM:", log_likelihood)

from sklearn.ensemble import IsolationForest

# Combine normal and attack test data from autoencoder example
X_test_if = test_data  # (120 x 2 array with 100 normal and 20 attack points)
# Train Isolation Forest (unsupervised) on the test set itself for demo (in practice train on known normal)
iso_forest = IsolationForest(n_estimators=100, contamination=0.15, random_state=0)
iso_forest.fit(X_test_if)
# Predict anomalies (-1 for anomaly, 1 for normal)
preds = iso_forest.predict(X_test_if)
anomaly_scores = iso_forest.decision_function(X_test_if)  # the higher, the more normal
print("Isolation Forest predicted labels (first 20):", preds[:20])
print("Number of anomalies detected:", np.sum(preds == -1))
print("Example anomaly scores (lower means more anomalous):", anomaly_scores[:5])

# 1 ─────────────────────────────────────────────────────────────────────
#    Create synthetic 4-D dataset
#      • Three clusters of “normal” traffic (duration, bytes)
#      • Two correlated features: packets & errors
#      • Five outlier points to simulate suspicious traffic
# ──────────────────────────────────────────────────────────────────────
import numpy as np
import matplotlib.pyplot as plt
from sklearn.manifold import TSNE
from sklearn.preprocessing import StandardScaler

rng = np.random.RandomState(42)

# Base (duration, bytes) clusters
normal1 = rng.normal(loc=[50, 500],  scale=[10, 100], size=(500, 2))
normal2 = rng.normal(loc=[60, 1500], scale=[8,  200], size=(500, 2))
normal3 = rng.normal(loc=[70, 3000], scale=[5,  300], size=(500, 2))

base_data = np.vstack([normal1, normal2, normal3])       # (1500, 2)

# Correlated features
packets = base_data[:, 1] / 50 + rng.normal(scale=0.5, size=len(base_data))
errors  = base_data[:, 0] / 10 + rng.normal(scale=0.5, size=len(base_data))

data_4d = np.column_stack([base_data, packets, errors])  # (1500, 4)

# Outlier / attack points
outliers_4d = np.column_stack([
rng.normal(250, 1, size=5),     # extreme duration
rng.normal(1000, 1, size=5),    # moderate bytes
rng.normal(5, 1, size=5),       # very low packets
rng.normal(25, 1, size=5)       # high errors
])

data_viz = np.vstack([data_4d, outliers_4d])             # (1505, 4)

# 2 ─────────────────────────────────────────────────────────────────────
#    Standardize features (recommended for t-SNE)
# ──────────────────────────────────────────────────────────────────────
scaler = StandardScaler()
data_scaled = scaler.fit_transform(data_viz)

# 3 ─────────────────────────────────────────────────────────────────────
#    Run t-SNE to project 4-D → 2-D
# ──────────────────────────────────────────────────────────────────────
tsne = TSNE(
n_components=2,
perplexity=30,
learning_rate='auto',
init='pca',
random_state=0
)
data_2d = tsne.fit_transform(data_scaled)
print("t-SNE output shape:", data_2d.shape)  # (1505, 2)

# 4 ─────────────────────────────────────────────────────────────────────
#    Visualize: normal traffic vs. outliers
# ──────────────────────────────────────────────────────────────────────
plt.figure(figsize=(8, 6))
plt.scatter(
data_2d[:-5, 0], data_2d[:-5, 1],
label="Normal traffic",
alpha=0.6,
s=10
)
plt.scatter(
data_2d[-5:, 0], data_2d[-5:, 1],
label="Outliers / attacks",
alpha=0.9,
s=40,
marker="X",
edgecolor='k'
)

plt.title("t-SNE Projection of Synthetic Network Traffic")
plt.xlabel("t-SNE component 1")
plt.ylabel("t-SNE component 2")
plt.legend()
plt.tight_layout()
plt.show()