Apache SPARK ML : principes, concepts et mise en œuvre

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
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
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.
Evaluators
Technique 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 est
constitué 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 une
Dataframe et retourne une
DataFrame.
Etape de Transformation
• Pour une étape d’estimation, la
méthode fit() d’un Estimator est
appelé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
Params
DataFrame
DataFrame
DataFrame
Transformer
Transformer
Estimator
Hiérarchie:
Estimator&Transformer

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
IntArrayParam
IntParam
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 cas
positifs correctement identifiés
• Spécificité : le taux de cas
négatifs correctement identifiés
• Accuracy : le taux de cas
positifs ou négatifs
correctement identifiés.
• F-mesure : le taux qui combine
la sensibilité et la spécificité
Mesures d’évaluation
• La courbe ROC (receiver
operating characteristic) est
utilisé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éelle
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 en
pourcentage (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
RegressionEvaluator
 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 setlabelCol
2. 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
1
2
3
4
5
6
DADT
A
B Ajuster le modèle sur DA et
valider le modèle sur DT
C Estimer l’erreur e
Appliquer A et B pour chaque couple d’échantillon
Calculer les erreurs e1 ….e6
Calculer l’erreur de prédiction
e1
e2
e6
DA : données d’apprentissage
DT : données de test
.
.
.

ML TUNING : SÉLECTION DU MODÈLE ET CHOIX DES PARAMÈTRES
21
• Spark ML propose des outils (ML
tuning) 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 la
validation croisée
2. TrainValidationSplit : pour
l’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 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
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 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
CrossValidatorModel
• 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é
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
de régression
de clustering
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. 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|
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
.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"). printSchema
root
|-- 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’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.
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
.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 vecteur
de 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 utile
lorsqu’ 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
.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 les
données en utilisant la norme Lp, p
est un paramètre d’entrée.
 Lorsque p prend la valeur 2 (valeur
par 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 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
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 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.
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 colonne
.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é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.
Objectif
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éparer
des données et à ajuster un modèle
régression logistique
 Le pipeline est composé de 2
transformateurs et d’un estimateur.
Objectif
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
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’é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.
Objectif
import org.apache.spark.ml.regression.LinearRegression
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
.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
.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
Appliquerlepipeline
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
Evaluerlemodèle
Evaluation

EVALUATION DE L’ARBRE DE DÉCISION, DONNÉES IRIS
 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
 La mesure utilisée est Accuracy
Objectif
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
Ajuster le model ML
Evaluer la méthode via la
mesure Accarucy

PIPELINE : REGRESSION LOGISTIQUE, DONNÉES PROSTATE
 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
 La mesure utilisée est areaUnderROC
Objectif
/*****************************************************************
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
Ajuster le model ML
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ée
d’une méthode de régression logistique ,
pour les données PROSTATE.
Objectif
import org.apache.spark.ml.evaluation.BinaryClassificationEvaluator
import org.apache.spark.ml.tuning.{CrossValidator, ParamGridBuilder}
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
.setInputCols(Array("age","acide","rayonx","taille", "grade", "logAcid"))
.setOutputCol("features")
// Transformer la variable Y en un indexer
.setInputCol("Y")
.setOutputCol("label")
Exemple
47
M.MICHRAFY
 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
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
.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 : DATASCIENCE.KM@GMAIL.COM
Un merci à Dr Bernard Kouakou et Dr Oussama Lachiri pour leurs lectures et remarques pertinentes.

Apache SPARK ML : principes, concepts et mise en œuvre

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

En vedette

En vedette (20)

Similaire à Apache SPARK ML : principes, concepts et mise en œuvre

Similaire à Apache SPARK ML : principes, concepts et mise en œuvre (20)

Apache SPARK ML : principes, concepts et mise en œuvre