Pour l'aide sur l'utilisation de Spark voir ici

Commencer par copier et décompresser dans votre espace de travail le fichier

/Infos/bd/spark/bdle/2015/data/wordcount.txt.bz2

Le fichier obtenu, wordcount.txt (45Mo), contient des statistiques d’accès aux pages Wikimdia en différentes langue. Une ligne de la forme En.d updates 3 24145 indique dans une page écrite en anglais (symbole ‘En’), intitulée ‘updates’ qui a été cliqué 3 fois et qui fait 24145 octets.

Lancer le spark-shell en mode local (voir Doc) en suivant les instructions fournies puis charger le fichier

 wordcount.txt 

au moyen de la méthode textFile() invoquée à partir de la variable context comme suit :

 val data = sc.textFile("<le_chemin_dans_votre_espace_perso>/wordcount.txt")

Ici, la variable data est une RDD, et donc, de type Array tel que vous pouvez le constater sur le shell. L’invocation de la méthode take(n) sur cette variable affiche les n premiers éléments sur une seule ligne. Pour un affichage sur plusieurs lignes (tel un head -n sous linux), utiliser plutôt take(n).foreach(println) qui itère sur les éléments de la variable d’où elle est invoquée et affiche chaque élément sur une ligne séparément. Noter également que la méthode count retourne la cardinalité (nombre d’éléments) de la RDD d’où elle est invoquée. Par soucis de lisibilité de votre code, stocker le résultat de chaque question dans des variables nommées q1, q2, q3 etc. Penser à tester au fur et à mesure le résultat des instructions lorsque celles-ci ne contiennent que des transformations.

1. Extraire le 4e champ de chaque élément de data et le convertir en type double
2. Construire à partir de q1 une liste contenant les nombres compris strictement entre 1000 et 1300 puis convertir en type entier.
3. Construire à partir de q2 une liste contenant les multiples de 3 et l’appeler q33. Faire de même pour les multiples de 4 et l’appeler q34.
4. Construire une liste obtenue en divisant par 10 chaque élément de q33.
5. Construire à partir de q4 un ensemble d’éléments (liste sans doublons).Construire une liste contenant les éléments de q2 qui sont multiples de 3 et de 4 à la fois. Utiliser impérativement q33 et q34.
6. Construire une liste contenant les éléments de q2 qui sont multiples de 3 mais pas de 4. Utiliser impérativement q33 et q34.
7. Construire à partir de q2 une liste contenant les éléments de q2 multiples de 3 ou de 10.
8. Convertir les éléments de q8 en type Double puis calculer la somme (q9sum), le minium (q9min) ainsi que le maximum (q9max) des éléments de q8. Calculer la moyenne (q9avg) en utilisant un operateur parmi reduce, fold et aggregate.
9. Retourner pour chaque élément distinct de q2 le nombre de fois qu’il apparaît dans cette liste.

1. Structurer le contenu de data de sorte à obtenir un tableau de tableaux de chaines de caractères. Ce dernier devra être stocké dans une nouvelle variable nommée list.
2. Afficher ensuite les 100 premiers éléments de la 3e colonne de list.
3. Transformer le contenu de list en une liste de paires (‘mot’, nb) où mot correspond à la première colonne de list et nb sa troisième colonne.
4. Grouper les paires par ‘mot’ et additionner leur nombre nb.
5. Reprendre les questions 13 et 14 en calculant ‘mot’ différemment : désormais, ‘mot’ doit correspondre au préfixe du premier sous-élément de chaque élément de list, çad, pour en.d, mot doit être en, pour fr.d, mot doit être fr, etc. Comparer les résultats avec ceux obtenus précédemment.

Cet exercice s’intéresse à la formulation de jointures simples en Scala. Pour cet exercice, utiliser le jeux de données films (cf Jeux de données) qui contient les fichiers :

• ratings.dat
• users.dat
• movies.dat

Comme d’habitude, commencez par formater les données afin de pouvoir les traiter.

Pour information :

• chaque ligne de ratings.dat est de la forme UserID::MovieID::Rating::Timestamp
• chaque ligne de users.dat est de la forme UserID::Gender::Age::Occupation::Zip-code
• chaque ligne de movies.dat est de la forme MovieID::Title::Genres.

Pour plus d'informations, voir movielens.

Charger et Transformer en tableau de String chaque ligne des fichiers ratings.dat, users.dat et movies.dat dans les variables notes, utilis, et films respectivement en effectuant les conversions de type nécessaires tel que indiqué dans le schéma suivant :

• notes (UserID : entier, MovieID : entier, Rating : entier, Timestamp : entier)
• utils (UserID, Gender, Age, Occupation, Zip-code)
• films (MovieID, Title, Genres)

Exprimer en Scala les requêtes suivantes

1. le nombre de notes (ratings) réalisées par chaque utilisateur identifié par son UserID
2. le nombre de notes (ratings) réalisées par chaque localisation donnée par le Zip-code
3. le nombre de notes (ratings) réalisées par chaque groupe de genres de film. (voir Remarque ci-dessous)
4. les 10 utilisateurs ayant noté le plus de films.
5. les films ayant reçu le moins de notes
6. les utilisateurs n’ayant noté aucun film

Remarque : on considère dans un premier temps qu’un genre est représenté par le groupe de genres donné par la chaine de caractères de l’attribut Genres. Dans un second temps, on considère les genres « atomiques » qui sont séparés par des barres « | ». Pour ce faire, déplier les données de films et les stocker dans une valeur intermédiaire films_bis qui contient un nuplet de fims avec un genre à la fois. Par exemple, pour le nuplet (1,Toy Story (1995),Animation|Children's|Comedy) de films, il existe trois nuplets dans films_bis : (1,Toy Story (1995),Animation), (1,Toy Story (1995), Children's) et (1,Toy Story (1995), Comedy). Indice: pour construire films_bis, il est possible d’imbriquer une fonction map à l’intérieur d’une autre (cf. question 2 de l’exercice 3).

1. Expliquer le résultat de ys dans les deux cas suivants : val ys = Map(“a” → List(1 → 11,1 → 111), “b” → List(2 → 222,2 → 22)).flatMap(_._1) et val ys = Map(“a” → List(1 → 11,1 → 111), “b” → List(2 → 222,2 → 22)).flatMap(_._2)
2. Faire de même pour les instructions suivantes : var pers = Array( (1,“pierre”), (5,“alice”), (4, “paul”)) et var v=pers.flatMap(x⇒x._2)

En considérant la variable pers de la question précédente, expliquer le résultat des instructions suivantes

• pers.flatMap(x⇒(x._2) map(y⇒y))
• pers.flatMap(x⇒(x._2) map(y⇒x._1))
• pers.flatMap(x⇒(x._2) map(y⇒x._2))

et expliquer pourquoi les deux instructions suivantes sont erronées

• pers.flatMap(x⇒(x._1) map(y⇒y))
• pers.flatMap(x⇒(x._2) map(y⇒y._1)))