Dr.

Heni Bouhamed
Co-Founder of DataCamp Training https://datacamp-training.com
Co-Founder & Product Owner of ZettaSpark https://zettaspark.io
Senior Lecturer at SFAX University, Tunisia
Senior Lecturer at ESTYA University, Paris, Montpellier, France

Lab Apache Spark : Data Frames, ETL,

SQL, ML et Streaming
1) Charger le fichier Iris1.csv en dataframe avec :
df=spark.read.load("file:///home/u1/Iris1.csv",format="csv",sep=",",inferSchema="tru
e", header="true") ou
df=sqlContext.read.format('csv').options(header='true',inferschema='true').load('file:///
home/u1/Iris1.csv')
En scala : val df = spark.read.option("delimiter"," ,").option("header",
"true").option("inferSchema", "true").csv('file:///home/u1/Iris1.csv')
2) Compter le nombre de ligne du data frame avec : df.count()
3) Afficher les 10 premières lignes du data frame avec : df.show(10)
4) Exécuter l’ensemble des commandes précédentes avec spark-submit en créant un
code python ayant comme entête les deux lignes de codes suivantes :
from pyspark.sql import SparkSession
spark = SparkSession.builder.getOrCreate()
5) Exécuter le code en mode cluster avec spark-submit --deploy-mode cluster (client
par défaut)
6) Enregistrer le data frame df dans votre dossier personnel sous forme de fichier csv
avec : df.write.save("file:///home/u1/iris",format="csv")
7) Charger un data frame avec le contenu du fichier csv déjà enregistré via l’étape
précédente avec dfc = spark.read.csv("file:///home/u1/iris",
sep=",",inferSchema="true")
8) Enregistrer une autre fois le data frame df avec df.write.save(‘file:///home/u1/irisp’)
et inspecter le résultat
9) Enregistrer une autre fois le data frame df avec son entête :
df.write.option("header",True).save("file:///home/u1/irish",format="csv")
10) Afficher les types de champs avec : df.dtypes
11) Afficher le schéma, les types et la possibilité d’avoir des valeurs manquantes: avec
df.schema
12) Afficher des statistiques concernant les données avec : df.describe().show()
13) Afficher les noms de colonnes avec : df.columns
14) Compter le nombre d'éléments distincts avec : df.select("species").distinct().count()
15) Enregistrer le data frame sur hdfs avec le format json :
df.write.save("hdfs://localhost:9000/iris",format="json")
16) Inspecter le résultat sur hdfs
17) Charger les données json à partir de hdfs avec
df1=spark.read.json("hdfs://localhost:9000/iris")
18) Inspecter le résultat avec df1.show()
19) Enregistrer le data frame sur hdfs avec le format parquet :
df1.write.save("hdfs://localhost:9000/irisp",format="parquet")
20) Inspecter les données sur hdfs

1
21) Charger les données parquet à partir de hdfs avec :
df2=spark.read.parquet("hdfs://localhost:9000/irisp")
22) Inspecter les données avec df2.show()
23) Démarrer zkServer, hbase et lancer phoenix avec : sqlline.py
24) Créer une table ayant comme nom example2 avec CREATE TABLE example2
(my_pk bigint not null, m.first_name varchar(50), m.last_name varchar(50)
CONSTRAINT pk PRIMARY KEY (my_pk));
25) Insérer une ligne de données avec : upsert into example2 values(1,'tt','fms');
26) Charger les données de cette table via spark avec : df =
sqlContext.read.format("org.apache.phoenix.spark").option("table",
"example2").option("zkUrl", "localhost:2181").load()
27) Charger un data frame dans la table example2 :
dfm = spark.createDataFrame([(3, "2", "foo"),(4, "5", "bar")],
["MY_PK","M.FIRST_NAME","M.LAST_NAME"])
dfm.write.format("org.apache.phoenix.spark").mode("overwrite").option("table",
"example2").option("zkUrl", "localhost:2181").save()
28) Afficher le résultat avec df.show()
29) Télécharger le connecteur mysql mysql-connector-java-5.1.47.jar, à copier dans
votre dossier personnel avant de lancer pyspark --jars /home/u1/mysql-connector-
java-5.1.47.jar
30) Accéder à mysql en tant que root (password : hadoop) et créer une base de données
tt dans laquelle créer une table emp avec deux champs ; id de type int et name de
type string, insérer quelques lignes de données dans cette table et charger son
contenu dans spark avec df =
spark.read.format("jdbc").option("driver","com.mysql.jdbc.Driver").option("url",
"jdbc:mysql://localhost:3306/tt").option("useSSL", "false").option("dbtable",
"emp").option("user","root").option("password","hadoop").load()
31) Charger les données Iris1.csv une autre fois avec :
df=spark.read.load("file:///home/u1/Iris1.csv",format="csv",sep=",",inferSchema=
"true", header="true")
32) Sélectionner la colonne sepal_length avec df.select("sepal_length").show()
33) Sélectionner les colonnes sepal_length et species avec
df.select("sepal_length","species").show()
34) Sélectionner la colonne sepal_length dont les valeurs sont supérieurs à 5 avec :
df.select("sepal_length",df.sepal_length > 5).show()
35) Filtrer et afficher les lignes dont les petal_length sont strictement supérieures à 6
avec : df.filter(df["petal_length"]>6).show().
(En scala: df.filter(df("petal_length")>6).show())
36) Filtrer et afficher les lignes dont les petal_length sont strictement supérieures à 6 et
strictement inférieur à 7 avec df.filter((df["petal_length"]>6) &
(df["petal_length"]<7)).show()
(En scala: df.filter(df("petal_length")>6 && df("petal_length")<7).show())
37) Filtrer et afficher les lignes dont les petal_length sont strictement supérieures à 6
ou strictement inférieur à 7 avec df.filter((df["petal_length"]>6) |
(df["petal_length"]<7)).show()
(En scala: df.filter(data("petal_length")>6 || data("petal_length")<7).show())
38) Compter les « species » par groupe avec : df.groupBy(df["species"]).count().show().
(En scala: df.groupBy(data("species")).count().show()
39) Afficher les 10 premières lignes avec : df.head(10)
40) Sélectionner les différentes « species » en utilisant une requête sql avec :

2
df.registerTempTable("table")
distinct_classes = sqlContext.sql("select distinct species from table")
(En scala: val sqlContext = new org.apache.spark.sql.SQLContext(sc)
data.registerTempTable("table")
val res = sqlContext.sql("select distinct species from table"))
41) Ajouter la colonne city au data frame avec les mêmes données que species :
df1 = df.withColumn('city',df.species)
42) Créer le data frame suivant : dfm = spark.createDataFrame([(1, "foo"),(2,
"bar")],["id", "label"])
43) Importer Row avec from pyspark.sql import Row
44) Créer le data frame suivant avec Row : df = spark.createDataFrame([Row(a=1, b=4.,
c='GFG1', d=1, e=2000)])
45) Créer un nouveau data frame df avec : data = [('James','Smith','M',3000),
('Anna','Rose','F',4100), ('Robert','Williams','M',6200)]
columns = ["firstname","lastname","gender","salary"]
df = spark.createDataFrame(data=data, schema = columns)
df.show()
46) Ajouter à df une colonne bonus_percent ayant une valeur constante de 0.3 :
from pyspark.sql.functions import lit
df.withColumn("bonus_percent", lit(0.3)).show()
47) Ajouter à df une colonne DEFAULT_COL ayant des valeurs Null avec
df.withColumn("DEFAULT_COL", lit(None)).show()
48) Ajouter à df une colonne bonus_amount qui sera 30% du salaire :
df.withColumn("bonus_amount", df.salary*0.3).show()
49) Importer concat_ws avec from pyspark.sql.functions import concat_ws
50) Ajouter à df une nouvelle colonne name qui sera la concaténation du firstname et
du lastname avec : df.withColumn("name",
concat_ws(",","firstname",'lastname')).show()
51) Importer when avec from pyspark.sql.functions import when
52) Ajouter à df une colonne grade selon le salaire avec df.withColumn("grade",
when((df.salary < 4000), lit("A")).when((df.salary >= 4000) & (df.salary <= 5000),
lit("B")).otherwise(lit("C"))).show()
53) Créer les deux data frames suivants :
dff = spark.createDataFrame([Row(w=1,z='a'),Row(w=2,z='b')])
dfm = spark.createDataFrame([(1, "foo"),(2, "bar")],["mat", "label"])
54) Fusionner dff et dfm horizontalement avec :
from pyspark.sql.functions import monotonically_increasing_id
dff = dff.withColumn("idi",monotonically_increasing_id() )
dff.show()
dfm = dfm.withColumn( "idi", monotonically_increasing_id() )
dfm.show()
horiztnlcombined_data = dff.join(dfm,dff.idi == dfm.idi, how='inner')
horiztnlcombined_data.show()
final=horiztnlcombined_data.select('w','z','mat','label')
final.show()
55) Remplacer le contenu de la colonne label avec tt si bar, null si non :
from pyspark.sql.functions import when
final = final.withColumn("label", when(final.label == "bar","tt"))
final.show()
56) Remplacer les valeurs Null de label par cloud :

3
 final = final.withColumn("label",
when(final.label.isNull(),"cloud").otherwise(final.label))
final.show()
57) Créer un data frame dfm:
dfm = spark.createDataFrame([(1, "foo"),(2, "bar")],["id", "label"])
58) Ajouter une colonne city avec les valeurs de id
dfm = dfm.withColumn('city',dfm.id)
dfm.show()
59) Changer le nom de la colonne city en cities :
dfm = dfm.withColumnRenamed('city', 'cities')
dfm.show()
60) Supprimer la colonne cities :
dfm = dfm.drop("cities")
dfm.show()
61) Créer un data frame avec deux lignes de données puis ajouter une nouvelle ligne à
ce dernier avec :
columns = ['id', 'dogs', 'cats']
vals = [(1, 2, 0), (2, 0, 1)]
df = spark.createDataFrame(vals, columns)
df.show()
newRow = spark.createDataFrame([(4,5,7)], columns)
df = df.union(newRow)
df.show()
62) Créer le data frame df suivant :
data = [
("James",None,"M"),
("Anna","NY","F"),
("Julia",None,None)
]
columns = ["name","state","gender"]
df = spark.createDataFrame(data,columns)
df.show()
63) Remplacer les valeurs null par hello :
df.na.fill('hello').show()
64) Créer le data frame df suivant :
data = [
("James",None,"M"),
("Anna","NY","F"),
("Julia",None,None)
]
columns = ["name","state","gender"]
df = spark.createDataFrame(data,columns)
df.show()
65) Supprimer les lignes ayant des valeurs nulles avec :
df.na.drop().show()
--Naive Bayes--
1) Importer Naives Bayes de ML avec : from pyspark.ml.classification import
NaiveBayes.

4
2) Importer la base de données Iris1.csv avec
df=spark.read.load("file:///home/u1/Iris1.csv",format="csv",sep=",",inferSchema="tru
e", header="true")
3) Transformer le data frame df en indexant la variable classe « species » et en créant un
vecteur de « features » avec :
from pyspark.ml.feature import StringIndexer
speciesIndexer = StringIndexer(inputCol="species", outputCol="speciesIndex")
from pyspark.ml.feature import VectorAssembler
vectorAssembler=VectorAssembler(inputCols=["petal_width","petal_length","sepal_
width","sepal_length"], outputCol="features")
data = vectorAssembler.transform(df)
index_model = speciesIndexer.fit(data)
data_indexed = index_model.transform(data)
4) Visualiser une partie du résultat avec : data_indexed.show(2).
5) Diviser aléatoirement les données en base d’apprentissage et en base de test avec :
trainingData, testData = data_indexed.randomSplit([0.8, 0.2],0.0).
6) Configurer le modèle avec : nb =
NaiveBayes().setFeaturesCol("features").setLabelCol("speciesIndex").setModelType("
multinomial").
7) Lancer l’apprentissage du modèle avec : model = nb.fit(trainingData).
8) Effectuer la classification de la base test avec : classifications =
model.transform(testData) (classifications est un data frame contenant les toutes les
données tests ainsi que les valeurs de prédictions).
9) Importer les fonctions d’évaluations des modèles de classification avec : from
pyspark.ml.evaluation import MulticlassClassificationEvaluator.
10) Configurer l’évaluation avec la métrique accuracy avec : evaluator =
MulticlassClassificationEvaluator(labelCol="speciesIndex",
predictionCol="prediction", metricName="accuracy").
11) Calculer le pourcentage de bonnes classifications avec : accuracy =
evaluator.evaluate(classifications).
12) Afficher le résultat avec : print("Test set accuracy = " + str(accuracy))
13) #étape optionnelle : visualiser toutes les prédictions avec :
classifications.select('prediction').show().
14) Configurer l’évaluation avec la métrique Recall avec : evaluator =
MulticlassClassificationEvaluator(labelCol="speciesIndex",
predictionCol="prediction", metricName="weightedRecall").
15) Exécuter avec : recall = evaluator.evaluate(classifications).
16) Afficher le résultat avec : print("Test set recall = " + str(recall)).
Rq : l’évaluation supporte aussi le f1score "f1" (par défaut) ainsi que le
"weightedPrecision".
--neural network--
17) Etape 2 et 11.
18) Diviser aléatoirement les données en base d’apprentissage et en base de test avec :
trainingData, testData = data_indexed.randomSplit([0.8, 0.2],0.0).
19) Importer la fonction MultilayerPerceptronClassifier avec : from
pyspark.ml.classification import MultilayerPerceptronClassifier
20) Choisir le nombre de layers adéquat avec : layers = [4, 5, 4, 3].
21) Configurer le modèle avec : nn =
MultilayerPerceptronClassifier().setLayers(layers).setLabelCol("speciesIndex").setFea
turesCol("features").setBlockSize(120).setSeed(1234).

5
22) Lancer l’apprentissage du modèle avec : model = nn.fit(trainingData).
23) Effectuer la classification de la base test avec : classifications = model.transform(testData).
24) Refaire les étapes de 17 à 20 pour l’évaluation avec :
from pyspark.ml.evaluation import MulticlassClassificationEvaluator.
evaluator = MulticlassClassificationEvaluator(labelCol="speciesIndex",
predictionCol="prediction", metricName="accuracy")
accuracy = evaluator.evaluate(classifications)
print("Test set accuracy = " + str(accuracy))
25) Essayer une architecture plus profonde avec : layers = [4, 1000, 1000, 3].
26) Configurer le modèle avec les nouvelles couches : nn =
MultilayerPerceptronClassifier().setLayers(layers).setLabelCol("speciesIndex").setFeature
sCol("features").setBlockSize(120).setSeed(1234).
27) Lancer l’apprentissage avec : model = nn.fit(trainingData).
28) Effectuer la classification de la base test avec : classifications = model.transform(testData).
29) Refaire les étapes de 17 à 20 pour l’évaluation avec :
from pyspark.ml.evaluation import MulticlassClassificationEvaluator
evaluator = MulticlassClassificationEvaluator(labelCol="speciesIndex",
predictionCol="prediction", metricName="accuracy")
accuracy = evaluator.evaluate(classifications)
print("Test set accuracy = " + str(accuracy))
--Arbre de décision--
30) Répéter les étapes 2 et 11.
31) Diviser aléatoirement les données en base d’apprentissage et en base de test avec :
trainingData, testData = data_indexed.randomSplit([0.8, 0.2],0.0).
32) Importer la fonction des arbres de décision avec : from pyspark.ml.classification import
DecisionTreeClassifier
33) Configurer le modèle avec : dt =
DecisionTreeClassifier().setLabelCol("speciesIndex").setFeaturesCol("features").
34) Lancer l’apprentissage avec : model = dt.fit(trainingData).
35) Effectuer la classification de la base test avec : classifications = model.transform(testData)
36) Refaire les étapes de 17 à 20 pour l’évaluation avec :
from pyspark.ml.evaluation import MulticlassClassificationEvaluator
evaluator = MulticlassClassificationEvaluator(labelCol="speciesIndex",
predictionCol="prediction", metricName="accuracy")
accuracy = evaluator.evaluate(classifications)
print("Test set accuracy = " + str(accuracy))
-- Random forest--
37) Répéter l’étape 2 et 11.
38) Diviser aléatoirement les données en base d’apprentissage et en base de test avec :
trainingData, testData = data_indexed.randomSplit([0.8, 0.2],0.0).
39) Importer la fonction random forest avec : from pyspark.ml.classification import
RandomForestClassifier.
40) Configurer le modèle avec : rf =
RandomForestClassifier().setLabelCol("speciesIndex").setFeaturesCol("features").setNu
mTrees(40).
41) Lancer l’apprentissage avec : model = rf.fit(trainingData).
42) Effectuer la classification de la base test avec : classifications = model.transform(testData).
43) Refaire les étapes de 17 à 20 pour l’évaluation avec :
from pyspark.ml.evaluation import MulticlassClassificationEvaluator
evaluator = MulticlassClassificationEvaluator(labelCol="speciesIndex",
predictionCol="prediction", metricName="accuracy")
accuracy = evaluator.evaluate(classifications)
print("Test set accuracy = " + str(accuracy))

6
--Arbre de décision pour la régression--
df=spark.read.option("inferSchema",
"true").csv("file:///home/u1/real_estate.csv",header=True)
df.show()
real_estate.printSchema()
df.printSchema()
from pyspark.ml.feature import VectorAssembler
assembler = VectorAssembler(inputCols=[
'X1 transaction date',
'X2 house age',
'X3 distance to the nearest MRT station',
'X4 number of convenience stores',
'X5 latitude',
'X6 longitude'],
outputCol='features')
data_set = assembler.transform(df)
data_set.select(['features','Y house price of unit area']).show(2)
train_data,test_data = data_set.randomSplit([0.7,0.3])
from pyspark.ml.regression import DecisionTreeRegressor
dt = DecisionTreeRegressor(labelCol='Y house price of unit area')
model = dt.fit(train_data)
from pyspark.ml.evaluation import RegressionEvaluator
predictions = model.transform(test_data)
evaluator = RegressionEvaluator(labelCol="Y house price of unit area",
predictionCol="prediction", metricName="rmse")
rmse = evaluator.evaluate(predictions)
print("Root Mean Squared Error (RMSE) on test data = %g" % rmse)
RMSE: Root Mean Square Error = Écart quadratique moyen
evaluator = RegressionEvaluator(labelCol="Y house price of unit area",
predictionCol="prediction", metricName="r2")
R2 squared = Coefficient of determination
r2 = evaluator.evaluate(predictions)
print("R2 on test data = %g" % r2)

Projet : Appliquer random forest regressor pour la même base de données

7
--Exemple de Streaming en RDD--

from pyspark import SparkContext

from pyspark.streaming import StreamingContext

# Create a local StreamingContext with two working thread and batch interval of 10 second
sc = SparkContext("yarn", "NetworkWordCount")
ssc = StreamingContext(sc, 10)
# Create a DStream that will connect to hostname:port, like localhost:9999
lines = ssc.socketTextStream("localhost", 9999)
# Split each line into words
words = lines.flatMap(lambda line: line.split(" "))
# Count each word in each batch
pairs = words.map(lambda word: (word, 1))
wordCounts = pairs.reduceByKey(lambda x, y: x + y)

# Print the first ten elements of each RDD generated in this DStream to the console
wordCounts.pprint()
ssc.start() # Start the computation
ssc.awaitTermination() # Wait for the computation to terminate

--Exemple de Streaming en DataFrame--

from pyspark.sql import SparkSession

from pyspark.sql.functions import explode
from pyspark.sql.functions import split
spark=SparkSession.builder.appName("StructuredNetworkWordCount").getOrCreate()
lines = spark.readStream.format("socket").option("host", "localhost").option("port",
9999).load()
words = lines.select(explode(split(lines.value, " ")).alias("word"))
query=words.writeStream.format("csv").option("format", "append").option("path",
"file:///home/u1/strem1").option("checkpointLocation",
"file:///home/u1/checkpoint1").outputMode("append").start()
query.awaitTermination()

--Exemples de Streaming via Kafka--

Démarrage de Zookeeper et de kafka :

zkServer.sh start
cd kafka/bin
sudo ./kafka-server-start.sh /home/u1/kafka/config/server.properties
~/kafka/bin/kafka-topics.sh --create --topic test-topic --bootstrap-server localhost:9092
~/kafka/bin/kafka-topics.sh --list --bootstrap-server localhost:9092
~/kafka/bin/kafka-console-producer.sh --topic user-tracker-hh --broker-list localhost:9092
Lancement de pyspark avec les dépendances spark-sql-kafka :
pyspark --packages org.apache.spark:spark-sql-kafka-0-10_2.11:2.2.0

Lecture du topic kafka user-tracker-hh :

df = spark.readStream.format("kafka").option("kafka.bootstrap.servers",
"localhost:9092").option("subscribe", "user-tracker-hh").load()

Write stream sur la console :

query = df.writeStream.outputMode("append").format("console").start()
query.awaitTermination()

8
********query.stop()********* pour lancer query avec d’autre possibilités

Write stream sur la console avec casting en string :

query = df.selectExpr("CAST(key AS STRING)", "CAST(value AS
STRING)").writeStream.format("console").option("checkpointLocation",
"/user/u1/dir").start()
query.awaitTermination()

Write stream sur la console en sélectionnant seulement la valeur en string :

query = df.selectExpr("CAST(value AS
STRING)").writeStream.format("console").option("checkpointLocation",
"/user/u1/dir").start()
query.awaitTermination()
query.stop()

Write stream csv en local en sélectionnant seulement la valeur string :

query = df.selectExpr("CAST(value AS STRING)").writeStream.format("csv").option("path",
"file:///home/u1/res").option("checkpointLocation", "/user/u1/dir").start()
query.awaitTermination()
// can be "orc", "json", "parquet", etc

Write stream csv sur hdfs en sélectionnant seulement la valeur string :

query = df.selectExpr("CAST(value AS STRING)").writeStream.format("csv").option("path",
"hdfs://localhost:9000/res").option("checkpointLocation", "/user/u1/dir").start()
query.awaitTermination()
// can be "orc", "json", "parquet", etc

Write stream dans une table temporaire en sélectionnant seulement la valeur string :
query = df.selectExpr("CAST(value AS
STRING)").writeStream.format("memory").queryName("tablename").start()
query.awaitTermination()
dframe = sqlContext.table("tablename")

Write stream json sur la console avec une structure de données définie :
from pyspark.sql.types import StructType,StructField, StringType, IntegerType
from pyspark.sql.functions import from_json
from pyspark.sql.functions import col
schema = StructType([
StructField("user_id",IntegerType(),True),
StructField("user_name",StringType(),True),
StructField("user_address",StringType(),True),
StructField("platform",StringType(),True),
StructField("signup_at",StringType(),True)
])
json_df = df.selectExpr("cast(value as string) as value")
json_expanded_df = json_df.withColumn("value", from_json(json_df["value"],
schema)).select("value.*")
exploded_df = json_expanded_df.select("user_id", "user_name", "user_address", "platform",
"signup_at").writeStream.format("console").start()
exploded_df.awaitTermination()

python3.6 p.py (lancer le producteur kafka json)