scala
Les outils spark sont :
- Spark Streaming : il permet d'accéder à des données en temps réel.
- Spark SQL: il permet d’interroger et modifier les données comme avec des requêtes
classiques.
- Spark MLlib pour des modèles de Machine Learning.
- GraphX pour le calcul et la création de graphes.
1. Scala
Spark est basé sur le langage scala qui est un langage de programmation orienté objet et
fonctionnel. spark scala manipule les RDDs via des instructions de transformation et
d’actions.
Création d’un RDD (Dataset)
La création d’un RDD est le résultat du chargement des données ou la transformation d’un
RDD existant.
Exemples :
1. val words = sc.textFile(“file:///home/hadoop/Downloads/words_alpha.txt")
- words est le Nom de RDD
- sc : spark context
- words contient toutes les données du fichier words_alpha.txt
2. val purchases = sc.texFile(“hdfs:///im1/purchases.txt”)
⇒ il s’agit de créer un RDD (purchases) contenant les données du fichier
purchases.txt, stocké dans le hdfs (hadoop).
sachant que purchases.txt est un fichier de données défini par les colonnes
suivantes : date, heure, store, item, cost and payment. Pour identifier les
différentes colonnes, nous pouvons le charger en tant que fichier csv en indiquant
le séparateur de colonnes.
3. val purchases_col =
spark.read.option(“delimiter”,”\t”).csv(“hdfs:///im1/purchases.txt”)
- purchase_col est un dataset formaté en colonne.
- spark.read.option().csv() : permet de charger un fichier text comme un
CSV, et ce , en indiquant le séparateur de colonne dans la partie option
de la lecture.
- afin de définir deux options d’un fichier de données telles que : le nom
de colonne et le séparateur de colonne, nous pouvons définir ces options
comme suit :
val purchases_headercol = spark.read.option(“delimiter”,”\t”).option(“header”,
“true”).csv(“hdfs:///im1/purchases.txt”)
A. Les actions
collect() Elle retourne toutes les lignes du Dataset comme un tableau au
programme driver.
exemple :
val purchases = sc.textFile(“hdfs:///im1/purchases.txt”
purchases.collect() :
count() Elle retourne le nombre de lignes du Dataset.
purchases.count() : retourne le nombre de lignes dans le RDD purchases
take(n) retourne le n premières lignes du Dataset
purchases.take() : retourne le première lignes
first() Retourner la première ligne du Dataset (équivalent à take(1) .
purchases.first() : retourne la première ligne
show(n) Afficher les n premières lignes du Dataset sous forme de tableau.
purchases.show(10) : affiche les 10 premières lignes sous forme d’un
dataframe (ligne et des colonnes)
foreach(func) Appliquer la fonction func à toutes les lignes.
purchases.foreach(println) : applique la fonction (println) pour chaque
ligne du RDD purchases
reduce(func) Agréger les éléments du Dataset en utilisant la fonction func (qui prend
2 arguments et retourne 1 résultat)
purchases.map(l=>1).reduce((a,b)=>a+b)
cette instruction scala retourne le nombre de ligne dans le dataset
purchases elle équivalente à : purchases.count().
elle est composée de :
- map(l=>1) : chaque ligne sera remplacée par 1 où l=1 est une
fonction anonyme.
- reduce((a,b)=>a+b) permet d'agréger les résultats retournés par
la fonction map.
Exercice : Soit le fichier words_alpha.txt contenant les mots en anglais.
1. Avec deux manières différentes, déterminer le nombre de mots dans ce
fichier.
2. Calculer le nombre total de caractères dans ce fichier
3. Déterminer quelle est la taille maximale des mots
4. Déterminer la taille moyenne des mots.
correction :
a. chargement des words_alpha.txt
val words =
sc.textFile(“File:///home/hadoop/Downloads/words_alpha.txt”)
1. Le nombre de mots dans words
2. _alpha.txt
a1. words.count() : retourne le nombre de mots dans le fichier
words_alpha.txt
a2. words.map(l=>1).reduce((a,b)=>a+b) : retourne le nombre de mots
dans le fichier words_alpha.txt
3. Le nombre total de de caractères dans word _alpha.txt
words.map(l=>l.length).reduce((a,b)=>a+b)
4. la taille maximale des mots
words.map(l=>l.length).reduce((a,b)=>if (a>b) a else b)
5. la taille minimale des mots
words.map(l=>l.length).reduce((a,b)=>if (a>b) b else a)
6. taille moyenne des mots
words.map(l=>l.length).reduce((a,b)=>a+b)/words.count()
B. Les transformations
filter() Retourne un nouveau RDD dont le contenu vérifiant la condition de
filtre
exemple :
- val purchasesAtlanta = purchases.filter(l=>l.contains(“Atlanta”)).
- val motseas = words.filter(l=>l.contains(“eas”))
map Elle permet d’appliquer une fonction de transformation et elle retourne
le même nombre de lignes de dataset d ‘origine.
flatmap Elle permet d’appliquer une fonction flatmap qui peut retourner
plusieurs lignes par lignes de RDD source. exemple si le RDD est est
un texte et pour compter le nombre des mots du texte.
val texte = sc.textFile(“file:///home/hadoop/Downloads/texte.txt”
mots = texte.flatmap(l=>lsplit(“ “))
union Elle permet de grouper les lignes de deux rdds.
val rddAtlanta = sc.textFile(“hdfs:///im1/purchases.txt”)
val rddVisa = sc.textFile(“hdfs:///im1/purchases.txt”)
val rddresult = rddAtlanta.union(rddVisa)
intersection Elle retourne les lignes communes de deux dataset(Rdds).
exemple
val purchases = sc.textFile(“hsdfs:///im1/purchases.txt”)
val purchasesAtlanta = purchases.filter(l=>l.contains(Atlanta”))
val purchasesBooks = purchases.filter(m=>m.contains(“Books”))
val resultIntersection = purchasesAtlanta.intersection(purchasesBooks )
l’inverse de cette commande permettant de retourner les lignes vérifiant la
distinct rdd sans doublons
join join de deux rdd selons une clé
