ESI : 2024-2025 Matière : Big Data Analytics
TP 4: Machine Learning sur SPARK ML
Objectif :
L’objectif de ce TP est d’introduire les notions de base de machine learning
sur Spark ML ainsi que la notion de pipeline. Quelques algorithmes de ML pour
l’extraction de caractéristiques, la classification et de clustring seront
traités comme exemples.
1. Source de données :
• Image data source :
Cette source de données d'image est utilisée pour charger des fichiers image
à partir d'un répertoire, elle peut charger une image compressée (jpeg, png,
etc.). Le DataFrame chargé a une StructType column : "image", contenant les
données d'image stockées sous forme de schéma d'image. Le schéma des colonne
d’image est représenté par le tableau ci-dessous :
Spark.read.formet("image").option("dropInvalid",true).load("data/…")
• LIBSVM data source
Cette source de données permet de charger des fichiers de type 'libsvm' depuis
un répertoire. Le DataFrame chargé comporte deux colonnes : label contenant
des étiquettes stockées sous forme de doubles et des fonctionnalités contenant
les fonctionnalités stockés sous forme de vecteurs. Le schéma des colonnes
est:
• label: DoubleType (représente l’instance label)
• features: VectorUDT(représente le vecteur de caractéristiques)
ESI : 2024-2025 Matière : Big Data Analytics
2. Transformer, Estimator, parameter
1. Importer les packages
import org.apache.spark.ml.classification.LogisticRegression
import org.apache.spark.ml.linalg.{Vector, Vectors}
import org.apache.spark.ml.param.ParamMap
import org.apache.spark.sql.Row
2. Création du dataset d’apprentissage (training data)
val training = spark.createDataFrame(Seq(
(1.0, Vectors.dense(0.0, 1.1, 0.1)),
(0.0, Vectors.dense(2.0, 1.0, -1.0)),
(0.0, Vectors.dense(2.0, 1.3, 1.0)),
(1.0, Vectors.dense(0.0, 1.2, -0.5))
)).toDF("label", "features")
3. Création d’une instance d’un algorithme d’apprentissage (ex : Logistic resgression)
val lr = new LogisticRegression()
4. Afficher les paramètres par défaut
ESI : 2024-2025 Matière : Big Data Analytics
println(s"LogisticRegression parameters:\n ${lr.explainParams()}\n")
5. Modifier les paramètres de la régression suivant le besoin. Exemple :
lr.setMaxIter(10)
.setRegParam(0.01)
6. Créer le modèle en utilisant l’algorithme d’apprentissage sur les données d’apprentissage. Le
model1 est un transformer produit à partir d’un estimateur(lr).
val model1 = lr.fit(training)
- Afficher les paramètres utilisés lors de cette apprentissage :
println(s"Model 1 was fit using parameters: ${model1.parent.extractParamMap()}")
7. Les paramètres peuvent être spécifiés en utilisant ParamMap :
val paramMap = ParamMap(lr.maxIter -> 20)
.put(lr.maxIter, 30) // spécifie 1 Param. qui écrase la valeur originale
.put(lr.regParam -> 0.1, lr.threshold -> 0.55) // spécifie plusieurs Params.
- Une combinaison des paramètres est possible :
val paramMap2 = ParamMap(lr.probabilityCol -> "myProbability") // Change le nom de
la colonne de sortie.
val paramMapCombined = paramMap ++ paramMap2
8. Créer un nouveau modèle avec les nouveaux paramètres :
val model2 = lr.fit(training, paramMapCombined)
println(s"Model 2 was fit using parameters: ${model2.parent.extractParamMap()}")
9. Préparer les données de tests :
val test = spark.createDataFrame(Seq(
(1.0, Vectors.dense(-1.0, 1.5, 1.3)),
(0.0, Vectors.dense(3.0, 2.0, -0.1)),
(1.0, Vectors.dense(0.0, 2.2, -1.5))
)).toDF("label", "features")
10. Faire une prédiction sur les données de test en utilisant la méthode Transformer.transform()
ESI : 2024-2025 Matière : Big Data Analytics
model2.transform(test)
.select("features", "label", "myProbability", "prediction")
.collect()
.foreach { case Row(features: Vector, label: Double, prob: Vector, prediction:
Double) => println(s"($features, $label) -> prob=$prob, prediction=$prediction")
}
3. Pipeline :
1. Importer les packages :
import org.apache.spark.ml.{Pipeline, PipelineModel}
import org.apache.spark.ml.classification.LogisticRegression
import org.apache.spark.ml.feature.{HashingTF, Tokenizer}
import org.apache.spark.ml.linalg.Vector
import org.apache.spark.sql.Row
2. Préparer les données d’apprentissage :
val training = spark.createDataFrame(Seq(
(0L, "a b c d e spark", 1.0),
(1L, "b d", 0.0),
(2L, "spark f g h", 1.0),
(3L, "hadoop mapreduce", 0.0)
)).toDF("id", "text", "label")
3. Configurer le pipline qui consist en trois étapes : tokenizer, hashingTF, et lr
val tokenizer = new Tokenizer()
.setInputCol("text")
.setOutputCol("words")
val hashingTF = new HashingTF()
.setNumFeatures(1000)
.setInputCol(tokenizer.getOutputCol)
.setOutputCol("features")
val lr = new LogisticRegression()
.setMaxIter(10)
.setRegParam(0.001)
val pipeline = new Pipeline()
.setStages(Array(tokenizer, hashingTF, lr))
4. Appliquer le pipeline sur les données d’apprentissage :
val model = pipeline.fit(training)
5. On peut à ce niveau persister le pipeline :
ESI : 2024-2025 Matière : Big Data Analytics
model.write.overwrite().save("/tmp/spark-logistic-regression-model")
On peut le charger quand on a besoin lors de la production par exemple :
val sameModel = PipelineModel.load("/tmp/spark-logistic-regression-model")
6. Préparer les données de tests, sans étiquette (label):
val test = spark.createDataFrame(Seq(
(4L, "spark i j k"),
(5L, "l m n"),
(6L, "spark hadoop spark"),
(7L, "apache hadoop")
)).toDF("id", "text")
7. Faire la prédiction sur les données de tests :
model.transform(test)
.select("id", "text", "probability", "prediction")
.collect()
.foreach { case Row(id: Long, text: String, prob: Vector, prediction: Double)
=> println(s"($id, $text) --> prob=$prob, prediction=$prediction") }
4. Extracting, transforming and selectiong Features :
Cette étape consiste à extraire les caractéristiques à partir d’une
collection de données. Plusieurs algorithme d’extraction peuvent être
utilisés suivant le besoin.
Nous considérons comme exemple l’algorithme TF-IDF (Term frequency-inverse
document frequency)qui permet est très utilisé dans le domaine du textmining.
Cet algorithme permet de savoir l’importance d’un terme dans un document
corpus. Soit le terme t et d le document et D le corpus. la fréquence du
terme est égale au nombre de fois ce terme se trouve dans le document d. La
fréquence de document est considérée comme le nombre de document qui contient
le terme t.
Pour cela, nous avons besoin des fonctions suivantes :
• Tokenizer: un transformateur de caractéristiques. C’est le processus
qui permet d’avoir les termes (mots) à partir d’un texte ou une
phrase.
• HashingTF : est un tranformer qui prend un ensemble de terms comme
entrée et donne des vecteurs de caractéristiques de tailles fixe. les
deux algorithme HashingTF et CountVectorizer peuvent être utilisés
pour générer le vecteur fréquence de terme TF
• IDF: est un estimateur qui s'ajuste sur un jeu de données et produit
un IDFModel. Le IDFModel prend des vecteurs de caractéristiques
(généralement créés à partir de HashingTF ou CountVectorizer) et met
ESI : 2024-2025 Matière : Big Data Analytics
à l'échelle chaque entité. Intuitivement, il sous-pondère les
caractéristiques qui apparaissent fréquemment dans un corpus.
1. Importer les fonctions
import org.apache.spark.ml.feature.{HashingTF, IDF, Tokenizer}
2. Création d’une collection de données sous forme de texte (sentence) avec des étiquettes
(labels) :
val sentenceData = spark.createDataFrame(Seq(
(0.0, "Hi I heard about Spark"),
(0.0, "I wish Java could use case classes"),
(1.0, "Logistic regression models are neat")
)).toDF("label", "sentence")
3. Transformer le texte en termes
val tokenizer = new Tokenizer().setInputCol("sentence").setOutputCol("words")
val wordsData = tokenizer.transform(sentenceData)
4. Transformer les termes en vecteurs de caractéristiques (features extraction)
val hashingTF = new HashingTF()
.setInputCol("words").setOutputCol("rawFeatures").setNumFeatures(20)
val featurizedData = hashingTF.transform(wordsData)
// alternatively, CountVectorizer can also be used to get term frequency vectors
5. Création du modèle à l’aide de l’estimateur IDF () qui implémente la méthode fit () qui prends
les données comme entrée et produit le modèle.
val idf = new IDF().setInputCol("rawFeatures").setOutputCol("features")
val idfModel = idf.fit(featurizedData)
val rescaledData = idfModel.transform(featurizedData)
rescaledData.select("label", "features").show()
ESI : 2024-2025 Matière : Big Data Analytics
