Apprentissage profond dans les systèmes distribués

L’apprentissage automatique

                  L’apprentissage automatique est motivé par la réalisation de tâches difficiles à définir de manière exhaustive ou par des règles simples dans des programmes classiques. Par exemple, développer une IA (Intelligence Artificielle) pour jouer au jeu de Go en respectant les règles du jeu est relativement simple à programmer car l’ensemble des règles peut facilement être défini (Chaque joueur joue un seul pion à son tour, il ne peut poser son pion que sur une case valide, etc). Cependant, faire jouer l’IA de manière optimale afin de remporter la victoire est impossible à définir simplement. Ceci est dû au fait que le jeu de Go n’a pas de stratégie optimale connue, ce qui ne permet pas de créer une succession de règles à suivre pour l’IA afin de gagner. De plus, le nombre d’états possibles du jeu ainsi que les possibilités à chaque état sont tellement importants qu’il est impossible de tout décrire dans un programme classique pour une IA. Prenons un autre exemple avec la vision assistée par ordinateur. La reconnaissance du visage d’un être humain sur une image peut nous paraître être une tâche simple car il nous est possible de le faire sans réflexion. Mais lorsque nous combinons la grande variété de visages possibles avec l’ensemble de toutes les dispositions de ces visages dans une image, il est impossible de décrire simplement ceux-ci à partir de la valeur de chaque pixel de l’image. Dans ces deux situations, l’apprentissage automatique permet d’entrainer des modèles statistiques afin qu’ils trouvent par eux-même les connaissances nécessaires à l’accomplissement de ces tâches à l’aide d’exemples présents dans nos données. Une définition formelle de l’apprentissage automatique a été proposée par T. Mitchell [78] : « Un programme informatique est dit capable d’apprentissage à partir d’une expérience E dans le respect d’une classe de tâche T avec la mesure de performance P s’il accomplit la tâche T, mesurée par P, et améliorée par l’expérience E ». Nous appellerons modèle (modèle statistique ou modèle d’apprentissage) ce programme informatique capable d’apprentissage. Voyons tout d’abord ce modèle comme une boîte noire, capable de prendre en entrée des données de l’extérieur (par exemple, des images d’une caméra, le trafic réseau d’un routeur, etc) et renvoyer une sortie (par exemple, prise de décision de l’IA, description d’une image, etc ). Ce modèle possède des paramètres θ qui permettent d’influencer sa sortie en fonction de l’entrée (voir Figure 1.1). Comme expliqué dans la définition de Michell, l’apprentissage nécessite une expérience E. Celle-ci consiste généralement en une base de données d’apprentissage Btrain que le modèle analyse lors du processus d’apprentissage. Cet apprentissage d’une tâche T se fait à l’aide d’une fonction de coût J. Cette fonction de coût est calculée sur une base de données de test Btest, distincte de Btrain, afin de mesurer les performances du modèle appris ; c’est la mesure de performance P. Lors de l’apprentissage, le modèle doit donc être capable de modifier ses paramètres θ à l’aide de la base de données d’apprentissage Btrain pour améliorer ses performances mesurées par P. Le fait que la performance soit mesurée sur une base de données Btest distincte de Btrain implique une capacité de généralisation du modèle, c’est-à-dire, une capacité à répondre à des cas qu’il n’a pas vu lors de son expérience E. Le but du modèle est de faire tendre ses paramètres θ vers un optimal θ∗ qui minimise J sur Btest (la mesure P). L’apprentissage automatique se divise en deux catégories en fonction de la nature de l’expérience E : l’apprentissage supervisé et l’apprentissage non supervisé. Dans le cas de l’apprentissage supervisé, pour chaque exemple x ∈ Btrain, la sortie attendue du modèle y lui est donnée. Nous présentons ici deux cas classiques de tâches d’apprentissage supervisé :
— La classification : Chaque donnée en entrée x est associée à un label y ∈ {0, 1}m. Une valeur de 1 dans la i-ème entrée de y signifie que x appartient à la i-ème classe parmis les m possibles. La classification est dite multi-classes lorsque m > 2 et multi-labels lorsqu’il est possible que plusieurs entrées de y soient égales à 1. Un exemple de classification binaire (c’est-à-dire, à deux
classes mutuellement exclusives) est présenté dans la Figure 1.2.
— La régression : Consiste à associer l’entrée x à un y ∈ Rm. La principale différence avec la classification est l’espace de sortie Y qui est continu. Le but d’un classifieur est d’apprendre la frontière entre ces deux classes. Il peut ainsi classifier des nouvelles données (en gris sur la figure). Dans le cas de l’apprentissage non supervisé, les exemples de la base de données d’apprentissage Btrain ne possèdent pas de label attendu en sortie. Le but de l’apprentissage est de trouver une structure cohérente aux données en entrée. Les 3 principales tâches qui peuvent être réalisées à partir d’un apprentissage non supervisé sont les suivantes :
— Clustering : Cette tâche consiste à séparer les données d’entrée en différents groupes en fonction de leur structure ou de leurs similarités. Contrairement aux tâches de classification, les groupes ne sont pas connus par avance. Dans cette catégorie, il est possible de citer les algorithmes des K-moyennes ou de clustering hiérarchique.
— Distribution de densité : Cette tâche consiste à trouver ou capturer la distribution (inconnue) des données en entrée. L’un des exemples le plus récent est le modèle des réseaux antagonistes génératifs [39] que nous verrons en détails au cours de ce document.
— Réduction de la dimensionnalité : Cette tâche consiste à compresser les données d’entrée (par exemple, représentées dans Rn) sur un espace de représentation plus petit (par exemple, Rm avec n >> m). Outre le simple gain en terme de place, cette réduction est également intéressante pour représenter les données. Réduire la dimensionnalité permet d’éviter les problématiques liées à la « malédiction de la dimension ». Cette malédiction fait référence aux problématiques que l’on rencontre sur des données de grandes dimensions. Par exemple, la recherche de plus proches voisins obtient de très mauvais résultats sur des données avec beaucoup de dimensions [11]. Un exemple intéressant de réduction de dimension est le modèle du Word2Vec [77], capable de représenter des mots, par des vecteurs denses de quelques centaines de dimensions. Cette représentation a tendance à rapprocher les mots avec des sens proches les uns des autres. Cette liste des tâches possibles en apprentissage n’est pas exhaustive. Nous n’abordons pas le cas, un peu particulier, de l’apprentissage par renforcement [57]. De même, il est possible de trouver des cas d’apprentissage dits semi-supervisés, dans lesquels les informations des données ne sont pas complètes [59, 19]. Dans ce chapitre nous allons voir le modèle d’apprentissage des réseaux de neurones profonds. Celui-ci est utilisé pour de nombreuses tâches différentes de nos jours, qu’elles soient supervisées ou non.

Les méthodes de second ordre

                 La descente de gradient est une méthode dite de premier ordre, c’est-à-dire qu’elle optimise les paramètres d’une fonction en utilisant sa dérivée première. Il existe d’autres méthodes d’optimisation tel que la méthode de Newton qui utilise la dérivée seconde de la fonction à minimiser afin de trouver un extremum. Le calcul de la Hessienne, ou son approximation demande de calculer la matrice des dérivées partielles secondes ce qui correspond à une matrice de taille n × n à chaque itération (avec n le nombre de paramètres du réseau de neurones). Dans le cas de réseaux de neurones modernes, nous rappelons que n peut être de l’ordre de 106 voir 107. Ces techniques sont efficaces mais nécessitent d’approximer la Hessienne par différentes méthodes pour pouvoir fonctionner sur des réseaux de neurones classiques. Actuellement, elles sont rarement utilisées dans l’apprentissage de réseaux de neurones car d’autres méthodes se sont montrées tout aussi efficaces.

Normalisation par batch

                      La technique de normalisation par batch a été proposée en 2015 par S. Ioffe et al. [54]. Le but est de contourner le problème lié à l’apprentissage de successions de couches dépendantes les unes des autres. Lorsqu’une couche l est modifiée lors de l’apprentissage, la représentation intermédiaire des données en entrée de la couche l+1 se retrouve modifiée et donc celle-ci doit ré-apprendre ses paramètres en fonction de cette nouvelle représentation. Une solution pour réduire les perturbations dues à ce changement de représentation intermédiaire en entrée d’une couche consiste à normaliser l’activation de chaque neurone d’une couche suivant l’activation de celui-ci sur tout un batch. Une fois l’activation des neurones normalisée, celle-ci est « dénormalisée » à l’aide de deux variables µi, βi pour chaque neurone, que le réseau doit apprendre en plus. Cette dénormalisation est nécessaire pour garder la capacité de représentation du réseau de neurones. Cette méthode a pour effet de rendre l’apprentissage plus stable vis-à-vis de l’initialisation du réseau de neurones profond et le taux d’apprentissage choisi (celui-ci peut donc être plus important). La normalisation par batch est maintenant utilisée dans une grande partie des réseaux de neurones de l’état de l’art.

Collaboration pour l’apprentissage d’un réseau de neurones profond

                    La motivation de nos travaux consiste en l’apprentissage d’un réseau de neurones profond à l’aide des ressources fournies par de nombreux participants. Dans cette « application », nous supposons un service permis par un réseau de neurones profond, comme par exemple, un assistant vocal personnel tel que Alexa ou Siri. Afin de construire le modèle nécessaire à ce service, nous proposons aux futurs utilisateurs de participer à l’apprentissage de celui-ci. Pour cela, ils mettent à disposition leur(s) machine(s) ainsi que leurs données pour servir de base à l’apprentissage. Plus précisément, les données (par exemple, des requêtes vocales) sont stockées et mises à disposition sur ces machines. Ces dernières se chargent d’en extraire les connaissances via une étape d’apprentissage (c’est-à-dire, une descente de gradient comme expliqué dans la Section 1.2.2) et partagent ces connaissances entre elles à travers Internet. L’avantage de ce type de collaboration est de tirer partie des machines participantes lorsqu’elles ne sont pas (ou peu) utilisées. De plus, il n’est plus nécessaire de fabriquer et de réunir une grande base de données dans un datacenter puisque le modèle utilise les données présentes sur ces machines. Enfin, l’utilisateur peut avoir l’assurance que ses données, utiles à l’apprentissage, restent sur sa machine. Une fois l’apprentissage fini, il peut profiter du service apporté par le réseau de neurones profond. Ce type de travail collaboratif a été expérimenté notamment avec le projet SETI @home 1, dans lequel les participants mettent à disposition leur ordinateur afin d’analyser des petits bouts de séquences d’enregistrements réalisées par un radiotélescope à Puerto Rico. Le but de cette analyse était de trouver des fréquences prouvant l’existence de signes de vie en dehors de la terre. Bien qu’aucune vie extra-terrestre n’ait été détéctée, le projet a permis de mettre en évidence les capacités d’un travail collaboratif avec un grand nombre de participants. En effet, plus de 100 000 internautes actifs ont participé à ce projet. De nombreux autres projets similaires ont également vu le jour avec des buts différents. Plus récemment, en 2016, les ingénieurs de recherche de Google ont proposé une solution appelée Federated Learning 2 afin de mettre en commun l’apprentissage d’un réseau de neurones profond effectué sur les machines de ses utilisateurs. Ils expérimentent actuellement cette méthode avec l’application GBoard sur Android afin de faire des propositions de requêtes automatiques. Nous présenterons cette méthode plus en détail à la fin de ce chapitre. Les machines que nous considérons lors de la collaboration peuvent aussi bien être des téléphones mobiles, des tablettes connectées, des ordinateurs personnels ou bien même des gateways ou des set-top box. Il est évident qu’en terme de puissance, ces machines sont bien plus limitées que les ressources disponibles à l’intérieur d’un datacenter. Par exemple, il n’est pas envisageable de supposer que chacune dispose d’une carte graphique. De plus, les données contenues sur ces machines correspondent aux données d’un seul utilisateur (ou d’une famille). La variété et la quantité de données sur une unique machine ne sont pas suffisantes pour l’apprentissage d’un modèle tel qu’un réseau de neurones profond. Il est donc nécessaire que l’apprentissage soit partagé par de nombreuses machines d’utilisateurs. Cela permet de mettre en commun les connaissances tirées d’un plus grand nombre de données sans partager directement ces données. Le réseau de neurones profond obtenu à la fin de l’apprentissage devrait donc être capable d’avoir une très bonne capacité de généralisation. Nous allons voir dans la section suivante en quoi ce type de collaboration se rapporte aux problématiques bien connues des systèmes distribués.

Parallélisme du modèle

                   Le parallélisme du modèle consiste à diviser la charge de calcul pour l’inférence et la rétropropagation du réseau de neurones. Il existe plusieurs granularités possibles pour partager le réseau de neurones sur différentes machines :
— Il est possible de répartir les différentes couches sur les agents disponibles. Cette solution permet notamment de pipeliner l’exécution du réseau de neurones lorsque plusieurs données sont calculées les unes après les autres (comme c’est le cas dans la descente de gradient avec mini-batch).
— Avec un niveau de granularité plus fin, il est possible de diviser les neurones présents sur chaque couche entre les agents. Dans le cas des CNN, les neurones peuvent être répartis selon plusieurs dimensions : la hauteur, la largeur ou les canaux (voir Figure 2.1).
— De manière encore plus fine, il est possible de partager chaque opération matricielle du réseau de neurones de manière indépendante. Une couche de neurones peut nécessiter plusieurs opérations différentes ce qui permet de répartir encore plus finement la charge sur chaque agent.
Il existe différents travaux [111] qui se sont intéressés à la recherche de la répartition optimale du modèle sur un ensemble d’agents. Le parallélisme du modèle a pour avantage d’accélérer la vitesse d’inférence et de rétropropagation du réseau de neurones profond mais également de répartir la charge de mémoire nécessaire pour contenir toutes ces opérations. Cette répartition de la mémoire est particulièrement utile dans le cas où celle-ci est limitée pour les différents agents (comme dans le cas des GPUs). Le parallélisme du modèle nécessite beaucoup de communications entre les agents. Même si certaines architectures de réseaux de neurones ont parfois été prévues pour limiter ces communications, il est généralement nécessaire d’avoir l’activation des neurones d’une couche pour calculer la suivante. De plus, les données, qu’elles soient sous forme brute ou sous forme d’activation de neurones à l’intérieur des couches, sont accessibles en partie à plusieurs machines (ou GPUs). Ceci ne permet pas de répondre aux problématiques de préservation de la vie privée évoquées en Section 2.2.

Architecture avec une mémoire partagée

                Une version de descente de gradient asynchrone a été proposée dans les travaux de [89]. Dans ce modèle, plusieurs agents (des processeurs) ont en commun une mémoire. Les auteurs ont montré que chaque processeur peut faire un calcul de gradients sur un mini-batch différent en parallèle et appliquer la mise à jour des paramètres sans synchronisation (c’est-à-dire, sans blocage au niveau de la lecture et de l’écriture des paramètres). Cette absence de blocage a pour effet de permettre l’écrasement de variables lors d’une écriture concurrente sur la mémoire partagée (voir une illustration sur la Figure 2.3). Cependant ce phénomène a un impact relativement faible sur l’apprentissage du fait que les modifications faites à chaque itération sont généralement parcimonieuses, c’est-à-dire, que le gradient calculé est important pour quelques paramètres du modèle et très faible pour tous les autres lors du calcul d’un gradient sur un minibatch. Les paramètres concernés par une modification dépendent beaucoup des données contenues dans le batch Xt de l’itération t. Cette parcimonie réduit considérablement les problèmes dus à l’écrasement d’écriture lors de la mise-à-jour des paramètres. Cette architecture est décrite dans la Figure 2.4. Bien qu’elle ne permette pas de répondre à des problématiques de système distribué, cette architecture montre la tolérance de l’apprentissage des réseaux de neurones profonds face à des opérations concurrentes asynchrones.

Réduire le trafic entrant au niveau du serveur

                   Le contexte d’apprentissage de réseau de neurones collaboratif avec de nombreux participants entraîne des difficultés techniques. L’une d’entre elles est clairement la bande-passante nécessaire à l’apprentissage entre les agents et le serveur de paramètres. Plus précisément, le trafic qui provient des agents et arrive sur le serveur central. Il y a deux raisons à cela :
— Le dimensionnement des serveurs dans le cloud est souvent directement lié aux capacités de réceptions et de traitements souhaitées (voir par exemple, Amazon Kinesis, dont le prix dépend de la quantité de données à réceptionner par seconde). Afin de proposer une solution peu coûteuse, il est donc nécessaire de réduire au maximum le trafic entrant du serveur de paramètres.
— La tâche d’apprentissage doit rester une tâche de fond pour les machines participantes. Leur débit sortant étant généralement limité, il n’est pas raisonnable de le saturer en permanence afin d’envoyer des informations au serveur de paramètres.
Il est donc important de mesurer le trafic entrant au niveau du serveur de paramètres pour avoir un point de vue global du trafic montant généré par l’apprentissage sur les agents. Nous avons illustré cette contrainte imposée par le modèle, avec une expérience de 200 agents et un serveur de paramètres qui ont pour but d’apprendre un classifieur simple sur la base de données MNIST [67]. Le trafic entrant sur le serveur de paramètres est reporté sur la Figure 3.3. Dans cette expérience, la quantitié de donnée nécessaire pour apprendre le modèle à un niveau de précision supérieur à 96% (c’est-à-dire, plus de 96% des données de l’ensemble de test sont bien classifiées) est de près de 400Go. Ce trafic entrant est beaucoup trop important comparé à la taille de la base de données d’apprentissage MNIST (environ quelques centaines de Mo). Compression Shokri et al. [98] proposent une mécanique de compression qui permet de réduire la taille des gradients envoyés par les agents vers le serveur de paramètres, appelée la descente de gradients sélective. Une fois le gradient calculé par un agent sur un batch de données, le principe consiste à sélectionner seulement une partie des paramètres sur laquelle le gradient sera appliqué. La sélection peut se faire de manière aléatoire ou en choisissant les valeurs du gradient les plus importantes. Le taux de compression ainsi gagné est représenté par une valeur fixe c ∈ (0, 1]. Leurs expérimentations montrent que la précision du modèle appris en utilisant la sélection de gradients reste très proche du modèle appris par une descente de gradient classique. Dans leurs exemples, un réseau de neurones profond voit sa précision finale passer de 98, 10% à 97, 07% sur le dataset MNIST avec une sélection c = 0.01. Le trafic total entrant au niveau du serveur de paramètres peut être calculé analytiquement. Dans le cas du gradient sélectif, le trafic entrant du serveur de paramètres est de l’ordre de I × |θ| × c par agent (avec I le nombre total d’itérations). Le point important à mesurer est la précision du modèle au cours de l’apprentissage. Nous avons vu que cette précision n’était pas linéaire par rapport au nombre d’itérations, par conséquent, elle n’est pas linéaire par rapport au trafic entrant (voir Figure 3.3). C’est pourquoi il est important de mesurer la précision par rapport au trafic expérimentalement. Comme nous allons le voir dans la Section 3.3, l’approche de Shokri et al. [98] dans notre contexte permet de réduire la taille des modifications envoyées par les agents au coût d’une perte en précision du modèle. Cette dégradation du modèle est problématique car les réseaux de neurones profonds ont la capacité de pouvoir être très précis. Afin de réduire la taille des gradients envoyés par les agents, tout en maintenant une bonne précision lors de l’apprentissage, nous introduisons l’algorithme d’AdaComp dans la section suivante.

Table des matières

1 État de l’art sur l’apprentissage profond 
1.1 L’apprentissage automatique
1.2 Les réseaux de neurones
1.2.1 Le modèle du perceptron
1.2.2 Le perceptron multi-couches
1.2.3 Apprendre avec la rétro-propagation
1.2.4 Convergence de l’apprentissage
1.2.5 Alternatives à la descente de gradient
1.3 Les réseaux de neurones profonds 
1.3.1 L’intérêt des architectures profondes
1.3.2 Réseaux de neurones convolutifs
1.3.3 Réseaux de neurones récurrents
1.3.4 Techniques avancées pour améliorer l’apprentissage
1.3.5 Réseaux de neurones non supervisés
1.4 Conclusion 
2 Vers un apprentissage profond sur des systèmes distribués 
2.1 Collaboration pour l’apprentissage d’un réseau de neurones profond 
2.2 Systèmes distribués et contraintes
2.3 Apprentissage profond distribué 
2.3.1 Différents types de parallélisme
2.3.2 Les architectures proposées
2.4 Conclusion et méthodes existantes adaptées aux systèmes distribués 
3 Descente de gradient asynchrone avec AdaComp 
3.1 Modèle du serveur de paramètres dans le cas des systèmes distribués 
3.1.1 Gestion des gradients avec délai
3.1.2 Réduire le trafic entrant au niveau du serveur
3.2 La méthode d’AdaComp 
3.3 Expériences 
3.3.1 Plateforme expérimentale
3.3.2 Configuration expérimentale et compétiteurs
3.3.3 Précision du modèle
3.3.4 AdaComp face aux pannes
3.3.5 AdaComp dans un contexte d’agents hétérogènes
3.4 Discussion sur AdaComp et les travaux connexes
3.5 Conclusion 
4 Protocole de rumeur pour l’apprentissage des réseaux antagonistes génératifs 
4.1 Apprentissage collaboratif d’un GAN 
4.1.1 Modèle du GAN
4.1.2 GAN et systèmes distribués
4.2 FL-GAN vs Gossip GAN : une comparaison expérimentale
4.2.1 Configuration des expériences
4.2.2 Passage à l’échelle et performances
4.3 Conclusion 
5 MD-GAN : GAN avec de multiples discriminateurs pour des bases de données distribuées 
5.1 Contexte distribué
5.2 La méthode du MD-GAN
5.2.1 Raisonnement
5.2.2 Procédure d’apprentissage du générateur
5.2.3 Procédure d’apprentissage des discriminateurs
5.2.4 Caractéristiques de MD-GAN
5.3 Évaluation expérimentale 
5.3.1 Configuration expérimentale
5.3.2 Résultats des expériences
5.4 MD-GAN et les travaux connexes 
5.5 Perspectives et conclusion sur MD-GAN 
Conclusion

Télécharger le rapport complet