Quiz 02 – Spark Core : RDD, transformations et actions

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

Contenus évalués : SparkContext et SparkSession ; mode `local[*]` ; RDD immuable, lignée et tolérance aux pannes ; transformations paresseuses et actions ; dépendances narrow et wide ; PairRDD, `filter`, `map`, `count`, `take`, `collect`, `takeOrdered`, `reduceByKey`, `groupByKey`, `join`, `sortBy` ; jobs, stages et tâches découpés par le DAG scheduler ; shuffle et volume échangé sur le réseau ; lecture d'un CSV entre guillemets et diagnostic d'erreurs différées.

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 début du TP 2, tu écris sc = spark.sparkContext. Que récupères-tu dans sc ?

• a) Un nouveau SparkContext, indépendant de la session, qu'il faudra arrêter séparément.
• b) Le SparkContext contenu dans la SparkSession, qui sert à créer des RDD, par exemple avec sc.textFile.
• c) Un SQLContext, l'ancien point d'entrée hérité, qui sert à lancer des requêtes SQL.
• d) L'adresse de la Spark UI, que tu affiches ensuite avec print.

Question 2

lignes = sc.textFile("data/trips.csv")
entete = lignes.first()
courses = lignes.filter(lambda l: l != entete)

Après la troisième ligne, que contient lignes ?

• a) Les lignes sans l'en-tête, car filter a modifié lignes en place.
• b) Plus rien, car lignes a été remplacé par courses et n'est plus accessible.
• c) Toujours toutes les lignes avec l'en-tête : filter a créé un nouveau RDD courses, qui garde lignes dans sa lignée.
• d) Toutes les lignes sauf la première, car first() a retiré l'en-tête de lignes en le lisant.

Question 3

Tu exécutes ces deux cellules :

paires = champs.map(lambda c: (int(c[7]), float(c[16])))
ca_par_zone = paires.reduceByKey(lambda a, b: a + b)

Elles répondent instantanément, et l'onglet Jobs de la Spark UI ne montre aucun nouveau job. Pourquoi ?

• a) map et reduceByKey sont des transformations paresseuses : Spark note seulement le plan. Le calcul part au premier appel d'une action, comme takeOrdered.
• b) reduceByKey est une action, mais ses jobs s'affichent uniquement dans l'onglet Stages.
• c) Les données sont déjà calculées depuis le count() de l'étape 1, et Spark réutilise ce résultat.
• d) En local[*], Spark exécute les transformations directement sur ta machine, sans créer de job.

Question 4

map et filter sont des transformations dites narrow. Que signifie ce terme ?

• a) Elles ne gardent qu'une partie des données du RDD d'entrée.
• b) Ce sont des actions légères, qui ne renvoient qu'un petit volume de données.
• c) Elles traitent une seule partition à la fois, donc elles n'utilisent qu'un seul cœur.
• d) Chaque partition de sortie dépend d'une seule partition d'entrée : il n'y a pas d'échange entre partitions, donc pas de shuffle.

Question 5

Avec le code de la question 2, sur le fichier trips.csv du fil rouge, qu'affiche print(courses.count()) ?

• a) 120 001
• b) 120 000
• c) 19
• d) 265

Question 6

Pendant le calcul du top 10 sur un cluster, un Executor tombe. Les partitions de paires qu'il détenait sont perdues. Que fait Spark ?

• a) Il relit les copies de ces partitions sur un autre Executor, comme HDFS le fait avec les répliques des blocs.
• b) Il fait échouer le job, et tu dois tout relancer à la main.
• c) Il recalcule uniquement les partitions perdues en rejouant leur lignée : lecture du fichier, filter, puis map.
• d) Il ignore les partitions perdues et rend un résultat partiel, signalé dans la Spark UI.

Question 7

Tu appelles une action sur un RDD. Quelle phrase décrit correctement ce qui se passe ?

• a) Le DAG scheduler crée un job pour cette action et le découpe en stages à chaque shuffle. Chaque stage lance une tâche par partition.
• b) Chaque transformation devient un stage, et chaque stage est exécuté par une seule tâche sur un Executor.
• c) Chaque transformation a déjà lancé son propre job, et l'action se contente de rapatrier les résultats.
• d) Le DAG scheduler crée un stage par partition, et chaque stage contient une tâche par transformation.

Question 8

Combien de stages compte le job déclenché par cette ligne ?

rdd.map(f).filter(g).reduceByKey(h).map(k).count()

• a) 1
• b) 2
• c) 4
• d) 5

Question 9

Dans le bonus du TP 2, tu compares la colonne Shuffle Write de l'onglet Stages. Tu lis environ 480 Ko pour groupByKey().mapValues(sum) et environ 7 Ko pour reduceByKey. Quelle explication est la bonne ?

• a) reduceByKey ne fait aucun shuffle : les 7 Ko correspondent à la seule lecture du fichier.
• b) groupByKey envoie ses données sans compression, alors que reduceByKey les compresse avant l'envoi.
• c) groupByKey trie les valeurs de chaque clé avant l'envoi, ce qui ajoute des métadonnées.
• d) reduceByKey additionne d'abord sur chaque partition et n'envoie qu'un total par zone. groupByKey envoie toutes les valeurs, soit environ 70 fois plus de données.

Question 10

Un participant obtient une liste vide, sans aucun message d'erreur :

zones = (zl.filter(lambda l: l != zl_entete)
           .map(lambda l: next(csv.reader([l])))
           .map(lambda c: (c[0], f"{c[2]} ({c[1]})")))
resultat = sc.parallelize(top10).join(zones).sortBy(lambda kv: -kv[1][0])
resultat.collect()   # []

Quelle est la cause ?

• a) join ne garde pas l'ordre des lignes : il faut appeler sortBy avant le join, et non après.
• b) sc.parallelize(top10) produit un RDD vide, car top10 est une liste Python et non un RDD.
• c) Les clés n'ont pas le même type : '132' en texte dans zones, 132 en entier dans top10. Le join ne trouve aucune correspondance et ne signale rien.
• d) join exige deux RDD de même taille : il faut d'abord ramener zones à 10 lignes.

Question 11

Dans le TP 2, la session est créée avec .master("local[*]"). Que signifie l'étoile ?

• a) Spark lance autant de threads que de cœurs sur ta machine, et chaque thread peut exécuter une tâche.
• b) Spark se connecte à tous les workers disponibles sur le réseau local.
• c) Spark charge toutes les partitions en mémoire dès le démarrage de la session.
• d) Spark n'impose aucune limite de mémoire au driver.

Question 12

Parmi ces listes, laquelle ne contient que des actions ?

• a) map, count, take, collect
• b) reduceByKey, takeOrdered, collect, first
• c) join, sortBy, count, saveAsTextFile
• d) first, count, takeOrdered, saveAsTextFile

Question 13

À l'étape 2 du TP 2, tu exécutes :

paires = champs.map(lambda c: (int(c[7]), float(c[16])))
paires.take(3)

Que renvoie paires.take(3) ?

• a) Un nouveau RDD de 3 éléments, qui sera calculé au prochain collect.
• b) Les 3 premières lignes de trips.csv, en texte, telles qu'avant le split.
• c) Une liste Python de 3 tuples (PULocationID, total_amount), avec un entier puis un flottant, rapatriée sur le driver.
• d) Les 3 zones qui ont le plus gros chiffre d'affaires, triées par montant.

Question 14

Pour vérifier paires, l'énoncé utilise take(3). Un participant préfère afficher paires.collect(). Quel est le problème ?

• a) collect rapatrie les 120 000 paires dans la mémoire du driver, alors que take(3) n'en ramène que 3. Sur le mois réel, environ 3 millions de courses, le driver peut saturer.
• b) collect est une transformation : il ne renvoie rien tant qu'aucune action n'est appelée.
• c) collect ne fonctionne pas sur un PairRDD, seulement sur un RDD de lignes.
• d) collect déclenche un shuffle supplémentaire, alors que take reste dans un seul stage.

Question 15

Un participant oublie le signe moins à l'étape 4 :

top10 = ca_par_zone.takeOrdered(10, key=lambda kv: kv[1])

Qu'obtient-il dans top10 ?

• a) Le même top 10, car takeOrdered trie toujours par ordre décroissant.
• b) Les 10 zones au plus petit chiffre d'affaires, car takeOrdered garde les plus petites valeurs de la clé de tri.
• c) Les 10 zones aux plus petits identifiants, car la clé de tri est ignorée sur un PairRDD.
• d) Une erreur, car la fonction passée à key doit renvoyer une valeur négative.

Question 16

Dans le fichier des zones, csv.reader transforme une ligne en ['132', 'Queens', 'JFK Airport', 'Airports']. Le corrigé construit le nom avec f"{c[2]} ({c[1]})". Quel nom s'affiche en tête du top 10, avec environ 261 823 $ ?

• a) Queens (JFK Airport)
• b) 132 (Queens)
• c) Airports (Queens)
• d) JFK Airport (Queens)

Question 17

Tu veux maintenant le nombre de courses par zone de départ, à partir de paires. Quelle version donne le bon résultat en échangeant le moins de données sur le réseau ?

• a) paires.groupByKey().mapValues(len)
• b) paires.count()
• c) paires.map(lambda kv: (kv[0], 1)).reduceByKey(lambda a, b: a + b)
• d) paires.reduceByKey(lambda a, b: a + 1)

Question 18

Tu lances courses.count(), puis plus loin ca_par_zone.takeOrdered(10, key=lambda kv: -kv[1]). Dans la Spark UI, le job de takeOrdered relit trips.csv. Pourquoi ?

• a) Spark ne garde pas les RDD intermédiaires d'une action à l'autre : chaque action rejoue la lignée depuis la source, lecture du fichier comprise.
• b) courses est immuable : on ne peut pas le relire, il faut donc repartir du fichier.
• c) Le count() a consommé les lignes de courses, qui est vide après l'action.
• d) Le job du count() a échoué en silence, et Spark le relance automatiquement.

Question 19

Après resultat.collect() à l'étape 5, l'onglet Stages montre d'autres stages, en plus des 2 stages du calcul du top 10. D'où viennent-ils ?

• a) collect crée un stage par partition pour rapatrier les données sur le driver.
• b) sc.parallelize(top10) relit trips.csv, ce qui recrée les 2 stages du top 10.
• c) csv.reader s'exécute dans un stage dédié, un par ligne du fichier des zones.
• d) join et sortBy sont des transformations wide : chacune ajoute un shuffle, donc une frontière de stage.

Question 20

Un participant remplace csv.reader par un split :

zl = sc.textFile("data/taxi_zone_lookup.csv")
zl_entete = zl.first()
zones = (zl.filter(lambda l: l != zl_entete)
           .map(lambda l: l.split(","))
           .map(lambda c: (int(c[0]), f"{c[2]} ({c[1]})")))

La cellule s'exécute sans erreur. Une ValueError apparaît seulement plus loin, sur resultat.collect(). Quel diagnostic est le bon ?

• a) L'en-tête n'est pas retiré, donc int("LocationID") échoue. L'erreur sort au collect parce que filter s'exécute après les map.
• b) Tous les champs sont entre guillemets : split(",") donne '"132"', et int échoue sur les guillemets. L'erreur sort au collect, car les map sont paresseux et ne s'exécutent qu'à l'action.
• c) Les clés sont des entiers d'un côté et du texte de l'autre : le join lève une ValueError au moment de les comparer.
• d) Les guillemets font échouer int dès la cellule zones, mais Spark garde l'erreur en mémoire et ne l'affiche qu'au collect.

Corriger Recommencer

Flashcards

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

Question spark.sparkContext

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