Code :
#Step 3 - Training our K-Means Model
#Since our Initial Data is well scaled, we can pass it directly to our K-Means
kmeans = KMeans(featuresCol='features',k=4) # k est le nombre de groupe
kmeans_model = kmeans.fit(final_assembled_data)
explication:
1. La première ligne crée une instance de l'algorithme KMeans en utilisant
KMeans(featuresCol='features', k=4). Cela signifie que le modèle K-Means aura une colonne
"features" comme entrée et sera configuré pour créer 4 groupes (ou clusters).
2. Ensuite, la ligne kmeans_model = kmeans.fit(final_assembled_data) entraîne le modèle K-
Means en utilisant les données préparées final_assembled_data. La méthode fit() est utilisée
pour ajuster le modèle aux données fournies.
Après avoir exécuté cette partie du code, kmeans_model contiendra le modèle K-Means
entraîné, qui peut être utilisé pour effectuer des prédictions sur de nouvelles données ou
analyser les groupes formés par l'algorithme.
Code :
#Step 4 - Displaying the segmentation resultat
seg = kmeans_model.transform(final_assembled_data)
print("Prediction Data")
seg.show(50)
centres = kmeans_model.clusterCenters() #Determining the centroids of the cluster (groupe)
print("The company can setup 3 of their towers at these locations- latitudes and longitudes for
optimal network coverage")
cluster_list=[]
i=1
for centre in centres:
cluster_list.append(centre)
print("{} - {}".format(i,centre))
i=i+1
print("\nDetermining the number of users that belongs to each clusters")
seg.groupBy('prediction').count().show()
#code en relation avec la présentation graphique
#......
Explication :
Le code effectue les étapes suivantes :
1. Appliquer le modèle K-Means entraîné (kmeans_model) sur les données préparées
(final_assembled_data) pour attribuer un cluster à chaque point de données. Les résultats
sont stockés dans un nouveau DataFrame appelé seg avec une colonne "prediction" pour
représenter les clusters prédits.
2. Afficher les données prédites en affichant les 50 premières lignes du DataFrame seg.
3. Récupérer les coordonnées des centroïdes des clusters à partir du modèle K-Means et les
afficher en tant que latitudes et longitudes pour les emplacements optimaux de la couverture
réseau.
4. Afficher le nombre d'utilisateurs appartenant à chaque cluster en regroupant les données par
la colonne "prediction" dans le DataFrame seg et en comptant le nombre d'occurrences dans
chaque groupe.
Code :
#Step 4 -Evaluating our model
from pyspark.ml.evaluation import ClusteringEvaluator
evaluator_object = ClusteringEvaluator(predictionCol='prediction',featuresCol='features')
Silhouette_Score = evaluator_object.evaluate(predictions)
evaluator = ClusteringEvaluator()
print("The Silhouette Score when k=3 is {}".format(Silhouette_Score))
explication:
Le code effectue les étapes suivantes :
1. Importer la classe ClusteringEvaluator du module pyspark.ml.evaluation pour évaluer la
qualité des résultats de clustering.
2. Créer une instance de l'évaluateur de clustering avec les colonnes spécifiées pour les
prédictions et les caractéristiques.
3. Évaluer les résultats de clustering en utilisant la métrique de Silhouette avec la méthode
evaluate() de l'évaluateur de clustering, en fournissant un DataFrame contenant les
prédictions du modèle K-Means.
4. Créer une autre instance de l'évaluateur de clustering sans spécifier de colonnes spécifiques.
5. Afficher le score de Silhouette obtenu pour les résultats de clustering lorsque le nombre de
clusters est égal à 3.
Ce code nous permet d'évaluer la qualité des résultats de clustering du modèle K-Means en
utilisant la métrique de Silhouette.
Code :
#wssse = kmeans_model.computeCost(final_assembled_data)
#print("Within Set Sum of Squared Errors = " + str(wssse))
pdt = kmeans_model.transform(final_assembled_data)
evaluator = ClusteringEvaluator()
silhouette = evaluator.evaluate(pdt)
print(silhouette)
cost = kmeans_model.summary.trainingCost
print("Within Set Sum of Squared Errors = " + str(cost))
explication :
1. La ligne wssse = kmeans_model.computeCost(final_assembled_data) calcule la somme des
erreurs quadratiques intra-cluster (Within Set Sum of Squared Errors) pour évaluer la
dispersion des points de données à l'intérieur de chaque cluster. Le résultat est stocké dans la
variable wssse.
2. La ligne pdt = kmeans_model.transform(final_assembled_data) applique le modèle K-Means
aux données d'entrée (final_assembled_data) pour attribuer un cluster à chaque point de
données. Le résultat est stocké dans le DataFrame pdt avec une colonne supplémentaire
"prediction".
3. La ligne evaluator = ClusteringEvaluator() crée une instance de l'évaluateur de clustering.
4. La ligne silhouette = evaluator.evaluate(pdt) calcule le score de silhouette pour évaluer la
qualité des clusters obtenus à partir du modèle K-Means. Le score de silhouette mesure à
quel point chaque point de données est similaire à son propre cluster par rapport aux autres
clusters. Le résultat est stocké dans la variable silhouette.
5. La ligne cost = kmeans_model.summary.trainingCost récupère le coût total de
l'entraînement du modèle K-Means. Ce coût représente la somme des carrés des distances
entre chaque point de données et son centroïde de cluster. Le résultat est stocké dans la
variable cost.
le code calcule la somme des erreurs quadratiques intra-cluster (WSSSE) pour évaluer la
dispersion des points de données à l'intérieur des clusters. Il calcule également le score de
silhouette pour évaluer la qualité des clusters obtenus à partir du modèle K-Means. Ces mesures
fournissent des informations sur la performance et la qualité du modèle K-Means appliqué aux
données d'entrée.
Code :
#Additional Info Step - Performing K-Means with Scaled Features
# Example of Scaling the Data and performing K-Means
from pyspark.ml.feature import StandardScaler
scalar_object = StandardScaler(inputCol='features',outputCol='ScaledFeatures')
scalar_model = scalar_object.fit(final_assembled_data)
final_scaled_data = scalar_model.transform(final_assembled_data)
print("\nConsolidated Data with Scaled Features")
final_scaled_data.show(4)
scaled_kmeans = KMeans(featuresCol='features',k=5)
scaled_kmeans_model = scaled_kmeans.fit(final_scaled_data)
scaled_predictions = scaled_kmeans_model.transform(final_scaled_data)
print("Prediction Data")
scaled_predictions.select('latitude','longitude','ScaledFeatures','prediction').show(4)
scaled_centres = scaled_kmeans_model.clusterCenters()
print("Scaled Tower Locations {}".format(scaled_centres))
Scaled_Silhouette_Score = evaluator_object.evaluate(scaled_predictions)
print("\nThe Silhouette Score when k=5 is {}".format(Scaled_Silhouette_Score))
#print("\nWithin set Sum of Square Error
{}".format(scaled_kmeans_model.computeCost(final_scaled_data)))
print("\nDetermining the number of users that belongs to each clusters")
scaled_predictions.groupBy('prediction').count().show()
explication :
1. Importer la classe StandardScaler du module pyspark.ml.feature pour mettre à l'échelle les
caractéristiques (features) des données.
2. Créer une instance de StandardScaler avec les colonnes d'entrée et de sortie spécifiées.
3. Appliquer le modèle de mise à l'échelle (scalar_model) sur les données d'entrée
(final_assembled_data) pour obtenir les données finales mises à l'échelle
(final_scaled_data). Les données mises à l'échelle sont affichées dans le DataFrame
final_scaled_data.
4. Créer une nouvelle instance du modèle K-Means (scaled_kmeans) en utilisant les
caractéristiques mises à l'échelle (featuresCol='features') et spécifier le nombre de clusters
(k=5).
5. Entraîner le modèle K-Means avec les données finales mises à l'échelle
(scaled_kmeans_model.fit(final_scaled_data)).
6. Appliquer le modèle entraîné (scaled_kmeans_model) sur les données finales mises à
l'échelle pour obtenir les prédictions (scaled_predictions). Les prédictions sont affichées dans
le DataFrame scaled_predictions en sélectionnant certaines colonnes.
7. Déterminer les centres des clusters mises à l'échelle (scaled_centres) à partir du modèle K-
Means.
8. Calculer le score de silhouette pour évaluer la qualité des clusters mises à l'échelle
(Scaled_Silhouette_Score).
9. Afficher le nombre d'utilisateurs appartenant à chaque cluster dans les prédictions
(scaled_predictions.groupBy('prediction').count().show()).
ce code met à l'échelle les caractéristiques des données, effectue le clustering K-Means sur les
données mises à l'échelle, et évalue la qualité des clusters obtenus en utilisant le score de
silhouette. Il fournit également des informations sur les centres des clusters et le nombre
d'utilisateurs appartenant à chaque cluster.
