Quiz 08 – Clustering K-means, silhouette et GraphFrames

• Jour 2
• 20 questions
• Seuil de réussite : 70 %
• 20 flashcards

Contenus évalués : apprentissage non supervisé et K-means ; centroïdes et affectation des courses ; choix de k par boucle et silhouette ; rôle de `seed` et numéros de `prediction` arbitraires ; `StandardScaler` comme Estimator et échelle des variables ; paramètre `featuresCol` sans normalisation ; lecture des centres sans normalisation ; comparaison des silhouettes ; heure cyclique et identifiants de zone comme variables ; description et nommage des familles de courses ; choix du clustering face à la régression et à la classification ; GraphFrames (sommets, arêtes, PageRank, degrés, jointure avec les zones, installation du JAR) ; mode dégradé avec `groupBy` quand GraphFrames est absent.

Une seule bonne réponse par question. Toutes les valeurs citées sont celles des TP de la formation. Le corrigé détaillé s’affiche après la correction. Ce quiz prépare le QCM de validation des acquis du dernier jour.

QCM

Question 1

Au TP 8, tu regroupes les courses en familles avec K-means. Pourquoi parle-t-on d'apprentissage non supervisé ?

• a) Parce que le modèle s'entraîne sans jeu de test séparé.
• b) Parce qu'aucune colonne n'indique la famille attendue : le modèle forme les groupes sans étiquette.
• c) Parce que Spark choisit lui-même le nombre de groupes k.
• d) Parce que les variables sont normalisées par StandardScaler avant l'entraînement.

Question 2

Après l'entraînement, tu affiches model.stages[-1].clusterCenters(). Que contient ce résultat, et comment K-means affecte-t-il une course à une famille ?

• a) Une course réelle par famille, la plus représentative ; chaque course rejoint la famille de la course réelle la plus proche.
• b) Les bornes minimale et maximale de chaque famille ; une course rejoint la famille dont elle respecte les bornes.
• c) Un centre par famille, la moyenne des points du groupe ; chaque course est affectée au centre le plus proche.
• d) Les probabilités d'appartenance de chaque course à chaque famille ; la course rejoint la famille la plus probable.

Question 3

Lis ce code du corrigé du TP 8.

for k in range(2, 7):
    model = Pipeline(stages=[assembleur, scaler, KMeans(k=k, seed=1)]).fit(df)
    resultats[k] = silhouette.evaluate(model.transform(df))
k_choisi = max(resultats, key=resultats.get)

Que fait-il ?

• a) Il entraîne un modèle pour chaque k de 2 à 6, mesure sa silhouette et retient le k qui a la plus haute ; ce choix reste à confronter au sens métier.
• b) Il entraîne un modèle pour chaque k de 2 à 7 inclus, mesure sa silhouette et retient le k qui a la plus haute.
• c) Il fait une validation croisée : chaque k est évalué sur des courses que le modèle n'a pas vues pendant l'entraînement.
• d) Il retient le k dont la silhouette est la plus basse, comme on retient la RMSE la plus basse en régression.

Question 4

Dans le TP 8, tu crées StandardScaler(inputCol="brut", outputCol="features", withMean=True, withStd=True). Que fait cette étape ?

• a) Elle ramène chaque variable entre 0 et 1.
• b) Elle divise chaque vecteur par sa norme pour que chaque course ait un vecteur de longueur 1.
• c) Elle supprime les montants extrêmes, qui fausseraient les centres.
• d) Elle centre chaque variable sur 0 et la ramène à un écart type de 1 : distance, montant et heure pèsent sur la même échelle.

Question 5

Tu évalues chaque k avec ClusteringEvaluator(featuresCol="features", metricName="silhouette"). Que mesure la silhouette ?

• a) Le pourcentage de courses rangées dans leur vraie famille.
• b) À quel point chaque point est proche de son groupe plutôt que des autres groupes : plus elle est haute, mieux les groupes sont séparés.
• c) La somme des distances de chaque point à son centre : plus elle est basse, meilleur est le modèle.
• d) La part de variance expliquée par les familles, comme le R² en régression.

Question 6

Deux valeurs de k obtiennent une silhouette presque égale. Le TP est réussi si 3 familles sont nommées avec des mots métier. Quelle démarche suit la consigne ?

• a) Retenir le k dont les familles ont le plus de sens métier, décrire chaque famille avec groupBy("prediction") (nombre de courses, distance, montant et heure moyens), puis la nommer, par exemple « longues / aéroport ».
• b) Retenir le plus grand k, toujours plus précis, et nommer les familles par leur numéro de prediction.
• c) Retenir le plus petit k et nommer les familles d'après leur taille : « grande famille », « petite famille ».
• d) Relancer avec d'autres seed jusqu'à départager les deux k, puis nommer chaque famille d'après sa zone de départ la plus fréquente.

Question 7

Tu relances K-means avec k = 3 sans StandardScaler, sur les variables brutes (distance, montant, heure). En affichant les centres, tu constates que l'heure moyenne est identique dans les trois familles. Quelle est l'explication ?

• a) L'heure est un entier : K-means ignore les variables entières.
• b) L'heure varie trop peu dans le jeu synthétique pour séparer des familles.
• c) Le montant, en dizaines de dollars, varie bien plus que l'heure (0 à 23) : il domine la distance euclidienne et l'heure ne joue aucun rôle.
• d) Il faudrait un k plus grand pour que l'heure fasse apparaître ses propres familles.

Question 8

Un participant remarque que la silhouette sans StandardScaler est plus élevée qu'avec. Que conclus-tu ?

• a) Le modèle sans normalisation est meilleur : il faut le garder.
• b) Le StandardScaler a introduit une fuite de données qui dégrade le score.
• c) Il faut normaliser après K-means plutôt qu'avant pour retrouver une bonne silhouette.
• d) Rien : les deux silhouettes sont calculées dans des espaces différents, features brutes contre features normalisées, et elles ne se comparent pas.

Question 9

Voici le bonus GraphFrames du corrigé, avec aretes construit à partir de PULocationID renommé src et de DOLocationID renommé dst.

g = GraphFrame(zones.withColumnRenamed("LocationID", "id"), aretes)
g.pageRank(resetProbability=0.15, maxIter=10).vertices.orderBy(F.desc("pagerank"))

Quelle lecture est juste ?

• a) Les sommets sont les courses, les arêtes relient leurs zones ; PageRank classe les courses les plus chères.
• b) Les sommets sont les 265 zones (colonne id), chaque course est une arête de src vers dst ; une zone a un fort PageRank si beaucoup de courses y arrivent, surtout depuis des zones elles-mêmes importantes.
• c) Les sommets sont les zones ; PageRank compte seulement le nombre de courses au départ de chaque zone.
• d) Le renommage en id sert seulement à l'affichage ; GraphFrame accepterait directement la colonne LocationID.

Question 10

Sur ton poste, from graphframes import GraphFrame échoue. Le script passe en mode dégradé et exécute aretes.groupBy("dst").count(), renommé en inDegree. Qu'obtiens-tu ?

• a) Le degré entrant de chaque zone, le même résultat que g.inDegrees ; en revanche tu perds PageRank, qui tient compte de l'importance des zones d'origine.
• b) Le PageRank exact de chaque zone, calculé sans le package.
• c) Le degré sortant de chaque zone, c'est-à-dire le nombre de courses au départ.
• d) Rien d'exploitable : sans GraphFrames, aucune analyse des zones n'est possible.

Question 11

Pour la partie 5 du TP 8, le corrigé entraîne K-means sans normalisation avec ce code.

brut = Pipeline(stages=[assembleur, KMeans(k=3, seed=1, featuresCol="brut")]).fit(df)

Pourquoi faut-il préciser featuresCol="brut" ?

• a) Pour demander à K-means de normaliser lui-même les variables avant de calculer les distances.
• b) Pour renommer la colonne de sortie, qui s'appellerait sinon features.
• c) Pour que la colonne des familles s'appelle brut au lieu de prediction.
• d) Parce que sans scaler, le seul vecteur est dans la colonne brut produite par l'assembleur ; K-means lit features par défaut, une colonne qui n'existe pas ici.

Question 12

Dans la boucle du TP 8, chaque modèle est créé avec KMeans(k=k, seed=1). À quoi sert seed=1 ?

• a) Il fixe à 1 le nombre de passes de l'algorithme sur les données.
• b) Il fixe le tirage aléatoire des centres de départ : tu retrouves les mêmes familles à chaque exécution, et la comparaison entre les k reste reproductible.
• c) Il indique que la première famille doit porter le numéro 1 dans la colonne prediction.
• d) Il fixe la fraction de courses échantillonnées pour entraîner le modèle.

Question 13

Tu as nommé tes familles à k = 3, puis tu réentraînes avec k = 4 pour comparer. La famille 0 de k = 4 ne ressemble plus du tout à la famille 0 de k = 3. Quel est le bon diagnostic ?

• a) Un bug : avec le même seed, la famille 0 doit toujours rester la même.
• b) C'est normal parce que la famille 0 est toujours la plus nombreuse, et les effectifs ont changé.
• c) C'est normal : les numéros de prediction sont des étiquettes arbitraires ; à chaque modèle, tu dois relire la description par groupBy("prediction") avant de rattacher un nom métier.
• d) C'est normal parce que K-means numérote les familles par distance moyenne croissante, et l'ajout d'une famille décale tous les numéros.

Question 14

Le TP 8 pose la question : l'heure est traitée comme un nombre, donc 23 h et 0 h sont « loin ». Quelle correction règle ce problème ?

• a) Représenter l'heure par deux variables, le sinus et le cosinus de sa position sur un cercle de 24 heures : 23 h et 0 h deviennent proches.
• b) Augmenter k pour qu'une famille dédiée aux courses autour de minuit apparaisse.
• c) Retirer l'heure du StandardScaler pour qu'elle garde ses valeurs de 0 à 23.
• d) Convertir l'heure en minutes depuis minuit pour gagner en précision.

Question 15

Dans la boucle, le StandardScaler est placé dans le Pipeline, et .fit(df) est rappelé pour chaque k. Que se passe-t-il pour le scaler au moment du fit ?

• a) Rien : c'est un Transformer qui applique une formule fixe, sans rien apprendre des données.
• b) C'est un Estimator qui apprend ses paramètres à partir des familles trouvées par K-means.
• c) C'est un Transformer ; dans ce pipeline, seul le VectorAssembler est un Estimator.
• d) C'est un Estimator : au fit, il calcule la moyenne et l'écart type de chaque variable sur df, puis le modèle obtenu applique ces valeurs pour normaliser avant K-means.

Question 16

Tu as fait pip install graphframes-py. L'import from graphframes import GraphFrame passe, mais la création de GraphFrame(...) échoue avec une erreur côté Java. Que manque-t-il ?

• a) La colonne id dans les sommets : il faut renommer LocationID en id.
• b) Une réinstallation du package Python, qui s'est mal terminée.
• c) Le JAR de GraphFrames, à déclarer avec spark.jars.packages=io.graphframes:graphframes-spark4_2.13:<version> ; c'est pour ce cas que le corrigé attrape Exception et pas seulement ImportError.
• d) Rien n'est possible : GraphFrames ne fonctionne pas avec Spark 4, seul le mode dégradé est utilisable.

Question 17

Le corrigé affiche les zones les plus desservies avec ce code.

g.inDegrees.join(zones, g.inDegrees.id == zones.LocationID).orderBy(F.desc("inDegree")).select("Zone", "inDegree").show(5)

Pourquoi la jointure avec zones est-elle nécessaire ?

• a) Pour retirer les zones sans aucune course, que inDegrees conserverait avec un degré de 0.
• b) Parce que inDegrees ne renvoie que l'identifiant id et le degré inDegree : la jointure ajoute le nom de la zone pour rendre le résultat lisible.
• c) Parce que c'est la jointure qui calcule le degré entrant en comptant les lignes de zones.
• d) Parce que inDegrees renvoie une ligne par course, qu'il faut regrouper par zone.

Question 18

Lis cette ligne du bonus GraphFrames.

g.pageRank(resetProbability=0.15, maxIter=10).vertices.orderBy(F.desc("pagerank")).select("id", "Zone", "pagerank").show(5)

Que t'affiche-t-elle, et que règle maxIter=10 ?

• a) Les 5 zones au PageRank le plus élevé ; maxIter=10 limite le calcul itératif de PageRank à 10 itérations.
• b) Les 10 zones au PageRank le plus élevé ; maxIter=10 fixe la taille du classement.
• c) Les 5 zones au PageRank le plus élevé ; maxIter=10 exclut les zones qui reçoivent moins de 10 courses.
• d) Les 5 zones au PageRank le plus faible ; maxIter=10 fixe le nombre de courses tirées par zone.

Question 19

Parmi ces situations, vues dans l'activité « quel type de problème ? », laquelle se traite avec un clustering comme au TP 8, et non avec une régression ou une classification ?

• a) Prédire si un client paiera par carte.
• b) Estimer la durée d'une course.
• c) Prévoir le nombre de courses demain à 18 h.
• d) Regrouper les zones selon leur activité horaire.

Question 20

Un participant ajoute PULocationID aux inputCols du VectorAssembler, en pensant que la zone de départ aidera à former les familles. Le StandardScaler reste en place. Quel est le problème ?

• a) Aucun : une fois normalisée, la zone devient une variable comme les autres.
• b) Le pipeline échoue, car K-means refuse les colonnes entières.
• c) PULocationID est un code, pas une quantité : deux numéros de zone proches ne désignent pas des zones proches, la distance euclidienne n'a donc pas de sens, et la normalisation n'y change rien.
• d) L'ajout d'une colonne de zone transforme le problème en apprentissage supervisé.

Corriger Recommencer

Flashcards

Cliquez sur une carte pour la retourner. Mélangez-les pour une révision active.

Question Pourquoi K-means relève-t-il de l'apprentissage non supervisé ?

◀ Précédente Retourner Suivante ▶ Mélanger 1 / 20