APACHE SPARK MLIB : PRINCIPES ET CONCEPTS POUR LA MISE

EN ŒUVRE DES MÉTHODES D’APPRENTISSAGE

DR MUSTAPHA MICHRAFY

CONTACT : DATASCIENCE.KM@GMAIL.COM
PLAN M.MICHRAFY

1. Contexte
2. Objectif et prérequis
3. Spark MLIB, Motivations
4. Concepts pour la mise en place des algorithmes de Spark ML
5. DataFrame, Motivations
6. Pipeline et ses composants
7. API Pipeline en Spark MLIB
8. ‘Transformers’ et ‘Estimators’ en Spark MLIB
9. Transformer : étapes
10. Gestion des paramètres en Spark MLIB
11. Quelques ‘Transformers’ et ‘Estimators’
12. Techniques pour l’évaluation d’une méthode d’apprentissage
13. API pour l’évaluation d’un algorithme d’apprentissage sous Spark ML
14.Validation croisée
15. Illustration et mise en œuvre sous Spark ML

2
CONTEXTE M.MICHRAFY

Cette étude a été menée dans le cadre des rencontres de travail

organisées au Laboratoire CERMSEM, Centre d'Économie de la
Sorbonne (CES).

Elle vise à présenter les étapes pour la mise en œuvre d’une

méthode d’apprentissage dans le cadre de Spark ML ( API
d’apprentissage de SPARK).

3
OBJECTIF ET PRÉREQUIS M.MICHRAFY

Objectif Prérequis
Cette étude vise à présenter les étapes d’un • Connaissance du langage Scala
workflow pour la mise en place des • Connaissance de Spark et Spark SQL
méthodes d’apprentissage basées sur l’API • Connaissance des méthodes
Apache Spark ML. d’apprentissage

4
SPARK ML : MOTIVATIONS ? M.MICHRAFY

SPARK ML ? Fonctionnalités
• Spark ML est une brique logiciel incontournable de • Préparer, enrichir, transformer des données
la plate forme Apache Spark. • L’API de Spark ML propose plusieurs transformateurs
• L’API Spark ML est dédiée à la mise en place des • Algorithmes pour le développement et la mise au
méthodes d’apprentissage. point des méthodes de :
• Spark ML offre des services couvrant la o Classification
préparation des données, l’enrichissement, la o Régression
mise au point des méthodes d’apprentissage, et le o Clustering
déploiement. o Recommandation

• En Apache Spark, deux API sont dédiées aux méthodes

d’apprentissage :
1. Spark ML : il est basé sur l’API DataFrame
2. Spark MLIB : il est basée sur RDD.
• Dans cette présentation, nous nous intéressons seulement à
Spark ML. Par conséquent, l’API Spark MLIB ne sera pas abordée.

5
CONCEPTS POUR LA MISE EN PLACE DES ALGORITHMES DE
DataFrame
C’est une structure de
données distribuée, orientée
colonne et adaptée pour les
données statistiques ou
méthodes d’apprentissage
Estimators
Ce sont des algorithmes visant
à ajuster une fonction entre les
variables explicatives et la
variable cible. Les algorithmes
s’appuient sur les données
d’une DataFrame.
SPARK ML
Transformers
Ce sont des algorithmes
permettant de transformer une
dataFrame en une autre
Parameters
Les Transformers et Estimators
partagent la même API pour
Concepts spécifier les paramètres.
Spark ML Pipeline
Un pipeline est constitué de plusieurs
Transformers et Estimators pour la
mise en place d’un workflow ML.

Evaluators Cross Validation

Technique pour mettre au
Mesures pour évaluer la
point une méthode
performance d’une méthode
d’apprentissage
d’apprentissage.

6
DATAFRAME : MOTIVATIONS

Variété des données

• Les méthodes d’apprentissage
trouvent des applications dans • Alors quelle structure
divers domaines, et nécessitant de données utilisée ?
divers types de données.

DataFrame est constituée de Popularisée par R,

n lignes (les individus) repris par python(Pandas)
m colonnes (les variables) enfin, étendue par Saprk SQL
une colonne est typée (vecteur)
• Distribuée, résiliente, orientée
colonne, optimisée
• Supportant divers types de
données, inclus les vecteurs

DataFrame

7
PIPELINE ET SES COMPOSANTS

PIPELINE
 Un pipeline est une séquence d’étapes finies.
 Chaque étape est associée à un Estimator ou un Transformer
 Un Estimator est une interface qui doit implémenter la
méthode fit()
 Un transformer est une interface nécessitant l’implémentation
de la méthode transform()
 Transformer.transform() et Estimator.fit() sont des états légers.
 Chaque instance du Transformer ou Estimator dispose d’un
identifiant unique.
Transformer Estimator

8
API PIPELINE EN SPARK MLIB

Pipeline & PipelineStage Etape de Transformation Etape d’Estimation

• Une méthode d’apprentissage • Pour une étape de • Pour une étape d’estimation, la
fait appel à des phases de transformation, la méthode méthode fit() d’un Estimator est
traitement, et d’apprentissage. transform() est appelée sur une appelée sur une dataframe pour
• Un Pipeline, en Spark MLIB, est Dataframe et retourne une produire un Transformer
une séquence d’éléments de DataFrame.
type pipelineStage.
• Chaque PipelineStage est
constitué d’un Transformer ou
d’un Estimator. DataFrame DataFrame
• Par conséquent, l’ordre des
étapes (PiplineStage) est
important

Pipeline
DataFrame Transformer

PipelineStage
9
TRANSFORMER ET ESTIMATOR EN SPARK MLIB

Transformer Estimator Package

• Un transformer permet de
transformer des données.
• En Spark ML, un transformer
permet de transformer une
DataFrame en une autre
DataFrame.
• Transformer est une classe
abstraite qui étend la classe
abstraite pipelineStage.
• Un estimateur permet d’évaluer • Les implémentations de transformer
ou approcher un paramètre
inconnu.
• Un estimateur statistique vise à
évaluer un paramètre inconnu
via un échantillon de données
• En Spark ML, un Estimator est un
opérateur qui prend en entrée
une DataFrame et retourne un
Transformer.
dans :org.apache.spark.ml.feature
• Des implémentation d’Estimators dans :
org.apache.spark.ml.regression
org.apache.spark.ml.recomendation
org.apache.spark.ml.clustering
org.apache.spark.ml.feature
org.apache.spark.ml.classification
…
….

Params
Estimator & Transformer

DataFrame DataFrame
Hiérarchie :

Transformer

Estimator
PipelineStage

Estimator Transformer DataFrame Transformer

10
ETAPES POUR LE TRANSFORMATEUR & ESTIMATEUR

Transformateur Estimateur

Créer l’opérateur de
transformation Créer l’estimateur

Positionner les paramètres Positionner les paramètres

d’entrée d’entrée

fit : ajuster le modèle selon

les données

transform : générer la transform : générer la

nouvelle DataFrame nouvelle DataFrame

11
PARAMETRES
Intérêt Serializable
• Les transformateurs, les
estimateurs, les évaluateurs ParamPair Param
nécessitent des paramètres.
• Spark ML propose un package
dédié à la gestion des ParamMap Params
paramètres, partagé par les
estimateurs et les LongParam
transformateurs.

BooleanParam
Package Param
DoubleParam
• Le package est :
org.apache.spark.ml.param FloatParam
• La classe de base est Param. StringArrayParam
• Des spécialisations de Param, IntParam
sont proposées, portant sur des IntArrayParam Transformer
primitifs (Int, Long, Float,
Boolean,Double, String, IntArray, DoubleArrayParam Estimator
…)
• Les classes Transformer et
Estimator étendent la classe 12
Params.
QUELQUES TRANSFORMERS ET ESTIMATORS

Transformers Estimators

 Tokenization : segmenter un texte en une liste de mots.
 Binarization : transformer des valeurs numériques en
valeurs binaires.
 Normalizer : normaliser des vecteur en utilisant p-norm.
 StringIndexer : coder des catégories
 IndexToString : décoder des index
 VectorIndexer : identifier des variables catégorielles
selon un seuil de fréquence

 N-gram : calculer le prochain caractère à partir d’une
séquence d’article
 MinMaxScaler : transformer une variable quantitative
vers une variable quantitative avec des valeurs dans
un intervalle donné.
 QuantileDiscretizer : transformer une variable
quantitative en une variable qualitative en utilisant le
quantile
 StandardScaler : normaliser un vecteur en utilisant la
variance

 Etc.  Etc.

13
EVALUER UNE MÉTHODE D’APPRENTISSAGE

Mesure d’évaluation ?
• Pour évaluer la performance d’une
méthode d’apprentissage, nous
utilisons des mesures dédiées.
• Quelles sont les mesures d’évaluation
pour les méthodes de classification?
• Pour un individu donné, une
mesure d’évaluation exploite la
valeur ajustée et la valeur de
référence. • Quelles sont les mesures d’évaluation
• Nous avons des mesures pour : pour les méthodes de régression?
1. les méthodes de régression
2. les méthodes de classification.

• Le choix de la méthode
d’évaluation dépend du problème
traité et de la connaissance métier
associée.
14
EVALUER UNE MÉTHODE D’APPRENTISSAGE : CLASSIFICATION

Matrice de confusion Mesures d’évaluation La courbe de ROC

• Elle vise à mesurer la qualité • Sensibilité : le taux de cas • La courbe ROC (receiver
d'une méthode de positifs correctement identifiés operating characteristic) est
classification. • Spécificité : le taux de cas utilisée pour évaluer la
• Elle indique si la méthode négatifs correctement identifiés performance d’un classifier
parvient à classifier • Accuracy : le taux de cas binaire.
correctement les individus. positifs ou négatifs • La courbe de ROC est la
Prédite correctement identifiés. courbe qui donne la sensibilité
• F-mesure : le taux qui combine en fonction de la spécificité.
Positif Négatif
la sensibilité et la spécificité
Réelle

Positif TP FN
Négatif FP TN
Matrice de confusion

• Les mesures d’évaluation utilisent les notions : • Formules :

1. VP (vrais positifs) : nombre de positifs classés positifs 1. Sensibilité = VP/(VP+FN)
2. FP (faux positifs) : nombre de négatifs classés positifs 2. Spécificité = VN/(VN + FN)
3. FN (faux négatifs) : nombre de positifs classés négatifs 3. Accuracy = (VP + VN)/(VP + VN + FP + FN)
4. VN(vrais négatifs) : nombre de négatifs classés 4. F2 = 2.(Sensibilité+Spécificité)/(Sensibilité + Spécificité)
négatifs
15
EVALUER UNE MÉTHODE D’APPRENTISSAGE : RÉGRESSION

Intérêt des mesures

𝑛

• Elle vise à mesurer la qualité d'une 𝑀𝑆𝐸 = 𝑦𝑙 − 𝑦𝒍 2

méthode de régression en 𝑙=1

calculant une erreur globale
• Une erreur est proche de zéro RMSE = 𝑀𝑆𝐸
indique la pertinence du modèle
𝑛

𝑀𝐴𝐸 = 𝑦𝑙 − 𝑦𝑙
Principales mesures
𝑙=1

• MSE : Erreur quadratique moyenne

(mean Squared Error) 𝑅 2 = 1 − 𝑀𝑆𝐸 𝑛
𝑙=1(𝑦𝑙 − 𝑦)2
• RMSE : c’est la racine carrée de MSE
(root Mean Squared Error)
𝑛 (𝑦𝑙 − 𝑦𝑙 )
• R : Coefficient de détermination 𝑙=1 𝑦𝑙
• MAE : Erreur absolue moyenne 𝑀𝐴𝑃𝐸 = . 100
𝑛
(mean Absolute Error)
• MAPE : Erreur absolue moyenne en
pourcentage (Mean Absolute y𝑙 𝑒𝑠𝑡 𝑙𝑎 𝑣𝑎𝑙𝑒𝑢𝑟 𝑟é𝑒𝑙, (𝑦 est la moyenne de 𝑦 )
Percentage Error) 𝑦𝑙 𝑒𝑠𝑡 𝑙𝑎 𝑣𝑎𝑙𝑒𝑢𝑟 𝑎𝑗𝑢𝑠𝑡é𝑒,
𝑛 𝑑𝑒𝑠𝑖𝑔𝑛𝑒 𝑙𝑒 𝑛𝑜𝑚𝑏𝑟𝑒 𝑑′𝑜𝑏𝑠𝑒𝑟𝑣𝑎𝑡𝑖𝑜𝑛𝑠
16
API POUR L’ÉVALUATION D’UN ALGORITHME D’APPRENTISSAGE 1/2

 Evaluator : Classe abstraite pour l’évaluation
de la méthode d’apprentissage.
 Le package : org.apache.spark.ml.evaluation
 Trois méthodes à implémenter :
1. Evaluate : évaluer le modèle
2. copy : copier une instance du modèle
3. uid : associer un ID
 L’API Spark ML propose trois implémentations pour la classe
abstraite Evaluator.
 Les classes sont :
1. RegressionEvaluator pour les méthodes de régression
2. BinaryClassificationEvaluator : pour les méthodes de
classification binaire
3. MulticlassClassificationEvaluator : pour les méthodes de
classification muti-classes.

Evaluator

Pour la régression RegressionEvaluator

Pour la classification binaire BinaryClassificationEvaluator

Pour la classification multi-classes MulticlassClassificationEvaluator

17
API POUR L’ÉVALUATION D’UN ALGORITHME D’APPRENTISSAGE 2/2

 RegressionEvaluator : une classe dédiée aux Package : org.apache.spark.ml.evaluation

algorithmes de régression.
 Différentes mesures sont proposées:
1. RMSE (par défaut) Evaluator
2. MSE
3. R2
4. MAE
 BinaryClassificationEvaluator : une classe
dédiée à l’évaluation des algorithmes de RegressionEvaluator
MulticlassClassificationEvaluator
classification binaire.
 Elle propose deux mesures :
1. areaUnderROC (par défaut) BinaryClassificationEvaluator
2. areaUnderPR

 MulticlassClassificationEvaluator : une classe
dédiée à l’évaluation des algorithmes de
classification multi-modales.
 Elle propose différentes mesures :
1. F1 (par défaut)
2. weightedPrecision
3. weightedRecall
4. accuracy
Pour les trois classes d’évaluation, il est possible de fixer :
1. Le nom de la colonne label avec la méthode setlabelCol
2. Le nom de la colonne prédite avec la méthode
setPredictionCol
3. La mesure d’évaluation avec la méthode setMetricName
18
VALIDATION CROISÉE 1/2
Intérêt
• La validation croisée est une
méthode d’estimation de fiabilité
d’un modèle, basée sur une
Alors quelles sont les méthodes
technique d’échantillonnage.
portant sur la validation croisée ?
• Elle permet :
• d’optimiser les paramètres du
modèle,
• d’éviter le sur-apprentissage

• Diviser l'échantillon de taille n en deux sous • Diviser les données en k échantillons(i..k)

échantillons : apprentissage (>60%), test (<
30%).
• Le modèle est ajusté sur l'échantillon
d'apprentissage et validé sur l'échantillon de
test.
• L'erreur est estimée en calculant une mesure
ou un score de performance du modèle sur
l'échantillon de test.
Testset validation
• Sélectionner un échantillon i pour la validation
et le reste des données pour l'apprentissage.
• Calculer le score de performance
• Répéter les étapes 2-3 en sélectionnant un
autre échantillon de validation.
• Estimer l’erreur de prédiction en calculant la
moyenne des k erreurs quadratiques
moyennes
k-fold Cross-validation
19
VALIDATION CROISÉE 2/2

Tests et validation k-fold Cross-validation

A. Diviser l'échantillon de taille n en deux sous
échantillons : apprentissage (> 60%), test (< 30%).
B. Le modèle est ajusté sur l'échantillon d'apprentissage
et validé sur l'échantillon de test.
C. L'erreur est estimée en calculant une mesure ou un
score de performance du modèle sur l'échantillon de
test.
1. Diviser les données en k échantillons(i..k)
2. Sélectionner un échantillon i pour la validation et le
reste des données pour l'apprentissage.
3. Calculer le score de performance
4. Répéter les étapes 2-3 en sélectionnant un autre
échantillon de validation.
5. Estimer l’erreur de prédiction en calculer la moyenne
des k erreurs quadratiques moyennes

DT
A 3
B Ajuster le modèle sur DA et
valider le modèle sur DT
C Estimer l’erreur e
DA : données d’apprentissage
DT : données de test
DA 1 e1
2 e2
.
.
4 .
5
6 e6
Appliquer A et B pour chaque couple d’échantillon
Calculer les erreurs e1 ….e6
Calculer l’erreur de prédiction
20
 M.MICHRAFY
ML TUNING : SÉLECTION DU MODÈLE ET CHOIX DES PARAMÈTRES

Tuning sous Spark ML

• Spark ML propose des outils (ML org.apache.spark.ml.tuning
tuning) pour la sélection et
l’optimisation d’un modèle.
• Spark ML tuning s’appuie sur : associé au
• La validation croisée
• L’ étude du comportement des Estimator Pipeline
paramètres nécessite s’applique sur
Tuning ML
Tuning et classes associées Evaluator Estimator
• La package portant sur le tuning ML
est org.apache.spark.ml.tuning Paramètres est un
• Spark ML Tuning propose deux
classes étendant Estimator :
1. CrossValidator : pour la
validation croisée
2. TrainValidationSplit : pour CrossValidation TrainValidationSplit
l’optimisation des paramètres
d’une méthode ML.
• Les deux classes nécessitent :
• Estimator
• Evaluator 21
• Parameters
ML TUNING : CROSSVALIDATOR

CrossValidator
• CrossValidator est la classe
dédiée à la validation croisée.
• C’est l’implémentation de la
méthode k-fold.
• Elle ne dispose pas de
constructeur
Mise en place ?
Deux étapes : initialisation et
réalisation
• Etape initialisation : fixer les
paramètres d’entrée
• Etape d’ajustement : CrossValidatorModel.
effectuer la validation croisée
via la méthode fit
Classe
CrossValidator
Etape d’Initialisation
Etape d’ajustement
modélise
Méthode k-fold
• Estimator : fixer l’estimateur ML ou le
pipeline.
• Evaluator : fixer la mesure d’évaluation.
• EstimatorParamMaps : fixer les paramètres
de l’estimateur ML
• numFolds : fixer le nombre de fold
• Seed : initialiser le générateur aléatoire
• fit : cette méthode applique la validation
croisée et génère les modèles associés.
• Elle retourne un objet de type

Alors, quelle sont les méthodes de la classe

CrossValidationModel ?
22

ML TUNING : CROSSVALIDATORMODEL
CrossValidatorModel
• CrossValidatorModel est la
classe qui encapsule le
modèle de validation
croisée.
• Une instance de la classe
CrossValidatorModel est
retournée par la méthode fit
de de l’objet CrossValidator
M.MICHRAFY
Fonctionnalités
• avgMetrics : permet d’accéder à la mesure moyenne pour chaque entrée
de la map des paramètres.
• bestModel : retourne le meilleur modèle identifié pendant la validation
croisée.
• save : enregistre le modèle ML dans un fichier.
• write : retourne une instance de MLwriter qui encapsule le modèle ML.
• Transform : prédire les valeurs de la variable dépendante pour les données
de test. Cette méthode applique le meilleur modèle identifié
23
API SPARK ML : VUE PACKAGES

Package dédié la gestion des Package pour la préparation

paramètres. et le formatage des données.

Package pour l’ évaluation

des méthodes
d’apprentissage
Package dédié aux méthodes Package dédié aux méthodes
de classification de clustering

Package pour la mise au point

des méthodes ML

Package dédié aux méthodes Package dédié aux méthodes

de recommandation de régression

24
MISE EN ŒUVRE SOUS APACHE SPARK ML

• Cette section présente la mise en œuvre sous Spark ML :

1. Les transformateurs et les estimateurs pour la préparation et formatage des

données
2. Les pipelines
3. L’évaluation des méthodes d’apprentissage
4. La mise au point d’un algorithme d’apprentissage

• Les exemples ont été réalisés avec Apache Spark version 2.0.2
• Le langage utilisé est Scala.

• Un prérequis de base en méthodes d’apprentissage est nécessaire

25
LES DONNÉES UTILISÉES

• Description : le jeu de données porte sur la pollution de l’air (112 individus et 13 variables)
OZONE • Variables explicatives : T9, T12, T15, Ne9, Ne12, Ne15, Vx9, Vx12, Vx15, maxO3v, vent, pluie
• Variable dépendante (cible) : maxO3
• URL : http://www.agrocampus-ouest.fr/math/livreR/ozone.txt

• Description : le jeu de données comprend 50 échantillons de chacune des trois espèces d'iris
IRIS • Variables explicatives : Sepallength, Sepalwidth, Petallength, Petalwidth
• Variable dépendante (cible) : Species
• URL : https://archive.ics.uci.edu/ml/machine-learning-databases/iris/

• Description : le jeu de données porte sur le concert de prostate

PROSTATE • Variables explicatives : age, acide, rayonx, taille, grade, Y, log.acid
• Variable dépendante (cible) : Y
• URL : http://www.agrocampus-ouest.fr/math/livreR/cancerprostate.txt

• Il est important de télécharger les jeux de données en local afin de les utiliser.

26
 M.MICHRAFY
MISE EN OUVRE DES TRANSFORMATEURS ET ESTIMATEURS

• Cette section présente des transformateurs avec des exemples utilisant

l’API Spark ML

• Les transformateurs présentés sont :

1. IndexToString
2. StringIndexer
3. VectorIndexer
4. OneHotEncoder
5. Normalizer
6. Tokenizer
7. Binarizer
8. VectorAssembler

27
 TRANSFORMER : INDEXER VERS
Objectif
 StringIndexer code une String en
un double ( plutôt c’est un entier
naturel)
 Ceci permet de gérer les
variables qualitatives en Spark
ML.
 StringIndexer permet de coder
une seule variable.
STRING M.MICHRAFY
Exemple
// importer de StringIndexer
import org.apache.spark.ml. feature.StringIndexer
// créer une dataFrame à partir d’une séquence
val sq = Seq((0, “aa"), (1, “ab"), (2, "cd"), (3, "ad"), (4, "aa"))
val dfin = spark.createDataFrame(sq). toDF("id", "category")
// Etablir le modèle (fit) et construire la colonne sortie (transform)
val indexer = new StringIndexer()
.setInputCol("category" .setOutputCol("categoryIndex")
val dfout = indexer.fit(dfin).transform(dfin)
dfout. printSchema
root
|-- id: integer (nullable = false)
|-- category: string (nullable = true)
|-- categoryIndex: double (nullable = true)
dfout.show(2)
| id|category|categoryIndex|
| 0| aa| 0.0|
| 1| ab| 2.0|
28
 TRANSFORMER : INDEXER VERS STRING M.MICHRAFY

Objectif Exemple
 IndexToString décode un double // importer StringIndexer et , IndexToString
en une String. import org.apache.spark.ml. feature.{StringIndexer, IndexToString}
val sq = Seq((0, “aa"), (1, “ab"), (2, "cd"), (3, "ad"), (4, "aa"))
 indexToString est l’application val dfin = spark.createDataFrame(sq). toDF("id", "category")
inverse de StringIndexer . // fixer la colonne de sortie
val indexer = new StringIndexer()
 Ceci est utile pour retrouver le .setInputCol("category") .setOutputCol("categoryIndex")
nom initiale d’une variable // Etablir le modèle (fit) et construire la colonne sortie (transform)
catégorielle val indexed = indexer.fit(dfin).transform(dfin)

val converter = new IndexToString()

.setInputCol("categoryIndex").setOutputCol("originalCategory")
val converted = converter.transform(indexed)
converted.select("Category", "originalCategory"). printSchema
root
|-- Category: string (nullable = true)
|-- originalCategory: string (nullable = true)
converted.select("Category", "originalCategory").show(2)
|Category|originalCategory|
| a| a|
| b| b|

29
 TRANSFORMER : INDENTIFICATION
CATÉGORIELLES
Objectif
 VectorIndexer permet d’identifier
des valeurs catégorielles selon un
seuil en utilisant la méthode fit.
 La méthode fit de VectorIndexer
renvoie un objet
« VectorIndexerModel »
 VectorIndexerModel permet de
mapper une variable en une
variable catégorielle en utilisant
transform.
ET CONVERSION VERS VARIABLES
M.MICHRAFY
Exemple
import org.apache.spark.ml. feature.VectorIndexer // importer VectorIndexer
val dt = spark.read.format(“libsvm”).load(“data.txt”) // charger les données
// fixer la colonne d’entrée et celui de la sortie
val indexer = new StringIndexer()
.setInputCol("features").setOutputCol("indexed").setMaxCategories(2)
val indexed = indexer.fit(dt) // Ajuster le modèle sur les données(fit)
// Ajouter la colonne « indexed » à la dataframe dt
val indexedDt = indexerModel.transform(dt)
// afficher les noms des colonnes de la dataframe indexedDt
val indexedData = indexerModel.columns
// res1 : Array[String] = Array(label, features, indexed)
// afficher le nombre de colonnes différentes (features, indexed)
indexedDt.filter(w => (w(1)!=w(2))).count
// res2 : Long = 47
// afficher le nombre des variables catégorielles identfiées
indexerModel.categoryMaps.size
// res3 : Int = 53
30
 TRANSFORMER : MAPPER DES LABELS VERS UN VECTEUR BINAIRE
Objectif
 OneHotEncoder code un vecteur
de labels (indexé) en un vecteur
binaire.
 L’idée est de coder une variable
catégorielle en une liste
variable binaires.
 La colonne des labels (indexés)
doit être de type numérique.
 Ce type de décodage est utile
lorsqu’ on a un algorithme qui
n’accepte que les variables
quantitatives. C’est le cas d’une
régression linéaire.
M.MICHRAFY
Exemple
// importer OneHotEncoder, StringIndexerval
import org.apache.spark.ml.feature.{OneHotEncoder, StringIndexerval}
val sq = Seq((0, "a"),(1, "b"),(2, "c"),(3, "a"),(4, "a"),(5, "c"))
val df = spark.createDataFrame(sq).toDF("id", "category") //creer la dataframe
// créer un indexer et ajuster le modèle sur les données df
de val indexer = new StringIndexer()
.setInputCol("category").setOutputCol("categoryIndex").fit(df)
val indexed = indexer.transform(dt) // générer la colonne categoryIndex
// créer un opérateur de codage (labels vers binaires)
val encoder = new OneHotEncoder()
.setInputCol("categoryIndex").setOutputCol("categoryVec")
// transformer les données (labels vers binaires)
val encoded = encoder.transform(indexed)
encoded.columns // afficher le nombre de colonnes de encoded
// res1 : Array[String] = Array(id, category, categoryIndex, categoryVec)
encoded.take(2)// afficher les 3 lignes de encoded
// res2 : Array([0,a,0.0,(2,[0],[1.0])], [1,b,2.0,(2,[],[])], [2,c,1.0,(2,[1],[1.0])])
31
 TRANSFORMER : NORMALISATION DES DONNÉES M.MICHRAFY

Objectif Exemple
 Normalizer vise à normaliser les
données en utilisant la norme Lp, p // importer Normalizer
est un paramètre d’entrée. import org.apache.spark.ml.feature.Normalizer

 Lorsque p prend la valeur 2 (valeur // charger les données : sample_libsvm_data.txt de la distribution Spark
par défaut), on retrouve la norme val dt = spark.read.format(“libsvm”)
euclidienne. .load(“SparkPath/data/mllib/sample_libsvm_data.txt”)

 La méthode setP(Double) de la // fixer la colonne d’entrée et celui de la sortie et la norme utilisée

classe Normalizer permet de fixer la val indexer = new Normalizer()
norme. .setInputCol("features") // fixer l’entrée
.setOutputCol("normFeatures") // fixer la sortie
.setP(2.0) // fixer la la nome L2

// Normaliser les données

val l2NormData = normalizer.transform(dt)

// afficher les données de la dataframe l2NormData

l2NormData.show()

32
 TRANSFORMER : SEGMENTATION
Objectif
 Tokenizer vise à segmenter une
phrase ou une ligne en une liste de
mots.
 Le Tokenizer utilise le séparateur
espace pour segmenter un texte.
DU TEXTE EN MOTS M.MICHRAFY
Exemple
// importer Tokenizer
import org.apache.spark.ml.feature.Tokenizer
// Créer la dataFrame sentenceDataFrame
val sentenceDataFrame = spark.createDataFrame(Seq(
(0, "La meilleure façon de predire l’avenir est de le creer"),
(1, "Vous ne trouverez jamais ce que vous ne cherchez pas"),
(2, "Si vous pouvez le rever, vous pouvez le faire.")
)).toDF("label", "phrase")
// fixer la colonne d’entrée et celui de la sortie
val tokenizer = new Tokenizer().setInputCol("phrase").setOutputCol("words")
// Segmenter chaque phrase en une liste de mots
val tokenized = tokenizer.transform(sentenceDataFrame)
// afficher les mots de chaque phrase et le label associé
tokenized.select("words", "label").take(3).foreach(println)
33
 TRANSFORMER : BINARISER
Objectif
 Binarizer permet de transformer un
vecteur numérique en un vecteur
binaire en se basant sur un seuil.
 La binarisation utilise la règle
suivante :
si la valeur > seuil alors 1 sinon 0
UN VECTEUR M.MICHRAFY
Exemple
// importer Binarizer
import org.apache.spark.ml.feature.Binarizer
// Créer la dataFrame sentenceDataFrame
val data = Array((0, 0.1), (1, 0.5), (2, 0.7), (3,0.8))
val dataFrame = spark.createDataFrame(data).toDF("label", "feature")
//Créer un op binarizer, fixer les colonnes d’entrée et de sortie et le seuil =0.5
val binarizer: Binarizer = new Binarizer()
.setInputCol("feature").setOutputCol("bin_feature").setThreshold(0.5)
// Binariser le vecteur feature et générer le résultat dans la colonne bin_feature
val binarizedDataFrame = binarizer.transform(dataFrame)
// afficher la dataframe générée
binarizedDataFrame.show()
|label|feature|bin_feature|
| 0| 0.1| 0.0|
| 1| 0.5| 0.0|
| 2| 0.7| 1.0|
| 3| 0.8| 1.0|
34
 TRANSFORMER : REGROUPER
Objectif
 VectorAssembler permet de
regrouper des colonnes en une
seule colonne.
 Les colonnes à regrouper doivent
faire partie des types suivants :
numérique, booléen ou vecteurs
(de type double).
 Ceci est utile puisque les
algorithmes de l’API Spark ML
nécessitent que les variables
explicatives soient de type
vecteur.
DES COLONNES M.MICHRAFY
Exemple
// importer VectorAssembler
import org.apache.spark.ml.feature.VectorAssembler
// Créer une dataframe avec 3 colonnes
val sq = Seq((0,0.0,3.0),(1,1.0,0.0),(2,0.0,4.0),(3,0.0,1.0),(4,1.0,0.0),(5,0.0,2.0))
val df = spark.createDataFrame(sq).toDF("id", "eligible", "couleur")
//Créer assembler pour regrouper les colonnes "eligible", "couleur"
val assembler = new VectorAssembler()
.setInputCols(Array("eligible", "couleur")).setOutputCol("features")
// Generer une la colonne features qui regroupe "eligible", "couleur"
val dfas = assembler.transform(df)
// afficher le contenu de la dataframe dfas
dfas.show()
| id|eligible|couleur| features|
| 0| 0.0| 3.0|[0.0,3.0]|
| 1| 1.0| 0.0|[1.0,0.0]|
| 2| 0.0| 4.0|[0.0,4.0]|
| 3| 0.0| 1.0|[0.0,1.0]|
| 4| 1.0| 0.0|[1.0,0.0]|
| 5| 0.0| 2.0|[0.0,2.0]|
35
 M.MICHRAFY
MISE EN OUVRE DES PIPELINES SOUS SPARK ML

• Cette section porte sur la mise en œuvre des pipelines sous Spark ML.

• Trois exemples sont abordés et portent sur :

1. Pipeline dédié à la régression linéaire
2. Pipeline dédié aux arbres de décision
3. Pipeline dédié à la régression logistique

36
 PIPELINE : RÉGRESSION LINÉAIRE, DONNÉES
Objectif
 Proposer un pipeline qui vise à
préparer des données et à ajuster
un modèle de régression linéaire
 Le pipeline est composé de :
1. Estimator : venIndexer
2. Estimator : pluieIndexer
3. Transformer : assembler
4. Transformer : featureIndexer
5. Estimator : lr
OZONE 1/2 M.MICHRAFY
Exemple 1
import org.apache.spark.ml.{Pipeline, PipelineModel}
import org.apache.spark.ml.feature.{VectorAssembler,StringIndexer,VectorIndexer}
import org.apache.spark.ml.regression.LinearRegression
// Charger les données et renommer les colonnes
val ozone = spark.read.option("header", true).option("inferSchema","true")
.option("delimiter"," ").csv("D:/MMY/PublicationsWeb/SparkML/ozone.txt")
.toDF("id", "maxO3", "T9", "T12", "T15", "Ne9", "Ne12", "Ne15", "Vx9", "Vx12", "Vx15",
"maxO3v", "vent", "pluie")
// Créer l’indexer pour transformer « vent » en variable catégorielle
val ventIndexer = new StringIndexer().setInputCol("vent").setOutputCol("labelVent")
// Créer l’indexer pour transformer « pluie » en variable catégorielle
val pluieIndexer = new StringIndexer().setInputCol("pluie").setOutputCol("labelPluie")
// Regrouper les prédicteurs en une seul colonne
val assembler = new VectorAssembler()
.setInputCols(Array("T9", "T12", "T15", "Ne9", "Ne12", "Ne15", "Vx9", "Vx12", "Vx15",
"maxO3v", "labelVent", "labelPluie")).setOutputCol("features")
// Identifier et indexer les variables categorielles avec un seuil = 4
val featureIndexer = new VectorIndexer()
.setInputCol("features").setOutputCol("indexedFeatures").setMaxCategories(4)
37
 PIPELINE : RÉGRESSION
Importer les packages
Charger les données OZONE
Créer l’indexer pour la variable
vent.
Créer l’indexer pour la variable
pluie
Regrouper les variables
Regrouper les variables
Identifier les variables
catégorielles
Créer le modèle de régression
Créer le pipeline
Ajuster le modèle sur les
données et faire la prédiction
LINÉAIRE, DONNÉES OZONE 2/2 M.MICHRAFY
Suite 2
// initier le modèle de régression linéaire
val lr = new LinearRegression()
.setMaxIter(20)
.setRegParam(0.5)
.setLabelCol("maxO3")
.setFeaturesCol("indexedFeatures")
.setPredictionCol("maxO3PredictCol")
// créer le pipeline : ventIndexer, pluieIndexer, assembler, featureIndexer, lr
val pipeline = new Pipeline()
.setStages(Array(ventIndexer, pluieIndexer, assembler, featureIndexer, lr))
// ajuster le modèle sur les données ozone
val model = pipeline.fit(ozone)
// évaluer le modèle sur les données d’apprentissage
val predictions = model.transform(ozone)
// afficher les resultats de prediction
predictions.select("id", "maxO3", "maxO3PredictCol" )
38
 PIPELINE : ARBRE DE DÉCISION,
Objectif
 Proposer un pipeline qui vise à préparer
des données et à ajuster un modèle
basé sur la méthode d’arbre de
décision.
 Le pipeline est composé de 2
transformateurs et d’un estimateur.
Importer les packages
Charger les données
Regrouper des colonnes
Indexer des catégories
Initier le modèle d’arbre de
décision
Construire et lancer le
pipeline
Evaluer le modèle les
données d’apprentissage
DONNÉES IRIS M.MICHRAFY
Exemple
import org.apache.spark.ml.{Pipeline, PipelineModel}
import org.apache.spark.ml.classification.{DecisionTreeClassifier,DecisionTreeClassificationModel}
import org.apache.spark.ml.feature.{StringIndexer, VectorAssembler}
// charger les données iris et renommer les colonnes
val iris = spark.read.option("header", true).option("inferSchema",
"true").csv("Path/iris.csv").toDF("id", "SepalL","SepalW","PetalL","PetalW", "Species")
val assembler = new VectorAssembler() //Créer assembler pour regrouper les colonnes
.setInputCols(Array("SepalL","SepalW","PetalL","PetalW")).setOutputCol("features")
val indexer = new // transformer la variable Species en un indexer
StringIndexer().setInputCol("Species").setOutputCol("SpeciesIndex")
val dt = new // Créer le modèle d’apprentissage DT
DecisionTreeClassifier().setLabelCol("SpeciesIndex").
.setPredictionCol("SpeciesPredictCol").setFeaturesCol("features")
// créer un pipeline : assembler, indexer, dt
val pipeline = new Pipeline().setStages(Array(assembler, indexer, dt))
// ajuster le modèle
val model = pipeline.fit(iris)
// evaluer le modèle sur les données d’apprentissage
val predictions = model.transform(iris)
predictions.show // ajuster les résultats
39
 PIPELINE : REGRESSION LOGISTIQUE, DONNÉES
Objectif
 Proposer un pipeline qui vise à préparer
des données et à ajuster un modèle
régression logistique
 Le pipeline est composé de
transformateurs et d’un estimateur.
Importer les packages
Charger les données
Regrouper des colonnes
Indexer des catégories
Initier le modèle régression logistique
Construire et lancer le pipeline
Evaluer le modèle sur les
données d’apprentissage
Afficher les résultats
PROSTATE M.MICHRAFY
Exemple
import org.apache.spark.ml.{Pipeline, PipelineModel}
import org.apache.spark.ml.feature.{VectorAssembler,StringIndexer,VectorIndexer}
import org.apache.spark.ml.classification.LogisticRegression
2 val prostate = spark.read.option("header", true) // charger les données .
.option("inferSchema", "true").option("delimiter",";").csv("cancerprostate.txt")
.toDF("age","acide","rayonx","taille", "grade", "Y", "logAcid")
val assembler = new VectorAssembler() // créer l’assember
.setInputCols(Array("age","acide","rayonx","taille", "grade",
"logAcid")).setOutputCol("features")
val indexer = new StringIndexer(). // transformer la variable Y en un indexer
setInputCol("Y").setOutputCol("label")
val lr = new LogisticRegression() // Initier le modèle de régression logistique
.setLabelCol("label").setFeaturesCol("features").setPredictionCol("labelPredictCol")
.setMaxIter(20).setRegParam(0.3).setElasticNetParam(0.8)
// créer un pipeline : assembler, indexer, lr
val pipeline = new Pipeline().setStages(Array(assembler, indexer, lr))
val model = pipeline.fit(prostate) // ajuster le modèle sur les données
val predictions = model.transform(prostate) // évaluer le modèle sur Prostate
predictions.show // afficher les résultats 40
 M.MICHRAFY
MISE EN OUVRE DU PROCESSUS D’ÉVALUATION

• Cette section vise à présenter des techniques relatives à l’évaluation d’une

méthode d’apprentissage

• Trois exemples sont abordés :

1. Evaluation d’une régression linéaire
2. Evaluation dune méthode d’arbre de décision
3. Evaluation de la régression logistique

41
 EVALUATION DE LA RÉGRESSION
Objectif
 Mise en œuvre de l’évaluation
d’une méthode de régression
linéaire pour les données OZONE.
 L’idée est de montrer la manière
d’utiliser la classe finale
RegressionEvaluator.
 Pour ce faire, nous avons deux
étapes.
 L’étape 1 consiste à positionner les
paramètres : label, prédicteur,
mesure.
 L’étape 2 évalue la méthode
ajustée et retourne un score.
 L’exemple proposé reprend les
étapes des slides 36-37.
LINÉAIRE, DONNÉES OZONE 1/2 M.MICHRAFY
Exemple
import org.apache.spark.ml.{Pipeline, PipelineModel}
import org.apache.spark.ml.feature.{VectorAssembler,StringIndexer,VectorIndexer}
import org.apache.spark.ml.regression.LinearRegression
// Charger les données et renommer les colonnes
val ozone = spark.read.option("header", true).option("inferSchema","true")
.option("delimiter"," ")..csv("D:/MMY/PublicationsWeb/SparkML/ozone.txt")
.toDF("id", "maxO3", "T9", "T12", "T15", "Ne9", "Ne12", "Ne15", "Vx9", "Vx12", "Vx15",
"maxO3v", "vent", "pluie")
// Créer l’indexer pour transformer « vent » en variable catégorielle
val ventIndexer = new StringIndexer().setInputCol("vent").setOutputCol("labelVent")
// Créer l’indexer pour transformer « pluie » en variable catégorielle
val pluieIndexer = new StringIndexer().setInputCol("pluie").setOutputCol("labelPluie")
// Regrouper les prédicteurs en une seule colonne
val assembler = new VectorAssembler()
.setInputCols(Array("T9", "T12", "T15", "Ne9", "Ne12", "Ne15", "Vx9", "Vx12", "Vx15",
"maxO3v", "labelVent", "labelPluie")).setOutputCol("features")
// Identifier et indexer les variables categorielles avec un seuil = 4
val featureIndexer = new VectorIndexer()
.setInputCol("features").setOutputCol("indexedFeatures").setMaxCategories(4)
42
 EVALUATION DE LA RÉGRESSION LINÉAIRE, DONNÉES OZONE 2/2 M.MICHRAFY

Exemple
// initier le modèle de régression linéaire
val lr = new LinearRegression().setMaxIter(20).setRegParam(0.5)
Charger les données .setLabelCol("maxO3").setFeaturesCol("indexedFeatures")
.setPredictionCol("maxO3PredictCol")
// créer le pipeline : ventIndexer, pluieIndexer, assembler, featureIndexer, lr
val pipeline = new Pipeline()

Appliquer le pipeline
.setStages(Array(ventIndexer, pluieIndexer, assembler, featureIndexer, lr))
Préparer les données // ajuster le modèle sur les données ozone
val model = pipeline.fit(ozone)
Initier et ajuster le modèle // évaluer le modèle sur les données d’apprentissage
val predictions = model.transform(ozone)

Effectuer la prédiction // import de la classe pour l’evaluation

import org.apache.spark.ml.evaluation.RegressionEvaluator
val evalution = new RegressionEvaluator() // créer l’instance d’évaluation
Evaluation

.setLabelCol("maxO3") //Fixer la colonne du label

Evaluer le modèle

Initier l’évaluateur et .setPredictionCol("maxO3PredictCol") // Fixer la colonne de la prédiction

positionner les params .setMetricName("rmse") // Fixer la mesure d’évaluation
val RMSE = evalution.evaluate(predictions)
Evaluer la méthode print(s"Root Mean Squared Error = ${RMSE}") // afficher la valeur de RMSE
Root Mean Squared Error = 13.60374600320492

43
 EVALUATION DE L’ARBRE DE DÉCISION, DONNÉES
Objectif
 Mise en œuvre de l’évaluation d’une
méthode d’arbre de décision, pour les
données IRIS.
 La classe d’évaluation utilisée est
MulticlassClassificationEvaluator
 La mesure utilisée est Accuracy
Charger les données
Préparer les données
Ajuster le model ML
Initier l’évaluateur et
positionner les params
Evaluer la méthode via la
mesure Accarucy
IRIS M.MICHRAFY
Exemple
import org.apache.spark.ml.{Pipeline, PipelineModel}
import org.apache.spark.ml.classification.{DecisionTreeClassifier,DecisionTreeClassificationModel}
import org.apache.spark.ml.feature.{StringIndexer, VectorAssembler}
/*****************************************************************
Reprendre les étapes du slide 38 :
depuis le chargement des données,
jusqu'au la génération de la dataframe predictions.
******************************************************************/
// import de la classe pour l’évaluation
import org.apache.spark.ml.evaluation. MulticlassClassificationEvaluator
// créer l’instance d’évaluation
val evalution = new MulticlassClassificationEvaluator()
.setLabelCol("SpeciesIndex") //Fixer la colonne du label
.setPredictionCol("SpeciesPredictCol") // Fixer la colonne de la prédiction
.setMetricName("accuracy") // Fixer la mesure d’évaluation
// calculer la valeur de Accuracy
val ACCURACY= evalution.evaluate(predictions)
print(s“ Accuracy= ${ACCURACY}") // afficher la valeur de ACCURACY
44
 PIPELINE : REGRESSION LOGISTIQUE, DONNÉES
Objectif
 Mise en œuvre de l’évaluation d’une
méthode de régression logistique, pour
les données PROSTATE.
 La classe d’évaluation utilisée est
BinaryClassificationEvaluator
 La mesure utilisée est areaUnderROC
Charger les données
Préparer les données
Ajuster le model ML
Initier l’évaluateur et
positionner les params
Evaluer la méthode avec la
mesure ROC
PROSTATE M.MICHRAFY
Exemple
import org.apache.spark.ml.{Pipeline, PipelineModel}
import org.apache.spark.ml.feature.{VectorAssembler,StringIndexer,VectorIndexer}
import org.apache.spark.ml.classification.LogisticRegression
/*****************************************************************
Reprendre les étapes du slide 39 :
depuis le chargement des données,
jusqu'au la génération de la dataframe predictions.
******************************************************************/
// import de la classe pour l’évaluation
import org.apache.spark.ml.evaluation. BinaryClassificationEvaluator
// créer l’instance d’évaluation
val evalution = new BinaryClassificationEvaluator()
.setLabelCol(" label ") //Fixer la colonne du label
.setRawxPredictionCol("labelPredictCol") // Fixer la colonne de la prédiction
.setMetricName("areaUnderROC") // Fixer la mesure d’évaluation
// calculer la valeur de areaUnderROC
val areaUnderROC = evalution.evaluate(predictions)
print(s“ AreaUnderROC= ${areaUnderROC}") // afficher la valeur de areaUnderROC
45
 M.MICHRAFY
MISE EN OUVRE DE LA VALIDATION CROISÉE

• Cette section porte sur la mise en œuvre de la validation croisée d’une méthode
d’apprentissage sous Spark ML.

• L’exemple abordé porte sur :

1. les données Prostate
2. la méthode de régression logistique
3. et validation croisée

46
 VALIDATION CROISÉE, GRADIENT BOOSTING,
Objectif
 Mise en œuvre de la validation croisée
d’une méthode de régression logistique ,
pour les données PROSTATE.
A retenir
 La validation croisée et la gestion des
paramètres de tuning nécessitent
l’import de :
 ParamGridBuilder
 CrossValidator
 Lors de la création d’une instance de
type CrosseValdation, il est important
de positionner :
 le pipleline ou l’algorithme ML
 l’instance d’évaluation
 les paramètres de tuning
DONNÉES PROSTATE 1/3 M.MICHRAFY
Exemple
1
import org.apache.spark.ml.{Pipeline, PipelineModel}
import org.apache.spark.ml.feature.{VectorAssembler,StringIndexer,VectorIndexer}
import org.apache.spark.ml.evaluation.BinaryClassificationEvaluator
import org.apache.spark.ml.tuning.{CrossValidator, ParamGridBuilder}
import org.apache.spark.ml.classification.LogisticRegression
// Charger les données et renommer les colonnes
val prostate = spark.read
.option("header", true) // fichier avec un en-tête
.option("inferSchema", "true") // faire l’inteférence sur le type de données
.option("delimiter",";") // préciser le séparateur
.csv("D:/MMY/PublicationsWeb/SparkML/cancerprostate.txt")
.toDF("age","acide","rayonx","taille", "grade","Y", "logAcid") //renommer les cols.
//Créer l’assembler pour regrouper les colonnes
val assembler = new VectorAssembler()
.setInputCols(Array("age","acide","rayonx","taille", "grade", "logAcid"))
.setOutputCol("features")
// Transformer la variable Y en un indexer
val indexer = new StringIndexer()
.setInputCol("Y")
.setOutputCol("label")
47
VALIDATION CROISÉE, FORÊT DE DÉCISION, DONNÉES PROSTATE 2/3 M.MICHRAFY

Exemple
2
val lr = new LogisticRegression() // Créer le modèle d’apprentissage lr
.setLabelCol("label") // Positionner la variable dépendante
.setFeaturesCol("features") // Positionner le vecteur des variables explicatives
.setPredictionCol("labelPredictCol") // Fixer le nom de la colonne prédite

// Créer l’instance d’évaluation

val evalution = new BinaryClassificationEvaluator() // évaluation binaire
.setLabelCol("label") // Positionner la variable dépendante
.setRawPredictionCol("labelPredictCol") // Positionner le nom de la colonne prédite
.setMetricName("areaUnderROC") // Positionner la mesure d’évaluation

// Positionner les paramètres de tuning pour le modèle lr

val paramGrid = new ParamGridBuilder()
.addGrid(lr.maxIter, Array(20, 30, 50)) // nombre d’itération
addGrid(lr.regParam, Array(0.2, 0.1, 0.01)) // le coef de regularisation
.addGrid(lr. elasticNetParam, Array(0.4, 0.6, 0.8)) // le coef elasticNetParam
.addGrid(lr. threshold, Array(0.4, 0.5, 0.6)) // le seuil
.build()

// créer un pipeline : assembler, indexer, lr

val pipeline = new Pipeline()
.setStages(Array(assembler, indexer, lr))
48
 VALIDATION CROISÉE,
Importer les packages :
Transformateurs, estimateurs,
Pipeline, évaluation, validation croisé
Charger les données (prostate)
Créer les transformateurs et les
estimateurs
Créer le pipeline
Créer l’instance d’évaluation
Créer l’instance validation croisée
Lancer la validation croisée et
effectuer la prédiction
GRADIENT BOOSTING, DONNÉES PROSTATE 3/3 M.MICHRAFY
Exemple
3
// Instancier la validation croisée
val cv = new CrossValidator()
.setEstimator(pipeline) // positionner le pipeline
.setEvaluator(evalution) // positionner l’instance d’évaluation
.setEstimatorParamMaps(paramGrid) // Positionner les params de tuning
.setNumFolds(3) // Positioner le nombre de fold
.setSeed(27) // Positionner seed
// Lancer le validation croisée et adjuster le modèle
val cvModel = cv.fit(prostate)
// collecter les moyennes pour chaque params de la validation croisée
val avg = cvModel.avgMetrics
println(s"avgMetrics = " + avg.mkString(", "))
// pointer la meilleur modele identifié durant la validation croisée
Val bestModel = cvModel.bestModel
// exécuter la prédiction avec bestModel sur les données d’apprentissage
val prediction = cvModel.transform(prostate)
prediction.show(3)
49
 DR MUSTAPHA MICHRAFY

CONTACT : DATASCIENCE.KM@GMAIL.COM

Un merci à Dr Bernard Kouakou et Dr Oussama Lachiri pour leurs lectures et remarques pertinentes.