Rapport de stage Master 2

Rapport de stage Master 2
Informatique Haute Performance et Simulation, 2ème année
Ecole Centrale Paris
Accélération des méthodes statistiques sur GPU
Auteur : CHAI Anchen.
Responsables: Joel Falcou et Christophe Genolini
Laboratoire: LRI
Du 01/04/2014 au 30/09/2014
1
Remerciements
Je voudrais remercier Joel Falcou et Christophe Genolini, mes tuteurs du
stage, de m’avoir aidé avec beaucoup de patience pendant mon stage. Ils ont
toujours encouragé ma créativité et m’ont fait confiance sur mon travail.
Je remercie également monsieur Antoine, thésard de deuxième années à LRI,
pour ses aides concernant mon stage.
Enfin, je voudrais remercier toutes les personnes de l’équipe « parsys » pour
leur accueil et leur bienveillance pendant mon stage.
2
Sommaire
1. Introduction:....................................................................................................................... 4
1.1 Statistique et informatique ......................................................................................... 4
1.2 R++, the Next Step .................................................................................................. 4
1.3 Parallélisme............................................................................................................. 5
1.4 Méthodologie générale de notre travail ................................................................... 6
1.5 Méthodes statistiques.............................................................................................. 7
1.5.1 Bootstrap ............................................................................................................. 7
1.5.2 Imputation multiple................................................................................................ 7
Partie 2 : Méthode Bootstrap ..................................................................................................... 8
2.1 Description détaillée ................................................................................................ 8
2.1.1 Cas univarié............................................................................................................................ 9
2.1.2 Cas multivarié......................................................................................................................... 9
2.1.3 Comparaison des deux cas .................................................................................................. 10
2.2 Expérience effectuée............................................................................................. 11
2.3 Résultat et performance ........................................................................................ 11
2.4 Conclusion ............................................................................................................ 14
Partie 3 : Imputation Multiple.................................................................................................... 14
3.1 Description détaillée ............................................................................................. 14
3.1.1 Modèle de régression linéaire............................................................................................... 15
3.2 Expérience effectuée ............................................................................................. 16
3.3 Résultats et performance ...................................................................................... 17
3.4 Conclusion ............................................................................................................ 21
4. Conclusion ........................................................................................................................... 22
4.1 Contribution du stage ............................................................................................ 22
4.2 Bilan d’apport du stage .......................................................................................... 23
Bibliographie ............................................................................................................................ 24
Annexe ..................................................................................................................................... 25
3
1. Introduction
1.1 Statistique et informatique
Depuis dizaine années, l’analyse statistique est de plus en plus utilisée dans beaucoup
de domaines. La statistique comprend souvent quatre parties : la collecte des données, le
traitement des données collectées, l’interprétation des données et enfin la présentation.
Aujourd’hui il n’est plus rare d’avoir besoin de traiter et interpréter des données
comportant des millions d’individus ou de variables. Le coût de temps des méthodes
d’analyse devient donc un facteur limitant.
L’arrivé des ordinateurs a profondément modifiée l’utilisation des méthodes
statistiques. Il existe deux types de logiciels qui permettent de faire l’analyse statistique:
les logiciel métier(R, SAS, SPSS...) sont souvent conçus par statisticiens et sont plus facile à
utiliser par les statisticiens. L’inconvénient de ce genre de logiciel est la performance. Le
temps de réponse est souvent long. D’un autre côté, les logiciels conçus par des
informaticiens (Matlab, C/C++, Fortran...) sont plus performants au niveau de calcul, mais
ils manquent d’APIs de haut niveau pour les statisticiens. Ils sont donc très peu utilisés par
les statisticiens.
1.2 R++, the Next Step
L’objectif du projet R++, the Next Step est de produire un logiciel statistique de
haute performance qui proposera les fonctionnalités des logiciels métiers tout en
profitant des techniques informatiques moderne.
Ce projet s’articule autour de trois axes :
a) Parallélisme : Aujourd’hui, il existe de plus en plus de sources de parallélisme
dans le domaine informatique: extension SIMD, multi-cœur, les architectures
récentes comme GPU et le Xeon Phi. Le challenge est donc de développer des
modèles de programmations parallèles qui s’adaptent bien à ces sources.
4
b) Big data : La taille de données devient aujourd’hui un facteur limitant pour les
logiciels statistiques (ils sont généralement bloqué autour du giga). Des
techniques utilisant les bases de données(Oracle ou PostGRES) ou encore plus
moderne, le framework « Hadoop » permettent d’aller au-delà.
c)
Interface homme-machine : Les logiciels statistiques actuels maquent souvent
l’interface graphique interactive. L’objectif de cet axe est de développer une
interface graphique qui facilite l’interaction homme-machine.
Dans ce stage, nous nous sommes intéressés au premier axe, la parallélisation des
méthodes statistiques. Nous nous sommes concentré sur deux méthodes
particulièrement utilisées et couteuses en temps : le Bootstrap et les Imputations
Multiples.
1.3 Parallélisme
Le parallélisme consiste à implémenter des programmes utilisant plusieurs
processeurs permettant de traiter des informations de manière simultanée. Ces
techniques ont pour objectif de réaliser le plus grand nombre d’opérations en un temps
le plus petit possible.Il existe 3 types de sources principales de parallélisme:
a) SIMD(Single Instruction Multiple Data) : la même instruction est appliquée
simultanément à plusieurs données pour obtenir plusieurs résultats en même
temps.C’est typiquement le cas des processeurs vectoriels.
b) Multi-cœur: un processeur possède plusieurs cœurs physiques travaillant en
parallèle. Chaque cœur physique comprend toutes les fonctionnalités
nécessaires à exécuter un programme de façon autonome.
c)
Many-cœur: ce sont des architectures massivement parallèle, par exemple GPU
ou Xeon Phi. Elles permettent de traiter efficacement de nombreuses tâches
simultanées.
Aujourd’hui, le parallélisme est exploré dans de nombreux logiciels. Beaucoup de
bibliothèques numériques ou noyaux de calcul ont été développés pour exploiter
différentes sources parallèles, par exemple BLAS, LAPACK..., qui sont largement utilisés
dans différents domaines.
5
Dans ce stage, nous nous sommes concentré sur l’implémentation parallèle sur GPU.
Pourquoi nous nous intéressons le plus à GPU ? Premièrement, GPU n’est pas cher qui
ont déjà été utilisés comme coprocesseurs pour un grand nombre d’application. GPU est
une unité de calcul massivement parallèle qui nous permet de traiter efficacement de
nombreuses tâches simultanées. Deuxièmement, il existe de nombreuse bibliothèques
numériques de haute performance sur GPU. Par exemple, cuRand(CUDA Random Number
Generation library)[nv10] réalise la génération des nombres aléatoires de haute qualité.
Troisièmement, GPU sont largement utilisés actuellement, même dans un ordinateur
portable, GPU sont souvent intégrés comme un élément standard.
1.4 Méthodologie générale de notre travail
L’objectif du stage est d’étudier les performances du parallélisme appliqué aux
méthodes statistiques. La qualité des résultats de certaines méthodes (généralement
non déterministes) dépend du nombre de tentatives effectués pour trouver la solution.
Cela signifie que pour obtenir des résultats intéressant, il faut faire un grand nombre
d’itérations, le plus grand nombre possible. Dans ce genre de cas, le coût en temps
devient donc un facteur limitant. D’où l’importance la parallélisation des méthodes.
Pour étudier la parallélisation, nous avons choisi deux méthodes statistiques
modernes, très utilisées et assez coûteuses en temps : le Bootstrap et les Imputation
multiple. Nous avons implémenté ces méthodes sur différentes architectures (Multicœur, GPU). Ensuite nous avons mesuré les temps d’exécution avec différentes tailles de
données. Enfin, nous avons comparéles versions classiques et parallèles, en C et en
R[r12].
6
1.5 Méthodes statistiques
1.5.1 Bootstrap
En statistique, bootstrap est une technique permettant de faire de l’inférence
statistique à partir d’un nombre limité d’observation.
Bootstrap est une méthode très utilisée dans le domaine statistique mais assez
coûteux, qui est la troisieme fonction que nous voulons paralléliser dans R[tm14]. Du
point de vu de l’informatique, un grand nombre de rééchantillonnage indépendants sont
requis, ce qui nous permet de penser que le parallélisme permettra effectivement un
gain de temps.
Il existe plusieurs packages parallèles de bootstrap, la liste(non exhaustif) est
présentée ici :
1) Le package parallèle dans R. Les fonctions standards dans R, par exemple, boot(),
bootstrap(), nous permettent de paralléliser bootstrap explicitement :
boot(..., parallel=c(“no”,”multicore”,”snow”) )
ou
bootstrap(..., parallel=c(“no”,”multicore”,”snow”)).
L’option “multicore” permet d’exécuter bootstrap en plusieurs processeurs en même
temps. L’option “snow” qui nous permet d’exécuter bootstrap dans un cluster de
machine.
2) Le package SPRINT[jh08](Simple Paralle R interface) qui nous permet de profiter de
plusieurs nœuds en utilisant l’interface MPI(Message Passing Interface)[sm98] .
1.5.2 Imputation multiple
En statistique, l’imputation consiste à remplacer des données manquantes par des
valeurs de substitution. Afin de réduire le bruit due à l’imputation, Rubin(1987) a
développé une méthode appelé l’imputation multiple[ru91].
L’idée de cette méthode est d’effectuer plusieurs imputations sur le même ensemble
de données. Chaque ensemble de données imputées est ensuite analysée séparément.
Le résultat final est la moyenne des résultats des analyses.
7
Imputation multiple est une méthode très utilisée à analyser des valeurs
manquantes aléatoirement, mais c’est aussi une méthode très coûteuse en temps
d’exécution.
Partie 2 : Méthode Bootstrap
2.1 Description détaillée
Le bootstrap est une méthode permettant de calculer l’intervalle de confiance d’une
statistique S lorsque les méthodes classiques (paramétriques) ne le permettent pas.
Différentes méthodes de bootstrap existent, mais elles font toutes appels à un processus
de 4 étapes :
1) A partir d’une population initiale de taille N, un échantillon de taille N, obtenu par
tirage avec remise,est constitué.
2) La statistique Si est calculée sur l’échantillon i
3) Les étapes 1) et 2) sont répétées M fois
4) Les M statistiques Si permettent de calculer l’intervalle de confiance de S.
Nous pouvons le voir, le processus de bootstrap est assez simple. Malheureusement,
la fiabilité du résultat dépend grandement du nombre déchantillonages effectués M.
Quand nous augmentons M, la précision du bootstrap augmente.
En résumé, plus M est grand, meilleure sera la qualité de l’intervalle. Mais d’un point
de vue informatique, plus M et N sont grands, plus de puissance de calcul nécessaire est
importante. D’où l’intérêt d’optimiser le Bootstrap avec l’architecture parallèle récente :
GPU(Graphics Processing Unit).
8
2.1.1 Cas univarié
Nous considérons une population initial de taille N ne contenant qu’une seule variable.
Nous voulons effectuer M échantillonnages, donc nous avons besoin de faire N tirages par
rééchantillonnage. Le nombre total de tirage que nous allons effectuer est M*N. Ensuite
nous pourrons calculer la statistique qui nous intéressent pour chaque échantillon.
Notons fla fonction qui calcule indice statistique. Les calculs dont nous avons besoin
sont :
1) N*M fois de tirage avec remise pour construire M rééchantillonnages
2) M fois d’appels de fonction f() pour calculer l’indice statistique
2.1.2 Cas multivarié
Supposons que nous avons n variables dépendantes et chaque variable a N
observations dans l’échantillon initial. Maintenant, la population initiale est une matrice
de n lignes et N colonne. Chaque colonne est une variable.
Puisque ces n variables sont dépendantes entre eux, nous ne pouvons pas faire les
tirages indépendamment pour chaque variable. Donc nous avons toujours besoin de faire
N tirages pour construire un échantillon, mais cette fois nous tirons une ligne à chaque
tirage. Ensuite nous appelons f() pour chaque variable.
Finalement tous les calculs dont nous avons besoin sont :
1) N*M fois de tirage de colonne pour construire M échantillon
2) n*M fois d’appels de fonction f()
9
2.1.3 Comparaison des deux cas
Si nous comparons le cas univarié et multivarié, nous pouvons constater que dans la
méthode Bootstrap, le nombre de tirages ne dépend pas du nombre de variables, il
dépend du nombre d’individus N et du nombre d’échantillonnage M. Par contre, le
nombre d’appel de f est décidé par le nombre de variablen et le nombre
d’échantillonnage M.
Maintenant pour analyser quantitativement les deux cas, j’introduis ici une métrique à
les évaluer : la densité de calcul P qui est définit par le nombre de calcul par rapport au
nombre total des éléments dans l’échantillon initial.
Pour le cas univarié : P =
N∗M+M
Pour le cas multivarié : P =
N
=M +
N∗M+n∗M
N∗n
M
N
M
M
n
N
= +
où M : nombre d’échantillonnage désiré
n : nombre de variable
N : nombre d’observation
Nous pouvons observer que si le nombre d’observation N reste constant, la densité de
calcul de Bootstrap diminue lorsque le nombre de variable n augmente. Cela signifie que
un peu de variable mais beaucoup d’observations sera le cas optimal à paralléliser. Nous
nous concentrerons donc au cas extrême : univariable dans la partie suivante.
10
2.2 Expérience effectuée
Dans ce rapport, nous allons étudier la performance de bootstrap sur différents
architecture : mono-cœur, multi-cœurs et GPU. Nous allons comparer le temps
d’exécution de bootstrap avec les implémentations sur R, C/C++ et CUDA(GPU).
2.2.1 Benchmark :
L’échantillon initial que nous allons utiliser ici sont des nombres flottants
générés aléatoirement entre 0 et 100. Sa taille varie de 1*100 jusqu’à 1*10^6.
Nous cherchons à estimer le moyen de cet échantillon. Nous fixons le nombre
de répétition M est 1000 fois.
2.2.2 Les processeurs utilisés :
CPU : Intel Xeon [email protected]
GPU : Tesla C2050, 3GB, 1.15GHz
Multi-cœur : 12 cœurs Intel Xeon [email protected]
2.2.3 Compilateur utilisé : gcc version 4.6.4
2.3 Résultat et performance
Dans cette partie, nous allons comparer les performances des différentes implémentations de
bootstrap :
1) L’implémentation manuelle avec R sur CPU(mono-cœur) sans utilisant des bibliothèques
extérieurs(C, C++...)
2) La fonction standard de R : boot() avec des bibliothèques extérieurs(mean(x))
3) L’implémentation avec C/C++ sur CPU(mono-coeur)
4) L’implémentation avec CUDA sur GPU
5) L’implémentation sur multi-coeurs en utilisant OpenMP. Dans le tableau suivant, MC_N
signifie que nous profitons de N cœurs simultanément.
11
2.3.1 L’accélération par rapport à l’implémentation séquentielle CPU :
Speedup
R
Boot()
CPU
GPU
1*10^2
0.04
0.216
1
0.041
1*10^3
0.04
0.483
1
1*10^4
0.04
0.689
1*10^5
0.04
1*10^6
0.04
MC_6
MC_8
MC_10
MC_12
1.41
0.605
0.229
1.034
0.31
3.315
3.62
2.669
2.036
1
2.294
4.85
6.37
5.741
7.382
0.698
1
8.451
5.23
6.89
8.227
9.855
0.577
1
8.81
5.27
6.75
8.442
9.887
Size
Nous prenons ici l’implémentation séquentielle sur CPU comme la référence,donc la
colonne de CPU est toujours 1 dans le tableau. Quand la valeur dans ce tableau est
inférieur à 1, c’est-à-dire que la version est plus lente que CPU et qu’il n’y pas
d’accélération.
Nous pouvons constater que l’implémentation manuelle sur R est toujours 25
fois(1/0.04) plus lente que l’implémentation sur CPU et la fonction standard boot() est
plus rapide que R mais plus lente que GPU et multi-cœur.
Ensuite nous pouvons trouver que GPU va gagner un gain à partir de taille 1*10^4.
L’accélération augmente quand la taille élargi. Nous obtenons un gain de 8.81 à 1*10^6
sur GPU.
Nous avons toujours une accélération sur multi-cœur à partir de taille 1*10^3 et
maintenant nous nous intéressons à la comparaison des performances de GPU avec le
multi-cœur.
Vous pouvez trouver aussi le tableau du temps d’exécution réel de chaque
implémentation de bootstrap dans l’annexe.
12
Selon la courbe ou l’histogramme au dessus, nous pouvons constater que l’accélération
de GPU est entre 10 cœur et 12 cœur à partir de taille 1*10^5. Cela signifie que quand
nous avons assez de données à traiter, la performance de bootstrap sur GPU est meilleur
qu’un processeur de 10 cœurs.
13
2.4 Conclusion
En conclusion, nous pouvons bien profiter de parallélisation sur GPU pour bootstrap
quand nous avons assez de données dans l’échantillonnage original. La performance de
GPU est comparable avec un processeur de 10 cœurs.
Mais la performance de certain résultats de GPU n’est pas très optimale. En fait, cette
limitation vient de deux aspects :
a) Le temps de transfert de données entre GPU et CPU n’est pas négligeable, donc
quand nous n’avons pas assez de calcul à faire, cette partie est assez élevée par
rapport au tempstotal.
b) L’accès à la mémoire globale de GPU est couteux(souvent 400-500 cycles
d’horloge). Sachant que pour construire les rééchantillonnages dans bootstrap,
nous avons besoin de faire de nombreuse fois de tirage qui demande d’accéder la
mémoire globale de manière très aléatoire. La conséquence de ce genre de l’accès
est de nombreuse de défauts de cache potentiels qui est un facteur important
pour bootstrap.
Partie 3 : Imputation Multiple
3.1 Description détaillée
L’Imputation multiple est une méthode statistique introduite par Rubin à 1987. Les
étapes principales de l’imputation multiple sont les suivantes :
a) Choisir un modèle qui prédit toutes les données manquantes à partir de toute les
autres informationsutilisables, par exemple, régression linéaire, régression
logistique ou modèle non-linéaire...
b) Utiliser le modèle choisi à créer un ensemble de données complet
c)
Faire l’analyse statistique de cet ensemble de données complet et enregistrer les
statistiques que nous cherchons(moyenne, ecart type... )
d) Répéter les étapes b) et c) (selon les auteurs, 3 à 5 fois suffisent)
e) Faire l’analyse finale pour l’ensemble de ces répétitions
Le dessin suivant montre le processus global de l’imputation multiple.
14
Dans ce rapport, nous avons utilisé le modèle de régression linéaire pour faire
l’inférence des données manquantes.
3.1.1 Modèle de régression linéaire
En statistique, un modèle de régression linéaire[cm91] est un modèle de régression
d’une variable expliquée sur une ou plusieurs variables explicatives. Dans ce modèle,
nous faisons l’hypothèse que la dépendance de variable expliquée et les variables
explicatives est linéaire.
La formule mathématique pour exprimer la relation entre une variable y et un
vecteur de variables x est :
(3.1)
Où y est la variable expliquée, le vecteur x est l’ensemble des variables explicatives.
u désigne le terme d’erreur aléatoire. Le vecteur ß est le paramètre que nous
cherchons pour pouvoir faire l’inférence les données manquantes. En fait, il existe
plusieurs méthodes mathématiques pour estimer Le vecteur ß. Nous avons choisi la
méthode OLS(ordinary least squares) pour résoudre cette équation.
La formule mathématique est :
15
(3.2)
D’où :
Sachant que trouver l’inverse d’une matrice est assez coûteux(O(n^3))] , nous
transformons cette formule en :
(XTX)ß = XTy
(3.3)
En ce cas là, nous avons besoin de résoudre le système linéaire A*ß = Y, d’où A est (XTX)
et Y est (XTy).
Une fois que nous trouvons ß, nous pouvons ensuite exprimer la variable expliquée
y par le vecteur X qui nous permet d’inférer les valeurs manquantes de y par l’équation
3.1.
Donc, l’implémentation réelle de l’imputation multiple est la suivante :
1) Initialiser toutes les valeurs manquantes. Si une valeur est manquantes, nous la
réplaçons aléatoirement par une des valeurs possibles. Cela conduit a un jeu de
donnée complet.
2) Appliquer le modèle de régression linéaire pour la première variable à qui il
manque des valeurs. Nous remplaçons les valeurs manquantes initiales par les
nouvelles valeurs qui sont trouvées par l’équation 3.1
3) Ensuite nous faisons une deuxième régression linéaire pour deuxième variable à
qui il manque des valeurs. Nous remplaçons les valeurs manquantes initiales par
les nouvelles valeurs. Et ainsi de suite, jusqu’à nous ayons traité toutes les
variables à qui manquent des valeurs
4) Répéter 1), 2), 3) M fois
3.2 Expérience effectuée
Dans ce rapport, nous allons étudier la performance de l’imputation multiple sur
16
différents architectures : mono-cœur, multi-cœur et GPU.
3.2.1 Benchmark :
Les Benchmarks effectués sont des matrices dont le nombre de variable varie de
10^2 jusqu’à 10^3 et dont le nombre d’observation de chaque variable varie de
10^3 jusqu’à 10^6.
Les valeurs de matrice sont des nombres flottants générés arbitrairement entre
0 et 100. Pour chaque taille de matrice, nous ajoutons 10% de valeurs manquantes
et nous appliquons 5 imputations.
3.2.2 Les processeurs utilisés :
CPU : Intel Xeon [email protected]
GPU : Tesla C2050, 3GB, 1.15GHz
Multi-cœur : 12 cœurs Intel Xeon [email protected]
3.2.3 Compilateur utilisé : gcc version 4.6.4
3.3 Résultats et performance
Dans cette partie, nous allons comparer les performances des différentes implémentations de
l’imputation multiple:
1) L’implémentation utilisant la fonction standard mice() dans R :
2) L’implémentation sequentielle en C/C++ avec bibliothèque Blas[bl02] et
Lapack[an99]
3) L’implémentation GPU avec la bibliothèque Magma[do14]
4) L’implémentation multi-cœur avec bibliothèque MKL[intel05] et Lapack, Dans le
tableau suivant, MC_N signifie que nous profitons de N cœurs simultanément.
3.3.1 L’accélération par rapport à l’implémentation CPU
17
Speedup
Mice()
CPU
GPU
MC_4
10*10^3
0.028
1
0.025
0.967
10*10^4
0.0136
1
0.0752
10*10^5
0.00787
1
10*10^6
0.0088
Speedup
MC_6
MC_8
MC_10
MC_12
0.93
0.97
0.947
0.88
1.25
1.05
1.15
1.04
1.07
0.31
0.993
0.97
0.993
1.01
1.028
1
1.015
1.039
1.07
1.09
1.06
0.69
Mice()
CPU
GPU
MC_4
MC_8
MC_10
MC_12
100*10^3
0.02
1
0.485
1.375
0.217
0.125
0.33
0.17
100*10^4
0.027
1
2.15
1.44
1.13
0.87
1.55
1.01
100*10^5
0.0314
1
3.36
1.37
2.22
2.39
2.31
2.24
100*10^6
0.0036
1
3.68
1.522
2.55
2.755
2.56
2.96
1000*1000 0.0074
1
5.79
1.56
3.02
1.65
3.76
3.09
Size
MC_6
Size
Vous pouvez trouver aussi le tableau du temps d’exécution réel de chaque
implémentation de l’imputation multiple dans l’annexe.
Nous prenons ici l’implémentation CPU comme la référence, donc la colonne de CPU
dans le tableau est toujours 1. Puisque à partir de taille 1000*10^4, l’exécution de
fonction mice() est trop longue(> 100h), la mesure donc s’arrête à 1000*1000.
18
Comme nous avons prévu, l’exécution de l’imputation multiple sous R est assez
coûteuse aux grandes tailles. Nous pouvons observer que quand la taille passe de
100*10^5 à 100*10^6, la fonction mice() est un peu près 100 fois plus lente(Annexe 2).
Mais pour CPU, GPU ou multi-cœur, le facteur est normalement 10. Cela signifie encore
une fois que l’overhead de R pour les problèmes de grandes tailles est assez élevé.
Ensuite, la performance de GPU est toujours la meilleur à partir de 100*10^4. Puisque
il existe des calculs assez intensifs dans cette méthode, par exemple la multiplication
matricielle, résoudre le système linéaire... Donc l’imputation multiple est une méthode
très adaptée à GPU, l’accélération est meilleur qu’un processeur de 12 cœurs quand nous
avons 100 variables à traiter.
Maintenant nous nous intéressons à la comparaison des performances de GPU avec le
multi-cœur. Nous prenons ici l’implémentation de CPU comme référence :
1) 10 variables:
19
2) 100 variables
20
Maintenant plus clairement, pour les tailles petite(10 variables), la performance de
GPU n’est pas très optimale par rapport à laquelle de multi-cœur, mais quand nous
augmentons le nombre de variables à 100, nous trouvons que GPU est plus rapide que
multi-cœur à partir de 100*10^4.
3.4 Conclusion
En conclusion, GPU est un bon choix pour accélérer l’imputation multiple quand la
taille de problème est grande. Mais pour les petites tailles, l’implémentation séquentielle
sur CPU est suffisante. En ce moment-là, nous n’avons pas besoin d’utiliser un GPU ou
multi-cœur.
21
4. Conclusion
4.1 Contribution du stage
Pendant 6 mois de stage, nous avons étudié le parallélisme potentiel des méthodes
statistiques modernes. Nous avons implémenté ces méthodes sur différentes
architectures avec des bibliothèques de haute performance.
Avoir effectué les
benchmarks sur différentes tailles de problème, nous avons montré que la parallélisation
est un moyen faisable pour réduire le temps d’exécution des méthodes statistiques
intensives.
Nous avons utilisé l’implémentation CPU comme références à bien montrer que
l’overhead de R est très élevé quand la taille de problème devient grande. Nous trouvons
que ce genre de logiciel métier ne peut plus satisfaire les besoins du statisticien pour
traiter des millions de données efficacement aujourd’hui. Cela confirme la motivation de
notre projet dont l’objectif est de produire un logiciel statistique adapté à Big data.
De plus, pendant ce stage, nous avons comparé expérimentalement les performances
de multi-cœur et GPU en fonction de tailles. Nous avons montré que la performance de
GPU est meilleur qu’un processeur de 12 cœurs quand il y a assez de données.
22
4.2 Bilan d’apport du stage
D’abord, j’ai appris deux méthodes statistiques très utilisée dans le domaine médical :
Bootstrap et Imputation Multiple. Ce stage m’a permis de découvrir le parallélisme
potentiel de statistique et d’appliquer GPGPU dans le domaine statistique. Pour pouvoir
étudier et comparer la performance de différentes architectures, j’ai utilisé beaucoup de
bibliothèques à exploiter la parallélisation, par exemple, CURAND ,Thrust, Blas, MKL,
Magma...
Ensuite, pendant ce stage, j’ai eu la chance à connaître comment utiliser le logiciel R
pour traiter et analyser des problèmes statistiques. J’ai mesuré le temps d’exécution de
chaque méthode sous R et les ai utilisé à comparer avec GPU et multi-cœur.
Enfin, ce stage était un stage multidisciplinaire, j’ai eu la chance de travailler avec des
statisticiens, informaticiens et des experts de compilation, qui me permettait d’élargir
mes connaissances dans différents domaines et d’augmenter mon niveau de
communication et collaboration.
23
Bibliographie
[r12] R Core Team, R: A Language and Environment for Statistical
Computing. R Foundation for Statistical Computing, Vienna, Austria,
2012. ISBN 3-900051-07-0, http://www.R-project.org.
[nv10] Nvidia, C. U. D. A. (2010). Curand library.
[tm14] Sloan, T. M., Piotrowski, M., Forster, T., & Ghazal, P. (2014). Parallel Optimisation of
Bootstrapping in R. arXiv preprint arXiv:1401.6389.
[jh08] Hill, J., Hambley, M., Forster, T., Mewissen, M., Sloan, T. M., Scharinger, F., ... & Ghazal, P. (2008).
SPRINT: A new parallel framework for R. BMC bioinformatics, 9(1), 558.
[sm98] Snir, M. (Ed.). (1998). MPI--the Complete Reference: The MPI core (Vol. 1). MIT press.
[ru91] Rubin, D. B., & Schenker, N. (1991). Multiple imputation in health‐are databases: An overview
and some applications. Statistics in medicine, 10(4), 585-598.
[cm91] Charles Manski, « Regression », Journal of Economic Literature, vol. 29,no 1, mars 1991, p. 3450
[bl02] Blackford, L. S., Petitet, A., Pozo, R., Remington, K., Whaley, R. C., Demmel, J., ... & Lumsdaine, A.
(2002). An updated set of basic linear algebra subprograms (BLAS). ACM Transactions on Mathematical
Software, 28(2), 135-151.
[an99] Anderson, E., Bai, Z., Bischof, C., Blackford, S., Demmel, J., Dongarra, J., ... & Sorensen, D.
(1999). LAPACK Users' guide (Vol. 9). Siam.
[do14] Dongarra, J., Gates, M., Haidar, A., Kurzak, J., Luszczek, P., Tomov, S., Yamazaki, I."Accelerating
Numerical Dense Linear Algebra Calculations with GPUs," Numerical Calculations with GPUs,
Volodymyr Kindratenko, eds., eds. Springer International Publishing, pp. 3-28, July, 2014.
[intel05] Intel, M. K. L. (2005). Intel math kernel library, linear solvers basics.
24
Annexe
1. Le temps d’exécution de bootstrap (en seconde)
Time
R
Boot()
CPU
GPU
1*10^2
0.119
0.025
0.0054
0.1324
1*10^3
0.995
0.085
0.0411
1*10^4
8.614
0.531
1*10^5
87.557
1*10^6
871.417
MC_6
MC_8
MC_10
MC_12
0.00384
0.00893
0.0236
0.00522
0.1343
0.0124
0.01136
0.0154
0.02019
0.3657
0.1594
0.0754
0.0574
0.0637
0.04954
5.056
3.52934
0.4176
0.675
0.5123
0.429
0.3581
61.563
35.534
4.033
6.7406
5.2628
4.2089
3.5938
Size
25
2. Le temps d’exécution de l’imputation multiple(en seconde)
Time
Mice()
CPU
GPU
MC_4
10*10^3
0.549
0.01548
0.6192
0.016
10*10^4
3.628
0.0495
0.6579
10*10^5
32.008
0.252
10*10^6
332.328
Time
MC_6
MC_8
MC_10
MC_12
0.0167
0.01591
0.01634
0.01763
0.0396
0.0473
0.043
0.0473
0.046
0.8228
0.2537
0.2596
0.2537
0.2494
0.245
2.925
2.881
2.816
2.728
2.684
2.752
4.214
Mice()
CPU
GPU
MC_4
MC_8
MC_10
MC_12
100*10^3
33.85
0.7095
1.462
0.516
3.268
5.676
2.15
4.214
100*10^4
218.245
6.006
2.795
4.18
5.28
6.88
3.87
5.934
100*10^5
1933.0335
60.72
18.06
44.29
27.278
25.37
26.316
27.09
100*10^6
189742.457
684.8
186.19
449.78
268.32
248.54
267.46
230.91
605.44
104.49
388.52
200.143
367.65
160.82
196.51
Size
MC_6
Size
(>50H)
1000*1000
80820.257
(>22H)
26