A) K-Moyennes

In [1]: import numpy as np

from sklearn.cluster import KMeans
from sklearn.datasets import load_iris
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

1)
In [2]: def k_means(X, n_clusters, max_iters=1000):
# Initialisation aléatoire des centres des clusters
centers = X[np.random.choice(range(len(X)), n_clusters, replace=False)]

for _ in range(max_iters):
# Attribution des points aux clusters les plus proches
labels = np.argmin(np.linalg.norm(X[:, np.newaxis] - centers, axis=2), axis=1)

# Mise à jour des centres des clusters

new_centers = np.array([X[labels == i].mean(axis=0) for i in range(n_clusters)])

# Vérification de la convergence
if np.all(centers == new_centers):
break

centers = new_centers

return labels, centers

In [3]: # importer les donnees IRIS

from sklearn.datasets import load_iris

iris = load_iris()
X_iris = iris.data

In [4]: # Utilisation de l'implémentation personnalisée

k = 3
labels_custom, centers_custom = k_means(X_iris, n_clusters=k)

# Utilisation de la fonction KMeans de sklearn pour la comparaison

kmeans_sklearn = KMeans(n_clusters=k)
labels_sklearn = kmeans_sklearn.fit_predict(X_iris)

# Comparaison des resultats

print("Résultats de l'implémentation personnalisée:")
print(labels_custom)
print("Centres des clusters:")
print(centers_custom)

print("\nRésultats de la fonction KMeans de sklearn:")

print(labels_sklearn)
print("Centres des clusters:")
print(kmeans_sklearn.cluster_centers_)

Résultats de l'implémentation personnalisée:

[1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 2 0 2 2 2 2 0 2 2 2 2
2 2 0 0 2 2 2 2 0 2 0 2 0 2 2 0 0 2 2 2 2 2 0 2 2 2 2 0 2 2 2 0 2 2 2 0 2
2 0]
Centres des clusters:
[[5.9016129 2.7483871 4.39354839 1.43387097]
[5.006 3.428 1.462 0.246 ]
[6.85 3.07368421 5.74210526 2.07105263]]

Résultats de la fonction KMeans de sklearn:

[1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 0 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
2 2 2 0 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 0 2 0 0 0 0 2 0 0 0 0
0 0 2 2 0 0 0 0 2 0 2 0 2 0 0 2 2 0 0 0 0 0 2 0 0 0 0 2 0 0 0 2 0 0 0 2 0
0 2]
Centres des clusters:
[[6.85 3.07368421 5.74210526 2.07105263]
[5.006 3.428 1.462 0.246 ]
[5.9016129 2.7483871 4.39354839 1.43387097]]

In [5]: plt.figure(figsize=(10, 6))

# Visualisation de l'implémentation personnalisée

plt.scatter(X_iris[:, 0], X_iris[:, 1], c=labels_custom, cmap='viridis', edgecolor='k', label='Clusters (Custom)')
plt.scatter(centers_custom[:, 0], centers_custom[:, 1], c='red', marker='X', s=200, label='Centers (Custom)')

# Visualisation de la fonction KMeans de sklearn

plt.scatter(X_iris[:, 0], X_iris[:, 1], c=labels_sklearn, cmap='plasma', edgecolor='k', marker='s', label='Clusters (sklearn)')
plt.scatter(kmeans_sklearn.cluster_centers_[:, 0], kmeans_sklearn.cluster_centers_[:, 1],
c='blue', marker='X', s=200, label='Centers (sklearn)')

plt.title("Clusters obtenus avec K-Moyennes")

plt.xlabel("Feature 1")
plt.ylabel("Feature 2")
plt.legend()
plt.show()

In [6]: # lancien affichage n'ext pas bien pour le visuel alors :

# Visualisation des résultats sur les trois premières dimensions de l'Iris dataset
fig = plt.figure(figsize=(12, 4))

# Plot des résultats de l'implémentation personnalisée

ax1 = fig.add_subplot(121, projection='3d')
ax1.scatter(X_iris[:, 0], X_iris[:, 1], X_iris[:, 2], c=labels_custom, cmap='viridis')
ax1.scatter(centers_custom[:, 0], centers_custom[:, 1], centers_custom[:, 2], c='red', marker='X', s=200, label='Centers')
ax1.set_title("K-Moyennes personnalisé")
ax1.set_xlabel("Feature 1")
ax1.set_ylabel("Feature 2")
ax1.set_zlabel("Feature 3")
ax1.legend()

# Plot des résultats de la fonction KMeans de sklearn

ax2 = fig.add_subplot(122, projection='3d')
ax2.scatter(X_iris[:, 0], X_iris[:, 1], X_iris[:, 2], c=labels_sklearn, cmap='viridis')
ax2.scatter(kmeans_sklearn.cluster_centers_[:, 0], kmeans_sklearn.cluster_centers_[:, 1], kmeans_sklearn.cluster_centers_[:, 2],
c='red', marker='X', s=200, label='Centers')
ax2.set_title("K-Moyennes avec sklearn")
ax2.set_xlabel("Feature 1")
ax2.set_ylabel("Feature 2")
ax2.set_zlabel("Feature 3")
ax2.legend()

plt.show()

2)Expérimenter l’instabilité due à l’initialisation : les centres des clusters étant choisis au
hasardlors de l’initialisation, le résultat obtenu peut varier d’une exécution à l’autre.
Vérifiez que c’est le cas
In [7]: def k_means(data, n_clusters, max_iters=100, random_seed=None):
if random_seed is not None:
np.random.seed(random_seed)

# Initialisation aléatoire des centres des clusters

centers = data[np.random.choice(range(len(data)), n_clusters, replace=False)]

for _ in range(max_iters):
# Attribution des points aux clusters les plus proches
labels = np.argmin(np.linalg.norm(data[:, np.newaxis] - centers, axis=2), axis=1)

# Mise à jour des centres des clusters

new_centers = np.array([data[labels == i].mean(axis=0) for i in range(n_clusters)])

# Vérification de la convergence
if np.all(centers == new_centers):
break

centers = new_centers

return labels, centers

In [8]: # Exécuter l'algorithme avec différentes initialisations

for i in range(10): # Exécutez l'algorithme trois fois avec différentes initialisations
labels, centers = k_means(X_iris, n_clusters=k, random_seed=i)

# Visualisation en 2D
plt.figure(figsize=(8, 5))
plt.scatter(X_iris[:, 0], X_iris[:, 1], c=labels, cmap='viridis', edgecolor='k')
plt.scatter(centers[:, 0], centers[:, 1], c='red', marker='X', s=200, label='Centers')
plt.title(f"Clustering avec initialisation aléatoire {i}")
plt.xlabel("Feature 1")
plt.ylabel("Feature 2")
plt.legend()
plt.show()

j'ai exécuté l'algorithme K-Means trois fois avec différentes initialisations, en contrôlant cela à l'aide de la graine aléatoire (random_seed). Vous devriez observer des variations dans la
position des centres des clusters et, par conséquent, dans les résultats du clustering à chaque exécution. Cela illustre l'instabilité due à l'initialisation.

In [9]: from sklearn.metrics import silhouette_score

from sklearn.datasets import load_iris

def find_best_k(data, k_range, num_iterations=10):

best_score = -1
best_k = -1
best_labels = None
best_centers = None

for k in k_range:
# Effectuer K-Means plusieurs fois pour chaque k
for _ in range(num_iterations):
kmeans = KMeans(n_clusters=k)
labels = kmeans.fit_predict(data)
score = silhouette_score(data, labels)

# Mettre à jour la meilleure solution si le score est amélioré

if score > best_score:
best_score = score
best_k = k
best_labels = labels
best_centers = kmeans.cluster_centers_

return best_k, best_labels, best_centers

k_range = range(2, 10+1)

best_k, best_labels, best_centers = find_best_k(X_iris, k_range)

print(f"Meilleur nombre de clusters selon l'indice de Silhouette : {best_k}")

Meilleur nombre de clusters selon l'indice de Silhouette : 2

In [10]: # Visualisation des résultats avec le meilleur nombre de clusters

plt.scatter(X_iris[:, 0], X_iris[:, 1], c=best_labels, cmap='viridis', edgecolor='k')
plt.scatter(best_centers[:, 0], best_centers[:, 1], c='red', marker='X', s=200, label='Centers')
plt.title(f"Clustering avec le meilleur nombre de clusters ({best_k}) selon l'indice de Silhouette")
plt.xlabel("Feature 1")
plt.ylabel("Feature 2")
plt.legend()
plt.show()

print(f"Meilleur nombre de clusters selon l'indice de Silhouette : {best_k}")

Meilleur nombre de clusters selon l'indice de Silhouette : 2

In [11]: from sklearn.decomposition import PCA

from sklearn.discriminant_analysis import LinearDiscriminantAnalysis

# Appliquer l'ACP
pca = PCA(n_components=2)
X_pca = pca.fit_transform(X_iris)

# Visualiser les résultats de l'ACP

plt.figure(figsize=(12, 5))

plt.subplot(1, 2, 1)
plt.scatter(X_pca[:, 0], X_pca[:, 1], c=best_labels, cmap='viridis', edgecolor='k')
plt.scatter(pca.transform(best_centers)[:, 0], pca.transform(best_centers)[:, 1],
c='red', marker='X', s=200, label='Centers')
plt.title(f"Résultats de l'ACP avec K-Moyennes (k={best_k})")
plt.xlabel("Principal Component 1")
plt.ylabel("Principal Component 2")
plt.legend()

# Appliquer l'ADL
lda = LinearDiscriminantAnalysis(n_components=min(X_iris.shape[1], len(np.unique(best_labels)) - 1))
X_lda = lda.fit_transform(X_iris, best_labels)

# Visualiser les résultats de l'ADL

plt.subplot(1, 2, 2)
plt.scatter(X_lda[:, 0], np.zeros_like(X_lda[:, 0]), c=best_labels, cmap='viridis', edgecolor='k')
plt.scatter(lda.transform(best_centers)[:, 0], np.zeros_like(lda.transform(best_centers)[:, 0]),
c='red', marker='X', s=200, label='Centers')
plt.title(f"Résultats de l'ADL avec K-Moyennes (k={best_k})")
plt.xlabel("Discriminant 1")
plt.yticks([]) # Pour masquer l'axe y
plt.legend()
plt.show()

B) Analyse des données « choix projet » :

1)
In [76]: from google.colab import drive
drive.mount('/content/drive')

Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount("/content/drive", force_remount=True).

In [77]: import csv

import numpy as np

# Spécifiez le chemin
chemin_fichier_csv = '/content/drive/MyDrive/WISD/S3/SDN/choixprojetstab.csv'

# Initialisez des listes vides pour les codes d'étudiants et la matrice de données
codes_etudiants = []
matrice_donnees = []

# Mappage des valeurs de mention

mapping_mention = {'très bien': 3, 'bien': 2, 'moyen': 1, 'jamais': 0}

# Lisez le fichier CSV avec le point-virgule comme séparateur

with open(chemin_fichier_csv, 'r') as fichier:
# Créez un lecteur CSV avec le point-virgule comme séparateur
lecteur_csv = csv.reader(fichier, delimiter=';')

# Extrait l'en-tête (saute la première ligne)

en_tete = next(lecteur_csv)

# Parcourez les lignes restantes

for i, ligne in enumerate(lecteur_csv):
# Extrait le code de l'étudiant (première colonne)
code_etudiant = ligne[0]
codes_etudiants.append(code_etudiant)

if i != 0:
# Extrait les données (à l'exclusion de la première colonne) et convertit en valeurs numériques
# ligne_donnees = np.array([mapping_mention[mention] for mention in ligne[1:]], dtype=int)
ligne_donnees = ligne[1:] # Les données commencent à la deuxième colonne
matrice_donnees.append(ligne_donnees)

X = np.array(matrice_donnees,dtype=int)

print("Codes d'étudiants :", codes_etudiants)

print("Matrice de données :")
print(X)

Codes d'étudiants : ['bl/.vSDYCGrSs', 'bl/1NiMubceBs', 'bl/dvgMTLVSvk', 'bl1NWhKcNADF2', 'bl1ao5B7htJfQ', 'bl1u./AF8TEp6', 'bl2LwDaKpKT/c', 'bl2jhb
3v2qUhc', 'bl2rqWgKava4o', 'bl4wbw9k3zw/c', 'bl5.Z2M26c/5o', 'bl5/1tjKhKrAE', 'bl55W0uSMrpz6', 'bl65TErI.VjAA', 'bl9BdxOPgV0XU', 'bl9HR9LuSmrMo',
'blA5K4GlKIEN2', 'blB6OJg1ilNV2', 'blC888Fel.osw', 'blDPCjzWCczr6', 'blFD1aQDfmpH.', 'blFq6YzuUpuG6', 'blGDihFnA6.LE', 'blHIVuF4ftibA', 'blHxzJKy1k
WeU', 'blIf9FrZBwJyk', 'blK.9jBCD/SSw', 'blKXgoRO0CXOE', 'blKsQZNr3tnvw', 'blMKFlGVYbnSA', 'blNDVy9IQ.pyc', 'blQdUJch/nfDg', 'blSI8b6JyYqHY', 'blUi
qJyD6t5eo', 'blXfmkaW817T6', 'blXtkgxAdNzb.', 'blYb2ABO7EU.M', 'blZxs/nnNLCos', 'blZzwRPNDZpRY', 'blaADEMnN043A', 'blaIQ61DLW6uc', 'blbKjW2k4.8xo',
'blbfVllTjpkQY', 'blbkl9iy6NSzQ', 'blddve1gjnw96', 'blfIGd5mN48z2', 'blg1OtiwNMDAs', 'blg8PMUnKJxes', 'blginkLBh0Sf.', 'blh9lEioXhmgc', 'blhai4aeyq
8rU', 'blhnNMwGPnuNc', 'bliYbAmgGkzSI', 'bljdvFfVzFYBk', 'bllOE3T7MU9nE', 'blleUFdn4IybY', 'blmLNmnzoOUT6', 'bln85uWpKDNjM', 'blnahdfBfYOd.', 'blpJ
fyKbetUsc', 'blpPNI0oxLIG.', 'bltZdophgVNQ2', 'bltppVKeGreVc', 'bltsUkerTn/gA', 'bluruT/sOvVm6', 'bluwV0aELRqFQ', 'blvqKhCDhQab.', 'blwyn40XjgvEs',
'bly3Oqsvf6WlU', 'bly69tf4z1FiM', 'blzon470EHguA']
Matrice de données :
[[1 1 1 ... 1 1 1]
[0 0 0 ... 1 0 0]
[1 1 1 ... 1 1 1]
...
[1 1 1 ... 1 0 2]
[1 1 0 ... 1 1 1]
[1 1 1 ... 0 1 1]]

2)
In [78]: from sklearn.cluster import KMeans, AgglomerativeClustering, DBSCAN, Birch, SpectralClustering

# Essayer différents algorithmes de clustering

algorithmes = {
'KMeans': KMeans(n_clusters=4),
'Agglomerative': AgglomerativeClustering(n_clusters=4),
'DBSCAN': DBSCAN(eps=3, min_samples=2),
'Birch': Birch(n_clusters=4),
'Spectral': SpectralClustering(n_clusters=4)
}

meilleur_algorithme = None
meilleur_silhouette = -1

for nom_algo, algo in algorithmes.items():

# Appliquer l'algorithme de clustering
labels = algo.fit_predict(X)

/usr/local/lib/python3.10/dist-packages/sklearn/cluster/_kmeans.py:870: FutureWarning: The default value of `n_init` will change from 10 to 'auto'
in 1.4. Set the value of `n_init` explicitly to suppress the warning
warnings.warn(
/usr/local/lib/python3.10/dist-packages/sklearn/manifold/_spectral_embedding.py:393: UserWarning: Exited at iteration 2000 with accuracies
[8.04956583e-11 1.45016845e-07 4.45135236e-08 4.54366600e-07
1.26516492e-05]
not reaching the requested tolerance 1.043081283569336e-06.
Use iteration 1628 instead with accuracy
1.6937239268132293e-06.

_, diffusion_map = lobpcg(
/usr/local/lib/python3.10/dist-packages/sklearn/manifold/_spectral_embedding.py:393: UserWarning: Exited postprocessing with accuracies
[1.99731453e-12 1.51544435e-07 4.46095104e-08 4.58512629e-07
7.81185669e-06]
not reaching the requested tolerance 1.043081283569336e-06.
_, diffusion_map = lobpcg(

In [79]: # Calculer l'indice de Silhouette

score_silhouette = silhouette_score(X, labels)

# Mettre à jour le meilleur algorithme si nécessaire

if score_silhouette > meilleur_silhouette:
meilleur_silhouette = score_silhouette
meilleur_algorithme = nom_algo

# Afficher le résultat pour chaque algorithme

print(f"{nom_algo}: Silhouette Score = {score_silhouette}")

# Afficher le meilleur algorithme

print(f"Meilleur algorithme selon l'indice de Silhouette : {meilleur_algorithme}")

Spectral: Silhouette Score = 0.1786591204229959

Meilleur algorithme selon l'indice de Silhouette : Spectral