Installation du framework Spark sous Windows

La librairie MLlib de Spark pour le Machine Learning

Programmation R avec SparkR

Ricco Rakotomalala
Tutoriels Tanagra - [Link] 1
Le framework Spark – Objectif du tutoriel

Apache Spark est un framework open source de calcul distribué dédié au Big Data. Sa particularité est qu’il
est capable de travailler en mémoire vive. Il est très performant pour les opérations nécessitant plusieurs
itérations sur les mêmes données, exactement ce dont ont besoin les algorithmes de machine learning.

Spark peut fonctionner sans Hadoop, mais il a besoin d’un gestionnaire de clusters (qu’il a en interne) et d’un
système de fichiers distribués (qu’il n’a pas), ce que peut lui fournir Hadoop avec respectivement Hadoop
Yarn et HDFS (Hadoop Distributed File System). De fait, les faire fonctionner ensemble est très avantageux
(Hadoop, stockage ; Spark, calculs).

Au-delà des API (modules de classes et fonctions) standards, Spark intègre des librairies additionnelles :
Streaming, traitement des données en flux ; SQL, accès aux données Spark avec des requêtes SQL ;
GraphX, traitement des graphes ; MLlib, types de données et algorithmes pour le machine learning.

SparkR est un package qui permet de manipuler les types de données et méthodes de MLlib (pas toutes, le
portage est en cours) en programmation R, et de bénéficier directement des avantages de Spark (gestion de
la volumétrie, calcul distribué). Ce tutoriel a pour objectif de s’initier à l’utilisation de SparkR en traitant un
exemple typique d’analyse prédictive.

Ricco Rakotomalala
Tutoriels Tanagra - [Link] 2
 Plan

1. Installation de Spark sous Windows

2. Installation de l’environnement de développement – R et RStudio
3. Programmation R avec SparkR
4. Références

Ricco Rakotomalala
Tutoriels Tanagra - [Link] 3
 Plusieurs pistes sont possibles. Certains éditeurs proposent des systèmes complets
(système d’exploitation + Spark) déjà configurés que l’on peut installer directement
sur une machine ou une machine virtuelle (ex. Cloudera).

Mais nous pouvons également installer le framework sur un système d’exploitation

préexistant. C’est le choix que nous avons fait dans ce tutoriel. Nous nous appuyons
sur Windows 7 64 bits (Edition familiale)

Pour éviter les interférences, nous partons d’une machine virtuelle vierge hébergée
par Virtual Box, un outil de virtualisation libre.

Ricco Rakotomalala
Tutoriels Tanagra - [Link] 4
VirtualBox

VirtualBox est un outil de virtualisation de systèmes

d’exploitation. Il permet l’hébergement de plusieurs ordinateurs
virtuels dans lesquels s’installent divers systèmes
d’exploitation. Plusieurs machines virtuelles peuvent ainsi
fonctionner concurremment sur la même machine hôte. C’est
un outil privilégié pour effectuer des tests. Il est possible
d’archiver différents états de la même machine.

Ricco Rakotomalala
Tutoriels Tanagra - [Link] 5
Machine virtuelle Windows 7 sous Virtual Box

Le système d’exploitation Windows 7 64 bits

vient d’être installé sous VirtualBox. Les mises à
jour automatiques ont été désactivées pour
éviter les modifications intempestives.

Ricco Rakotomalala
Tutoriels Tanagra - [Link] 6
Installation de Java JDK version 8 (64 bits)

Java a été installé à la racine, dans le

dossier « Java ». 2 sous-répertoires ont
été créés pour le JDK et le JRE.

Ricco Rakotomalala
Tutoriels Tanagra - [Link] 7
L’utilitaire WinUtils
Plusieurs utilitaires, dont
‘’winutils’’, sont nécessaires
pour pouvoir faire fonctionner
Hadoop sous Windows.

La distribution Spark que nous

allons utiliser est adossée à
Hadoop.

Contenu du
fichier archive.

Nous désarchivons le fichier

dans le dossier « c:\winutils »

Ci-contre le contenu du sous-

répertoire « c:\wintils\bin »

Ricco Rakotomalala
Tutoriels Tanagra - [Link] 8
Package redistribuable MS Visual C++ 2010
Ce package doit être installé. Il est
nécessaire au bon fonctionnement de
« winutils ».

Ricco Rakotomalala
Tutoriels Tanagra - [Link] 9
 Choix de la version de Spark et installation

Nous désarchivons simplement

le fichier dans un répertoire
dédié. Ici : « c:\spark-1.6.1-bin-
hadoop2.6 »

Voici l’organisation des

dossiers de notre
machine à ce stade.
Chargement de la version pour
Hadoop 2.6.

Ricco Rakotomalala
Tutoriels Tanagra - [Link] 10
Configuration des variables d’environnement 2 variables d’environnement, SPARK_HOME et
HADOOP_HOME, doivent être spécifiées pour
que le système retrouve les exécutables lors
de la sollicitation du dispositif.

Ricco Rakotomalala
Tutoriels Tanagra - [Link] 11
Configuration de Hadoop via winutils Créer le dossier « c:\tmp\hive » au préalable.

Lancer la console en mode administrateur, et

accorder tous les droits d’accès (chmod 777)
à ce dossier via l’utilitaire winutils.

Ce dossier temporaire est nécessaire au bon

fonctionnement de Hadoop.

Ricco Rakotomalala
Tutoriels Tanagra - [Link] 12
Lancer Spark

Mais pour l’exploiter, il faudrait savoir

coder en « scala », ce qui n’est pas mon
cas (Remarque : exit permet de sortir de
l’interpréteur de commandes).

Via le terminal de commande lancé en mode

administrateur. Liste des exécutables.

On peut lancer Spark avec « spark-shell »

Ricco Rakotomalala
Tutoriels Tanagra - [Link] 13
 Installation de R (obligatoire)
Installation de RStudio (c’est mieux)

Ricco Rakotomalala
Tutoriels Tanagra - [Link] 14
Installation de R

Installation de la version la plus récente de R

pour Windows (3.3.0 au 19/05/2016).

Ricco Rakotomalala
Tutoriels Tanagra - [Link] 15
Première utilisation de SparkR

On peut insérer directement ici les

commandes R. Mais ce n’est pas très
convivial, j’en conviens.

On peut déjà fonctionner directement en

lançant ‘’sparkR’’ dans le terminal de
commande. Attention ! Il faut que le
chemin de R soit ajouté à la variable
Ricco Rakotomalala PATH de Windows.
d’environnement
Tutoriels Tanagra - [Link] 16
Installation de RStudio

RStudio est un environnement de développement

dédié à R. Son utilisation n’est pas indispensable, mais
il nous facilite grandement la vie.

Editeur de code

Console R
Visualisation des sorties

Ricco Rakotomalala
Tutoriels Tanagra - [Link] 17
 Exploiter via R la librairie MLlib de machine learning pour Spark
dans un schéma d’analyse prédictive très classique

Pour éviter toutes ambigüités, toutes les fonctions SparkR seront

préfixées par le nom de la librairie dans le code R (SparkR::)

Ricco Rakotomalala
Tutoriels Tanagra - [Link] 18
MLlib et SparkR

MLlib est une librairie de machine learning pour Spark. Il intègre les
algorithmes usuels de fouille de données (classement, régression, clustering
– Voir MLlib Guide).

Il permet l’exploitation des capacités de Spark en matière de manipulation

et de traitement des gros volumes sans que l’on ait quelque chose de
particulier à faire, sauf à connaître les structures de données et les
commandes dédiées.

SparkR est un package spécifique qui fournit des outils permettant

d’exploiter les fonctionnalités de Spark et MLlib à partir de R.

Nous programmons toujours en langage R, mais de nouvelles structures de

données et jeux d’instructions sont à notre disposition pour exploiter
pleinement la puissance de Spark pour le traitement des données massives.

Ricco Rakotomalala
Tutoriels Tanagra - [Link] 19
Données : Breast Cancer Wisconsin (Serveur UCI)

Il s’agit d’un fichier texte

avec séparateur tabulation.
La dernière colonne ‘’target’’
représente la variable cible.

Le fichier « [Link] » a été

placé dans le dossier « c:\data »

Ricco Rakotomalala
Tutoriels Tanagra - [Link] 20
Etapes de la modélisation prédictive et de son évaluation

Y : variable cible (target)

X1, X2, … : variables explicatives (clump, …, mitoses)
f(.) une fonction qui essaie d’établir la relation Y = f(X1, X2, …)
f(.) doit être « aussi précise que possible »…

Ensemble Construction de la fonction f(.) à

d’apprentissage partir des données d’apprentissage

Y = f(X1,X2,…) + 

Application du modèle (prédiction)

sur l’ensemble de test

Ensemble Mesures de performances par

(Y , Yˆ )
de données confrontation entre Y et Y^ :
(dataset) matrice de confusion +
Y : valeurs observées mesures
Ensemble de test
Y^ : valeurs prédites par f(.)

Ricco Rakotomalala
Tutoriels Tanagra - [Link] 21
Etape 1 : Modification des chemins d’accès aux packages – Chargement du package

# vérifier les chemins d'accès aux packages

print(.libPaths())
# ajouter le chemin du package SparkR Il faut indiquer à R
.libPaths(c([Link]([Link]("SPARK_HOME"),"R","lib"), .libPaths())) l’endroit où est situé
#re-vérifier le package SparkR
print(.libPaths())

# chargement du package sparkR

library(SparkR)

#1er affichage (print)

[1] "C:/Users/Marjorie/Documents/R/win-
library/3.3" "C:/Program Files/R/R-
3.3.0/library"

#2nd affichage (print)

[1] "c:/spark-1.6.1-bin-hadoop2.6/R/lib"
"C:/Users/Marjorie/Documents/R/win-library/3.3"
[3] "C:/Program Files/R/R-3.3.0/library"

Ricco Rakotomalala
Tutoriels Tanagra - [Link] 22
Etape 2 : Chargement des données
# initialisation d'un SparkContext c.-à-d. le "moteur" Spark est démarré. [Link]() l'éteindra
# dans le gestionnaire de tâches de Windows, on voit 3 nouveaux processus arriver (java, cmd, cmd)
sc <- SparkR::[Link](master = "local", sparkPackages = "[Link]:spark-csv_2.10:1.4.0")
# puis d'un SQLContext, point d’entrée pour toutes les fonctionnalités Spark
# [Link]
sqlContext <- SparkR::[Link](sc)
# importation du fichier CSV via [Link] - séparateur tabulation (delimiter), en-tête (header) : noms des variables
# [Link] est de type DataFrame spécifique à SparkR
[Link] <- SparkR::[Link](sqlContext,"C:/data/[Link]","[Link]", header="true",delimiter="\t")
# affichage du schéma du DataFrame
SparkR::printSchema([Link])
# affichage des 10 premières observations (lignes)
SparkR::showDF([Link],10)

# affichage de la structure (schéma)

# du tableau de données
Affichage des 10 premières
root
lignes du DataFrame ‘’[Link]’’
|-- clump: string (nullable = true)
|-- ucellsize: string (nullable = true)
|-- ucellshape: string (nullable = true)
|-- mgadhesion: string (nullable = true)
|-- sepics: string (nullable = true)
|-- bnuclei: string (nullable = true)
|-- bchromatin: string (nullable = true)
|-- normnucl: string (nullable = true)
|-- mitoses: string (nullable = true)
|-- target: string (nullable = true)

Ricco Rakotomalala
Tutoriels Tanagra - [Link] 23
Etape 3 : Conversion de types

# conversions de types pour les descripteurs de [Link]

[Link]$clump <- SparkR::cast([Link]$clump, "double")
[Link]$ucellsize <- SparkR::cast([Link]$ucellsize, "double")
Les descripteurs
[Link]$ucellshape <- SparkR::cast([Link]$ucellshape, "double") "clump"..."mitoses" ont été
[Link]$mgadhesion <- SparkR::cast([Link]$mgadhesion, "double") reconnues comme « string ».
[Link]$sepics <- SparkR::cast([Link]$sepics, "double") Cela ne convient pas pour les
[Link]$bnuclei <- cast([Link]$bnuclei, "double")
calculs (régression logistique).
[Link]$bchromatin <- cast([Link]$bchromatin, "double")
[Link]$normnucl <- cast([Link]$normnucl, "double") Il faut les convertir en réel
[Link]$mitoses <- cast([Link]$mitoses, "double") (double) dans le DataFrame
# affichage du nouveau schéma du DataFrame ‘’[Link]’’
SparkR::printSchema([Link])

# nouveau schéma
root
|-- clump: double (nullable = true)
|-- ucellsize: double (nullable = true)
|-- ucellshape: double (nullable = true)
|-- mgadhesion: double (nullable = true)
|-- sepics: double (nullable = true)
|-- bnuclei: double (nullable = true)
|-- bchromatin: double (nullable = true)
|-- normnucl: double (nullable = true)
|-- mitoses: double (nullable = true)
‘’target’’ est la variable cible qualitative,
|-- target: string (nullable = true) on peut la laisser au format « string »

Ricco Rakotomalala
Tutoriels Tanagra - [Link] 24
Etape 4 : Subdivision des données en échantillons d’apprentissage et de test

Pour disposer d’une mesure honnête des

performances du modèle dans la population, il faut
l’évaluer sur un échantillon qui n’a pas pris part à sa
# compter le nombre de lignes construction. Habituellement, on scinde en 2 les
n <- SparkR::nrow([Link])
données disponibles : la première sert à
print(n) # 699
l’apprentissage, la seconde (test) sert à l’évaluation.
# ajouter dans le [Link] une colonne de valeurs aléatoires U(0, 1)
# on va s’en servir pour scinder les données
[Link]$alea <- SparkR::rand(n)
SparkR::printSchema([Link])

# extraction de l’échantillon d'apprentissage à partir d’une condition sur ‘’alea’’

# approximativement 2/3 des individus disponibles
# un nouveau DataFrame SparkR nommé ‘’[Link]’’ est créé
# la colonne additionnelle ‘’alea’’ n’est pas incluse (1:10)
[Link] <- SparkR::subset([Link], [Link]$alea <= 0.667, 1:10)
SparkR::printSchema([Link])
print(SparkR::nrow([Link])) # 455

# échantillon test (les autres)

[Link] <- SparkR::subset([Link], [Link]$alea > 0.667, 1:10)
print(SparkR::nrow([Link])) # 244

Ricco Rakotomalala
Tutoriels Tanagra - [Link] 25
Etape 5 : Modélisation et affichage des résultats – Régression logistique

# construction d'un modèle de régression logistique

# target vs. toutes les autres variables du DataFrame ‘’[Link]’’
modele <- SparkR::glm(target ~ ., family = "binomial", data = [Link])
# affichage
print(modele)
# affichage du summary
print(SparkR::summary(modele))

# print(modele)
An object of class "PipelineModel »
Slot "model": Java ref type
[Link] id 290

#affichage du summary
$coefficients Estimate
(Intercept)-10.9809891
Pas grand-chose dans le print(),
clump 0.5609039
ucellsize -0.1896514 summary() en revanche fournit les
ucellshape 0.3820318 coefficients de l’équation LOGIT
mgadhesion 0.3394497
sepics -0.0805315
bnuclei 0.5316810
bchromatin 0.4646330
normnucl 0.4338739
mitoses 0.8756312

Ricco Rakotomalala
Tutoriels Tanagra - [Link] 26
‘’target’’, cible observée sur l’échantillon test ; ‘’label’’,
Etape 6 : Prédiction sur l’échantillon test
target recodée en 0/1 ; ‘’rawPrediction’’, valeur du logit ;
‘’probability’’, probabilité d’appartenance aux classes,
transformation du logit via la fonction logistique ;
‘’prediction’’, prédiction du modèle : proba < 0.5 alors 0
(begnin) sinon 1 (malignant)

# prédiction sur l'échantillon test

pred <- SparkR::predict(modele, newData = [Link])
# structure (schéma) de pred qui est un DataFrame
SparkR::printSchema(pred)
# affichage des valeurs pour les 10 premiers
SparkR::showDF(SparkR::select(pred,c('target','label','rawPrediction','probability','prediction')),10)

# recodage de la prédiction pour être conforme avec la description de nos données (type target = string)
# la nouvelle colonne ‘’predTarget’’ est insérée dans le DataFrame ‘’pred’’
pred$predTarget <- SparkR::ifelse(pred$prediction == 0, "begnin", "malignant")
#affichage des valeurs pour les 10 premiers
SparkR::showDF(SparkR::select(pred,c('target','label','rawPrediction','probability','prediction','predTarget')),10)

La colonne ‘’predTarget’’ a été

accolée au DataFrame, on aura
alors à confronter ‘’target’’ (Y) et
‘’predTarget’’ (Y^) (cf. page 21)

Ricco Rakotomalala
Tutoriels Tanagra - [Link] 27
Etape 7 : Matrice de confusion et taux d’erreur

# 1. récupérer les infos dans un [Link] local (type R) On utilise un artifice pour pouvoir
[Link] <- SparkR::collect(select(pred,c('target','predTarget'))) élaborer la matrice de confusion :
(1) on monte les colonnes ‘’target’’
# 2. matrice de confusion
mc <- base::table([Link]$target,[Link]$predTarget)
et ‘’predTarget’’ dans un [Link]
print(mc) (type R) en mémoire locale [c’est le
rôle de SparkR::collect()], (2) à
# 3. taux d'erreur
print(1-sum(diag(mc))/sum(mc))
partir de là on les croise avec
base::table() [fonction de « base »
# fin de session sparkR, ne pas oublier (!) de R], (3) puis on calcule le ratio
[Link]()
« taux d’erreur ».

Matrice de confusion sur

l’échantillon test et taux d’erreur.
56
taux d'erreur   0.045
244

Ricco Rakotomalala
Tutoriels Tanagra - [Link] 28
Ricco Rakotomalala
Tutoriels Tanagra - [Link] 29
Références

Machine Learning Library (MLlib) Guide

Liste des méthodes de Machine Learning disponibles dans MLlib.

SparkR (R on Spark)
Structures et algorithmes disponibles. Pour l’heure (ver. 1.6.1), seuls les régressions linéaires et
logistiques sont disponibles.

Daniel Emaasit, « Installing and Starting SparkR Locally on Windows OS and

Rstudio », R-bloggers, July 2015.
Détaille le processus d’installation de Spark / SparkR sous Windows + un exemple très simple
d’accès aux données.

Alban Phelip, « Découvrez SparkR, la nouvelle API de Spark », Blog Xebia, Sep. 2015.
La trame de ma démo est très proche de la sienne, à la différence que d’autres données sont
utilisées, la subdivision aléatoire (apprentissage / test) des données est réalisée dans le
programme R, et que la matrice de confusion est calculée explicitement.

Ricco Rakotomalala
Tutoriels Tanagra - [Link] 30