apache spark ml : principes, concepts et mise en œuvre
TRANSCRIPT
APACHE SPARK MLIB : PRINCIPES ET CONCEPTS POUR LA MISE
EN ŒUVRE DES MÉTHODES D’APPRENTISSAGE
DR MUSTAPHA MICHRAFY
CONTACT : [email protected]
PLAN
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 composants7. API Pipeline en Spark MLIB
8. ‘Transformers’ et ‘Estimators’ en Spark MLIB
9. Transformer : étapes
10. Gestion des paramètres en Spark MLIB11. 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ée15. Illustration et mise en œuvre sous Spark ML
2
M.MICHRAFY
CONTEXTE
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
M.MICHRAFY
OBJECTIF ET PRÉREQUIS
• Connaissance du langage Scala
• Connaissance de Spark et Spark SQL
• Connaissance des méthodes
d’apprentissage
Cette étude vise à présenter les étapes d’un
workflow pour la mise en place des
méthodes d’apprentissage basées sur l’API
Apache Spark ML.
PrérequisObjectif
4
M.MICHRAFY
SPARK ML : MOTIVATIONS ?
• Spark ML est une brique logiciel incontournable de
la plate forme Apache Spark.
• L’API Spark ML est dédiée à la mise en place des
méthodes d’apprentissage.
• Spark ML offre des services couvrant la
préparation des données, l’enrichissement, la
mise au point des méthodes d’apprentissage, et le
déploiement.
• Préparer, enrichir, transformer des données
• L’API de Spark ML propose plusieurs transformateurs
• Algorithmes pour le développement et la mise au
point des méthodes de :
o Classification
o Régression
o Clustering
o Recommandation
SPARK ML ? Fonctionnalités
5
M.MICHRAFY
• 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.
CONCEPTS POUR LA MISE EN PLACE DES ALGORITHMES DE SPARK ML
6
Concepts
Spark ML
Ce sont des algorithmes
permettant de transformer une
dataFrame en une autre
Un pipeline est constitué de plusieurs
Transformers et Estimators pour la
mise en place d’un workflow ML.
Les Transformers et Estimators
partagent la même API pour
spécifier les paramètres.
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
DataFrame
Parameters
Pipeline
Transformers
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.
Estimators
Mesures pour évaluer la
performance d’une méthode
d’apprentissage.
EvaluatorsTechnique pour mettre au
point une méthode
d’apprentissage
Cross Validation
DATAFRAME : MOTIVATIONS
7
• Les méthodes d’apprentissage
trouvent des applications dans
divers domaines, et nécessitant
divers types de données.
Variété des données
• Alors quelle structure
de données utilisée ?
• Distribuée, résiliente, orientée
colonne, optimisée
• Supportant divers types de
données, inclus les vecteurs
DataFrame
DataFrame est constituée de
n lignes (les individus)
m colonnes (les variables)
une colonne est typée (vecteur)
Popularisée par R,
repris par python(Pandas)
enfin, étendue par Saprk SQL
PIPELINE ET SES COMPOSANTS
8
PIPELINE
Transformer Estimator
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.
API PIPELINE EN SPARK MLIB
9
• Une méthode d’apprentissage
fait appel à des phases de
traitement, et d’apprentissage.
• Un Pipeline, en Spark MLIB, est
une séquence d’éléments de
type pipelineStage.
• Chaque PipelineStage estconstitué d’un Transformer ou
d’un Estimator.
• Par conséquent, l’ordre des
étapes (PiplineStage) est
important
Pipeline & PipelineStage
• Pour une étape de
transformation, la méthode
transform() est appelée sur uneDataframe et retourne une
DataFrame.
Etape de Transformation • Pour une étape d’estimation, la
méthode fit() d’un Estimator estappelée sur une dataframe pour
produire un Transformer
Etape d’Estimation
DataFrame
DataFrame
DataFrame
Transformer
Pipeline
PipelineStage
TRANSFORMER ET ESTIMATOR EN SPARK MLIB
10
• 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.
Transformer
• Un estimateur permet d’évaluer
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.
Estimator
• Les implémentations de 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…
….
Package
PipelineStage
Estimator Transformer
ParamsDataFrame
DataFrame
DataFrame
Transformer
Transfo
rmer
Estimato
r
Hiéra
rchie :
Estimato
r&
Transfo
rmer
ETAPES POUR LE TRANSFORMATEUR & ESTIMATEUR
11
Créer l’estimateur
Positionner les paramètres d’entrée
fit : ajuster le modèle selon les données
transform : générer la nouvelle DataFrame
Créer l’opérateur de transformation
Positionner les paramètres d’entrée
transform : générer la nouvelle DataFrame
EstimateurTransformateur
PARAMETRES
12
• Les transformateurs, les
estimateurs, les évaluateurs
nécessitent des paramètres.
• Spark ML propose un package
dédié à la gestion des
paramètres, partagé par les
estimateurs et les
transformateurs.
Intérêt
• Le package est :
org.apache.spark.ml.param
• La classe de base est Param.
• Des spécialisations de Param,sont proposées, portant sur des
primitifs (Int, Long, Float,
Boolean,Double, String, IntArray,
…)
• Les classes Transformer et
Estimator étendent la classe
Params.
Package Param
Param
BooleanParam
DoubleParam
FloatParam
IntArrayParamIntParam
DoubleArrayParam
StringArrayParam
LongParam
Serializable
ParamPair
ParamMap Params
Estimator
Transformer
QUELQUES TRANSFORMERS ET ESTIMATORS
13
StringIndexer : coder des catégories
IndexToString : décoder des index
VectorIndexer : identifier des variables catégorielles selon un seuil de fréquence
QuantileDiscretizer : transformer une variable quantitative en une variable qualitative en utilisant le
quantile
StandardScaler : normaliser un vecteur en utilisant la variance
Etc.
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.
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é.
Etc.
Transformers Estimators
EVALUER UNE MÉTHODE D’APPRENTISSAGE
14
• Pour évaluer la performance d’une
méthode d’apprentissage, nous
utilisons des mesures dédiées.
• Pour un individu donné, une
mesure d’évaluation exploite la
valeur ajustée et la valeur de
référence.
• Nous avons des mesures pour :
1. les méthodes de régression
2. les méthodes de classification.
Mesure d’évaluation ?
• Le choix de la méthode
d’évaluation dépend du problème
traité et de la connaissance métier
associée.
• Quelles sont les mesures d’évaluation
pour les méthodes de classification?
• Quelles sont les mesures d’évaluation
pour les méthodes de régression?
EVALUER UNE MÉTHODE D’APPRENTISSAGE : CLASSIFICATION
15
• Sensibilité : le taux de caspositifs correctement identifiés
• Spécificité : le taux de casnégatifs correctement identifiés
• Accuracy : le taux de caspositifs ou négatifs
correctement identifiés.
• F-mesure : le taux qui combinela sensibilité et la spécificité
Mesures d’évaluation
• La courbe ROC (receiver
operating characteristic) estutilisée pour évaluer la
performance d’un classifier
binaire.
• La courbe de ROC est la
courbe qui donne la sensibilité
en fonction de la spécificité.
La courbe de ROC
• Elle vise à mesurer la qualité
d'une méthode de
classification.
• Elle indique si la méthode
parvient à classifier
correctement les individus.
Matrice de confusion
• Les mesures d’évaluation utilisent les notions :1. VP (vrais positifs) : nombre de positifs classés positifs
2. FP (faux positifs) : nombre de négatifs classés positifs
3. FN (faux négatifs) : nombre de positifs classés négatifs
4. VN(vrais négatifs) : nombre de négatifs classés
négatifs
• Formules :1. Sensibilité = VP/(VP+FN)
2. Spécificité = VN/(VN + FN)
3. Accuracy = (VP + VN)/(VP + VN + FP + FN)
4. F2 = 2.(Sensibilité+Spécificité)/(Sensibilité + Spécificité)
Positif Négatif
Positif TP FN
Négatif FP TN
Prédite
Rée
lle
Matrice de confusion
EVALUER UNE MÉTHODE D’APPRENTISSAGE : RÉGRESSION
16
• MSE : Erreur quadratique moyenne(mean Squared Error)
• RMSE : c’est la racine carrée de MSE(root Mean Squared Error)
• R : Coefficient de détermination
• MAE : Erreur absolue moyenne(mean Absolute Error)
• MAPE : Erreur absolue moyenne enpourcentage (Mean Absolute
Percentage Error)
Principales mesures
• Elle vise à mesurer la qualité d'une
méthode de régression en
calculant une erreur globale
• Une erreur est proche de zéro
indique la pertinence du modèle
Intérêt des mesures
𝑀𝑆𝐸 =
𝑙=1
𝑛
𝑦𝑙 − 𝑦𝒍2
RMSE = 𝑀𝑆𝐸
𝑀𝐴𝐸 =
𝑙=1
𝑛
𝑦𝑙 − 𝑦𝑙
𝑅2 = 1 − 𝑀𝑆𝐸 𝑙=1𝑛 (𝑦𝑙 − 𝑦)2
𝑀𝐴𝑃𝐸 = 𝑙=1𝑛 (𝑦𝑙 − 𝑦𝑙)
𝑦𝑙𝑛
. 100
y𝑙 𝑒𝑠𝑡 𝑙𝑎 𝑣𝑎𝑙𝑒𝑢𝑟 𝑟é𝑒𝑙, ( 𝑦 est la moyenne de 𝑦 ) 𝑦𝑙 𝑒𝑠𝑡 𝑙𝑎 𝑣𝑎𝑙𝑒𝑢𝑟 𝑎𝑗𝑢𝑠𝑡é𝑒,𝑛 𝑑𝑒𝑠𝑖𝑔𝑛𝑒 𝑙𝑒 𝑛𝑜𝑚𝑏𝑟𝑒 𝑑′𝑜𝑏𝑠𝑒𝑟𝑣𝑎𝑡𝑖𝑜𝑛𝑠
API POUR L’ÉVALUATION D’UN ALGORITHME D’APPRENTISSAGE 1/2
17
Evaluator
BinaryClassificationEvaluator
MulticlassClassificationEvaluator
RegressionEvaluator
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.
Pour la régression
Pour la classification binaire
Pour la classification multi-classes
API POUR L’ÉVALUATION D’UN ALGORITHME D’APPRENTISSAGE 2/2
18
Evaluator
BinaryClassificationEvaluator
MulticlassClassificationEvaluatorRegressionEvaluator
RegressionEvaluator : une classe dédiée aux algorithmes de régression.
Différentes mesures sont proposées:
1. RMSE (par défaut)
2. MSE
3. R2
4. MAE
BinaryClassificationEvaluator : une classe dédiée à l’évaluation des algorithmes de
classification binaire.
Elle propose deux mesures :
1. areaUnderROC (par défaut)
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 setlabelCol2. Le nom de la colonne prédite avec la méthode
setPredictionCol
3. La mesure d’évaluation avec la méthode setMetricName
Package : org.apache.spark.ml.evaluation
VALIDATION CROISÉE 1/2
19
• La validation croisée est une
méthode d’estimation de fiabilité
d’un modèle, basée sur une
technique d’échantillonnage.
• Elle permet :
• d’optimiser les paramètres du
modèle,
• d’éviter le sur-apprentissage
Intérêt
Alors quelles sont les méthodes
portant sur la validation croisée ?
• Diviser les données en k échantillons(i..k)
• 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
• Diviser l'échantillon de taille n en deux sous
é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 k-fold Cross-validation
VALIDATION CROISÉE 2/2
20
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
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.
Tests et validation k-fold Cross-validation
123456
DADT
A
B Ajuster le modèle sur DA et
valider le modèle sur DT
C Estimer l’erreur eAppliquer A et B pour chaque couple d’échantillon
Calculer les erreurs e1 ….e6
Calculer l’erreur de prédiction
e1e2
e6
DA : données d’apprentissageDT : données de test
.
.
.
ML TUNING : SÉLECTION DU MODÈLE ET CHOIX DES PARAMÈTRES
21
• Spark ML propose des outils (MLtuning) pour la sélection et
l’optimisation d’un modèle.
• Spark ML tuning s’appuie sur :
• La validation croisée
• L’ étude du comportement des
paramètres
Tuning sous Spark ML
Tuning ML
Pipeline
Estimator
s’applique sur
org.apache.spark.ml.tuning
associé au
• La package portant sur le tuning ML
est org.apache.spark.ml.tuning• Spark ML Tuning propose deux
classes étendant Estimator :
1. CrossValidator : pour lavalidation croisée
2. TrainValidationSplit : pourl’optimisation des paramètres
d’une méthode ML.
• Les deux classes nécessitent :
• Estimator
• Evaluator
• Parameters
Tuning et classes associées
CrossValidation TrainValidationSplit
Estimator
Evaluator
est un
nécessite
Paramètres
M.MICHRAFY
ML TUNING : CROSSVALIDATOR
22
• CrossValidator est la classedédiée à la validation croisée.
• C’est l’implémentation de la
méthode k-fold.• Elle ne dispose pas de
constructeur
CrossValidator
Deux étapes : initialisation et
réalisation
• Etape initialisation : fixer les
paramètres d’entrée
• Etape d’ajustement :
effectuer la validation croisée
via la méthode fit
Mise en place ?
Méthode k-fold
modélise
Etape d’Initialisation
• 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
Etape d’ajustement
• fit : cette méthode applique la validation croisée et génère les modèles associés.
• Elle retourne un objet de type
CrossValidatorModel.
Alors, quelle sont les méthodes de la classe
CrossValidationModel ?
Classe
CrossValidator
ML TUNING : CROSSVALIDATORMODEL
23
• CrossValidatorModel est laclasse 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
CrossValidatorModel
• avgMetrics : permet d’accéder à la mesure moyenne pour chaque entréede la map des paramètres.
• bestModel : retourne le meilleur modèle identifié pendant la validationcroisé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éesde test. Cette méthode applique le meilleur modèle identifié
Fonctionnalités
M.MICHRAFY
API SPARK ML : VUE PACKAGES
24
Package pour l’ évaluation
des méthodes
d’apprentissage
Package pour la mise au point
des méthodes ML
Package pour la préparation
et le formatage des données.
Package dédié aux méthodes
de classification
Package dédié aux méthodes
de régression
Package dédié aux méthodes
de clustering
Package dédié aux méthodes
de recommandation
Package dédié la gestion des
paramètres.
MISE EN ŒUVRE SOUS APACHE SPARK ML
25
• 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
LES DONNÉES UTILISÉES
26
• Description : le jeu de données porte sur la pollution de l’air (112 individus et 13 variables)
• 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
OZONE
• Description : le jeu de données comprend 50 échantillons de chacune des trois espèces d'iris
• Variables explicatives : Sepallength, Sepalwidth, Petallength, Petalwidth
• Variable dépendante (cible) : Species
• URL : https://archive.ics.uci.edu/ml/machine-learning-databases/iris/
IRIS
• Description : le jeu de données porte sur le concert de 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
PROSTATE
• Il est important de télécharger les jeux de données en local afin de les utiliser.
MISE EN OUVRE DES TRANSFORMATEURS ET ESTIMATEURS
27
M.MICHRAFY
• 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
TRANSFORMER : INDEXER VERS STRING
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.
Objectif
// 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. printSchemaroot|-- 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|
Exemple
28
M.MICHRAFY
TRANSFORMER : INDEXER VERS STRING
IndexToString décode un double
en une String.
indexToString est l’application
inverse de StringIndexer .
Ceci est utile pour retrouver le
nom initiale d’une variable
catégorielle
Objectif
// importer StringIndexer et , IndexToString
import org.apache.spark.ml. feature.{StringIndexer, IndexToString}
val sq = Seq((0, “aa"), (1, “ab"), (2, "cd"), (3, "ad"), (4, "aa"))
val dfin = spark.createDataFrame(sq). toDF("id", "category")
// fixer la colonne de sortie
val indexer = new StringIndexer()
.setInputCol("category") .setOutputCol("categoryIndex")
// Etablir le modèle (fit) et construire la colonne sortie (transform)
val indexed = indexer.fit(dfin).transform(dfin)
val converter = new IndexToString()
.setInputCol("categoryIndex").setOutputCol("originalCategory")
val converted = converter.transform(indexed)
converted.select("Category", "originalCategory"). printSchemaroot|-- Category: string (nullable = true)|-- originalCategory: string (nullable = true)
converted.select("Category", "originalCategory").show(2)|Category|originalCategory|| a| a|| b| b|
Exemple
29
M.MICHRAFY
TRANSFORMER : INDENTIFICATION ET CONVERSION VERS VARIABLES
CATÉGORIELLES
VectorIndexer permet d’identifierdes 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.
Objectif
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
Exemple
30
M.MICHRAFY
TRANSFORMER : MAPPER DES LABELS VERS UN VECTEUR BINAIRE
OneHotEncoder code un vecteurde labels (indexé) en un vecteur
binaire.
L’idée est de coder une variable
catégorielle en une liste de
variable binaires.
La colonne des labels (indexés)
doit être de type numérique.
Ce type de décodage est utilelorsqu’ on a un algorithme qui
n’accepte que les variables
quantitatives. C’est le cas d’une
régression linéaire.
Objectif
// 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
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])])
Exemple
31
M.MICHRAFY
TRANSFORMER : NORMALISATION DES DONNÉES
Normalizer vise à normaliser lesdonnées en utilisant la norme Lp, p
est un paramètre d’entrée.
Lorsque p prend la valeur 2 (valeurpar défaut), on retrouve la norme
euclidienne.
La méthode setP(Double) de la
classe Normalizer permet de fixer la
norme.
Objectif
// importer Normalizer
import org.apache.spark.ml.feature.Normalizer
// charger les données : sample_libsvm_data.txt de la distribution Spark
val dt = spark.read.format(“libsvm”)
.load(“SparkPath/data/mllib/sample_libsvm_data.txt”)
// fixer la colonne d’entrée et celui de la sortie et la norme utilisée
val indexer = new Normalizer()
.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()
Exemple
32
M.MICHRAFY
TRANSFORMER : SEGMENTATION DU TEXTE EN MOTS
Tokenizer vise à segmenter une
phrase ou une ligne en une liste de
mots.
Le Tokenizer utilise le séparateur
espace pour segmenter un texte.
Objectif
// 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)
Exemple
33
M.MICHRAFY
TRANSFORMER : BINARISER UN VECTEUR
Binarizer permet de transformer unvecteur 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
Objectif
// 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|
Exemple
34
M.MICHRAFY
TRANSFORMER : REGROUPER DES COLONNES
VectorAssembler permet deregrouper 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 lesalgorithmes de l’API Spark ML
nécessitent que les variables
explicatives soient de type
vecteur.
Objectif
// 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]|
Exemple
35
M.MICHRAFY
MISE EN OUVRE DES PIPELINES SOUS SPARK ML
36
M.MICHRAFY
• 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
PIPELINE : RÉGRESSION LINÉAIRE, DONNÉES OZONE 1/2
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
Objectif
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 colonneval 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)
Exemple
37
M.MICHRAFY
1
PIPELINE : RÉGRESSION LINÉAIRE, DONNÉES OZONE 2/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" )
Suite
38
M.MICHRAFY
2Importer 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
PIPELINE : ARBRE DE DÉCISION, DONNÉES IRIS
Proposer un pipeline qui vise à préparerdes données et à ajuster un modèlebasé sur la méthode d’arbre de
décision. Le pipeline est composé de 2
transformateurs et d’un estimateur.
Objectif
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
Exemple
39
M.MICHRAFY
Importer les packages
Charger les données
Indexer des catégories
Regrouper des colonnes
Initier le modèle d’arbre de décision
Construire et lancer le pipeline
Evaluer le modèle les données d’apprentissage
PIPELINE : REGRESSION LOGISTIQUE, DONNÉES PROSTATE
Proposer un pipeline qui vise à préparerdes données et à ajuster un modèle
régression logistique
Le pipeline est composé de 2transformateurs et d’un estimateur.
Objectif
import org.apache.spark.ml.{Pipeline, PipelineModel}
import org.apache.spark.ml.feature.{VectorAssembler,StringIndexer,VectorIndexer}
import org.apache.spark.ml.classification.LogisticRegression
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
Exemple
40
M.MICHRAFY
Importer les packages
Charger les données
Indexer des catégories
Regrouper des colonnes
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
MISE EN OUVRE DU PROCESSUS D’ÉVALUATION
41
M.MICHRAFY
• 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
EVALUATION DE LA RÉGRESSION LINÉAIRE, DONNÉES OZONE 1/2
Mise en œuvre de l’évaluationd’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.
Objectif
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 colonneval 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)
Exemple
42
M.MICHRAFY
EVALUATION DE LA RÉGRESSION LINÉAIRE, DONNÉES OZONE 2/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)
// import de la classe pour l’evaluation
import org.apache.spark.ml.evaluation.RegressionEvaluator
val evalution = new RegressionEvaluator() // créer l’instance d’évaluation
.setLabelCol("maxO3") //Fixer la colonne du label
.setPredictionCol("maxO3PredictCol") // Fixer la colonne de la prédiction
.setMetricName("rmse") // Fixer la mesure d’évaluation
val RMSE = evalution.evaluate(predictions)
print(s"Root Mean Squared Error = ${RMSE}") // afficher la valeur de RMSE
Root Mean Squared Error = 13.60374600320492
Exemple
43
M.MICHRAFY
Charger les données
Ap
pliq
uer le p
ipelin
e
Préparer les données
Initier et ajuster le modèle
Effectuer la prédiction
Initier l’évaluateur et positionner les params
Evaluer la méthode
Evaluer le m
od
èle
Eval
uat
ion
EVALUATION DE L’ARBRE DE DÉCISION, DONNÉES IRIS
Mise en œuvre de l’évaluation d’uneméthode d’arbre de décision, pour lesdonnées IRIS.
La classe d’évaluation utilisée estMulticlassClassificationEvaluator
La mesure utilisée est Accuracy
Objectif
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
Exemple
44
M.MICHRAFY
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
PIPELINE : REGRESSION LOGISTIQUE, DONNÉES PROSTATE
Mise en œuvre de l’évaluation d’uneméthode de régression logistique, pourles données PROSTATE.
La classe d’évaluation utilisée est
BinaryClassificationEvaluator
La mesure utilisée est areaUnderROC
Objectif
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
Exemple
45
M.MICHRAFY
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
MISE EN OUVRE DE LA VALIDATION CROISÉE
46
M.MICHRAFY
• 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
VALIDATION CROISÉE, GRADIENT BOOSTING, DONNÉES PROSTATE 1/3
Mise en œuvre de la validation croiséed’une méthode de régression logistique ,pour les données PROSTATE.
Objectif
import org.apache.spark.ml.{Pipeline, PipelineModel}import org.apache.spark.ml.feature.{VectorAssembler,StringIndexer,VectorIndexer}import org.apache.spark.ml.evaluation.BinaryClassificationEvaluatorimport org.apache.spark.ml.tuning.{CrossValidator, ParamGridBuilder}import org.apache.spark.ml.classification.LogisticRegression
// Charger les données et renommer les colonnesval 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")
Exemple
47
M.MICHRAFY
La validation croisée et la gestion desparamètres de tuning nécessitentl’import de :
ParamGridBuilder CrossValidator
Lors de la création d’une instance detype CrosseValdation, il est importantde positionner :
le pipleline ou l’algorithme ML l’instance d’évaluation les paramètres de tuning
A retenir
1
VALIDATION CROISÉE, FORÊT DE DÉCISION, DONNÉES PROSTATE 2/3
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))
Exemple
48
M.MICHRAFY
2
VALIDATION CROISÉE, GRADIENT BOOSTING, DONNÉES PROSTATE 3/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)
Exemple
49
M.MICHRAFY
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
3
DR MUSTAPHA MICHRAFY
CONTACT : [email protected]
Un merci à Dr Bernard Kouakou et Dr Oussama Lachiri pour leurs lectures et remarques pertinentes.