© Dominique Pothier, 2021

Réseaux convolutifs à politiques

Mémoire

Dominique Pothier

Maîtrise en informatique - avec mémoire

Maître ès sciences (M. Sc.)

Québec, Canada

Réseaux convolutifs à politiques

Mémoire

Dominique Pothier

Sous la direction de:

Luc Lamontagne, directeur de recherche

Résumé

Malgré leurs excellentes performances, les exigences élevées des réseaux de neurones artificielsen terme de volume de données et de puissance de calcul limitent leur adoption dans plusieursdomaines. C’est pourquoi il reste important de développer de nouvelles architectures moinsvoraces.

Ce mémoire cherche à produire une architecture plus flexible et moins vorace en s’appuyantsur la théorie de l’apprentissage par renforcement. En considérant le réseau comme un agentsuivant une politique, on réalise que cette politique est beaucoup plus rigide que celle sui-vie habituellement par les agents d’apprentissage par renforcement. Nous posons l’hypothèsequ’une architecture capable de formuler une politique plus flexible pourrait atteindre des per-formances similaires tout en limitant son utilisation de ressources. L’architecture que nousproposons s’inspire de la recherche faite en prédiction de paramètres, particulièrement del’architecture hypernetwork, que nous utilisons comme base de référence.

Nos résultats montrent que l’apprentissage d’une politique dynamique aussi performante queles politiques statiques suivies par les réseaux conventionnels n’est pas une tâche triviale. Nosmeilleurs résultats indiquent une diminution du nombre de paramètres de 33%, une diminutiondes calculs de 12% au prix d’une baisse de l’exactitude des prédictions de 2%. Malgré cesrésultats, nous croyons que notre architecture est un point de départ pouvant être amélioréde plusieurs manières que nous explorons rapidement en conclusion.

ii

Abstract

Despite their excellent performances, artificial neural networks high demand of both dataand computational power limit their adoption in many domains. Developing less demandingarchitecture thus remain an important endeavor.

This thesis seeks to produce a more flexible and less resource-intensive architecture by usingreinforcement learning theory. When considering a network as an agent instead of a functionapproximator, one realize that the implicit policy followed by popular feedforward networksis extremely simple. We hypothesize that an architecture able to learn a more flexible policycould reach similar performances while reducing its resource footprint. The architecture wepropose is inspired by research done in weight prediction, particularly by the hypernetworkarchitecture, which we use as a baseline model.

Our results show that learning a dynamic policy achieving similar results to the static policiesof conventional networks is not a trivial task. Our proposed architecture succeeds in limitingits parameter space by 20%, but does so at the cost of a 24% computation increase and loss of5% accuracy. Despite those results, we believe that this architecture provides a baseline thatcan be improved in multiple ways that we describe in the conclusion.

iii

Table des matières

Résumé ii

Abstract iii

Table des matières iv

Liste des tableaux vi

Liste des figures vii

Introduction 1

1 Réseaux de neurones artificiels 31.1 Apprentissage automatique . . . . . . . . . . . . . . . . . . . . . . . . . . . 31.2 Apprentissage supervisé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41.3 Réseaux de neurones artificiels . . . . . . . . . . . . . . . . . . . . . . . . . 51.4 Algorithme d’apprentissage . . . . . . . . . . . . . . . . . . . . . . . . . . . 91.5 Architectures avancées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

2 Interprétation agent des ANNs 292.1 Le problème de l’apprentissage par renforcement . . . . . . . . . . . . . . . 302.2 Agent ANN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 362.3 Résumé du chapitre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41

3 CNN à politique 423.1 Efficacité des ANNs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 433.2 PBCNN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 493.3 Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54

4 Expérimentations 554.1 Tâche et protocole . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 554.2 Base de comparaison . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 564.3 Protocole . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 574.4 PBCNN markovien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 584.5 PBCNN non markovien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 584.6 Comparaison à la base de référence . . . . . . . . . . . . . . . . . . . . . . . 60

Discussion et conclusion 63

iv

Bibliographie 69

v

Liste des tableaux

4.1 PBCNN markovien : Performances et ressources en fonction de la méthode denormalisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58

4.2 Phase 1 : Résultats pour différentes valeurs de J et 1 cellule GRU . . . . . . . . 594.3 Phase 2 : Résultats pour 1 cellule RNN de différents types avec J = 4 . . . . . 594.4 Phase 3 : Résultats pour un nombre variable de cellules GRUs avec J = 4 . . . 604.5 Performances des différents réseaux à taille pleine et sur ensemble d’entraîne-

ment complet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 604.6 Performances des différents réseaux à taille réduite et sur ensemble d’entraîne-

ment complet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 614.7 Performances des différents réseaux à taille complète et sur ensemble d’entraî-

nement complet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 614.8 Performances des différents réseaux à taille complète et sur 75 % de l’ensemble

d’entraînement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 624.9 Performances des différents réseaux à taille complète et sur 50 % de l’ensemble

d’entraînement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 624.10 Performances des différents réseaux à taille complète et sur 25 % de l’ensemble

d’entraînement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62

vi

Liste des figures

1.1 Architecture MLP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51.2 Problème du ou exclusif résolu par un ANN . . . . . . . . . . . . . . . . . . . . 81.3 Unité d’activation j de la couche n d’un CNN . . . . . . . . . . . . . . . . . . . 191.4 Champs perceptif après deux couches avec des filtres de taille 3 . . . . . . . . . 201.5 Réseau résiduel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221.6 RNNs à porte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 251.7 Architecture d’un RNN multicouche . . . . . . . . . . . . . . . . . . . . . . . . 28

2.1 Boucle de résolution d’une tâche en apprentissage par renforcement . . . . . . . 312.2 Réseau supervisé présenté comme un problème RL . . . . . . . . . . . . . . . . 39

3.1 Architecture de l’hypernetwork statique . . . . . . . . . . . . . . . . . . . . . . 463.2 Concaténation des θn,i pour former θn. . . . . . . . . . . . . . . . . . . . . . . . 473.3 Application de p à en,i pour obtenir θn,i . . . . . . . . . . . . . . . . . . . . . . 473.4 Architecture du PBCNN markovien . . . . . . . . . . . . . . . . . . . . . . . . 503.5 Architecture du PBCNN non markovien . . . . . . . . . . . . . . . . . . . . . . 52

vii

Introduction

Les progrès récents en intelligence artificielle sont dus en grande partie à l’apprentissage auto-matique (machine learning, ML), un sous-domaine cherchant à faire des prédictions à partird’une expérience préalable. Le ML est utilisé aujourd’hui pour résoudre un grand nombre detâches : traduction automatique, reconnaissance faciale, simulations boursières, etc.

La discipline de l’apprentissage automatique est généralement divisée en trois catégories enfonction des caractéristiques des problèmes auxquels elles s’attaquent. L’apprentissage nonsupervisé apprend à regrouper les instances d’un phénomène en fonction de leurs caractéris-tiques communes. L’apprentissage supervisé apprend à reproduire un comportement optimaldéfini par un ensemble de paires contenant une instance du problème à résoudre et la réponseoptimale attendue. L’apprentissage par renforcement apprend à identifier et reproduire uncomportement optimal en interagissant avec un environnement. Chacune de ces trois sous-disciplines a développé une variété d’algorithmes pour mener à bien les tâches qui leur sontassociées.

Parmi les algorithmes de ML, ceux basés sur les réseaux de neurones artificiels (artificialneural network, ANN) ont significativement augmenté en importance ces dernières années.Au cours de la dernière décennie, l’augmentation de la quantité de données disponibles pourl’entraînement, l’apparition de cartes graphiques multifonctions et une poignée d’innovationsalgorithmiques clés, comme la fonction d’activation relu (Glorot et al. (2011)) et les connexionsrésiduelles (He et al. (2016)) ont permis à cette approche classique d’apprentissage automa-tique de devenir la principale source d’avancées dans le domaine. Même s’ils ont d’abord étédéveloppé pour résoudre des problèmes supervisés, ils ont ensuite été utilisé avec succès surdes tâches d’apprentissage par renforcement (Mnih et al. (2013)).

Les ANNs se sont donc distingués comme une approche capable de tirer profit de l’accroisse-ment des ressources disponibles, autant en termes de calcul que de données. Malheureusement,cette voracité forme un frein à leur adoption. La quantité de données requise à leur entraîne-ment peut être prohibitive pour de plus petites organisations et la consommation de ressourcesinformatiques nécessaire à l’entraînement et à l’inférence ralenti les cycles de développementet limite les possibilités de déploiement dans des contextes mobiles ou embarqués. C’est pour-quoi la diminution des ressources requises par les ANNs forme un champ de recherche actif,

1

comprenant des approches comme la condensation des réseaux et la prédiction de poids.

Notre recherche s’inscrit dans cette tendance cherchant à diminuer la voracité des ANNs, parti-culièrement au niveau des ressources informatiques. Nous proposons une nouvelle architectured’ANN : les réseaux à politique (Policy-Based Artificial Neural Networks, PBANN). Cette ar-chitecture se base sur l’hypothèse que les ANNs apprenant une tâche supervisée forment unecatégorie particulière de tâches d’apprentissage par renforcement. Si cette hypothèse est véri-fiée, le comportement des ANNs est gouverné par une politique. Or, cette politique semble êtrebeaucoup moins flexible que celles typiquement utilisées en apprentissage par renforcement.Les PBANNs cherchent à doter les ANNs d’une politique plus flexible. Cette politique utilisela prédiction de poids d’une façon similaire à celle utilisée par Ha et al. (2017). Nous espéronsque l’utilisation d’une telle politique permettra de compresser encore davantage l’espace deparamètres des ANNs et d’augmenter ainsi leur efficacité.

Nous avons donc trois objectifs de recherche. Premièrement, nous voulons confirmer théorique-ment notre hypothèse que les ANNs supervisés forment une catégorie particulière de problèmesd’apprentissage par renforcement en comparant le formalisme et les équations des deux dis-ciplines. Deuxièmement, nous voulons confirmer que les PBANNs forment une architecturefonctionnelle, c’est à dire qu’il est possible de les entraîner par descente du gradient et d’ob-tenir des résultats acceptables. Finalement, nous voulons mesurer la capacité des PBANNs àaugmenter l’efficacité des réseaux, c’est à dire leur capacité à compresser l’espace de paramètrestout en conservant les mêmes performances.

L’organisation du mémoire est comme suit :

1. Chapitre 1 : Présentation des notions fondamentales d’apprentissage automatique dansun contexte de réseau de neurones oeuvrant sur des tâches d’apprentissage supervisé.

2. Chapitre 2 : Présentation du problème de l’apprentissage par renforcement. Démonstra-tion de l’équivalence entre l’entraînement d’ANNs supervisés et d’agents d’apprentissagepar renforcement.

3. Chapitre 3 : Présentation des PBANNs, une nouvelle architecture utilisant la prédictionde poids pour rendre explicite et plus flexible la politique implicite des ANNs.

4. Chapitre 4 : Présentation de notre protocole d’expérimentation et de nos résultats.

2

Chapitre 1

Réseaux de neurones artificiels

Ce chapitre familiarise le lecteur avec les réseaux de neurones artificiels. Il commence pardévelopper une compréhension intuitive du fonctionnement de ces réseaux, puis explique lesalgorithmes permettant de les entraîner. Il termine avec une présentation des architecturesd’ANNs les plus courantes.

1.1 Apprentissage automatique

Lorsqu’un ordinateur résout un problème, il le fait par le biais d’un algorithme, c’est à direun processus formel qui permet la résolution systématique d’une tâche. La distinction entrel’apprentissage automatique et les approches informatiques traditionnelles se trouvent dansl’objectif de l’algorithme développé par l’informaticien.

Dans la programmation traditionnelle, l’algorithme décrit directement la façon dont le pro-blème doit être résolu. Cette manière de faire est appropriée pour des tâches dont la résolutiondépend de règles connues, claires et immuables. Par exemple, même si elles sont nombreuses,les règles qui régissent une tâche de comptabilité sont prédéterminées et doivent être suiviesà la lettre. La programmation traditionnelle est donc particulièrement adaptée à ce genre detâches.

Certains problèmes ont des règles moins bien définies. Par exemple, il est très difficile denommer, avec la précision nécessaire à la construction d’un algorithme, ce qui fait qu’uneimage représente un chat plutôt qu’un chien. L’apprentissage automatique cherche à résoudreces problèmes en définissant deux composantes : le modèle et l’algorithme d’apprentissage.Le modèle est une forme de méta-algorithme : une famille de solutions dont les détails sontcontrôlés par un ensemble de paramètres. Le rôle de l’algorithme d’apprentissage est de dé-terminer les valeurs que doivent prendre ces paramètres pour maximiser la performance dumodèle sur la tâche.

Sous ce paradigme, le rôle de l’informaticien n’est plus d’établir une procédure pour résoudre le

3

problème. Son rôle est plutôt de circonscrire un ensemble de solutions possibles, puis d’établirla procédure d’apprentissage permettant de choisir parmi les possibilités grâce à un ensemblede données décrivant le problème.

On reconnaît généralement trois types d’apprentissage automatique, en fonction de l’informa-tion à laquelle l’algorithme d’apprentissage a accès :

� Supervisé : L’algorithme dispose de données d’entraînement contenant les caractéris-tiques de plusieurs instances du phénomène d’intérêt ainsi que la réponse attendue dumodèle pour chaque instance.

� Non-supervisé : L’algorithme dispose de données d’entraînement contenant unique-ment les caractéristiques d’instances, sans indication de la réponse attendue du modèle.

� Par renforcement : L’algorithme n’a pas accès à des paires instance-réponse atten-dues, mais doit les apprendre à partir d’un environnement qui décrit la tâche à réaliser.

Ce mémoire s’intéresse aux similitudes entre l’apprentissage supervisé et l’apprentissage parrenforcement. Ce chapitre présente les notions d’apprentissage supervisé nécessaire à la com-préhension du reste du mémoire. Le chapitre 2 explique les notions de base de l’apprentissagepar renforcement et s’en sert pour montrer que l’apprentissage supervisé peut, dans certainescirconstances, être considéré comme une forme particulière d’apprentissage par renforcement.

1.2 Apprentissage supervisé

Le problème supervisé est défini par un ensemble de paires d’entraînement. Chaque paire estcomposée de x, la représentation vectorielle d’une instance du problème, et de y, la solutionattendue, c’est à dire la valeur que nous voulons que l’algorithme produise dans cette situation.La tâche de l’algorithme d’apprentissage est de produire un modèle reproduisant le mieuxpossible les réponses attendues.

On peut interpréter formellement le problème de deux façons. On peut considérer les élémentsde la paire comme étant la valeur d’entrée et de sortie d’une fonction inconnue. Le modèledevient alors une approximation de cette fonction et l’algorithme d’apprentissage doit mini-miser l’erreur de l’approximation sur les points connues de la fonction que sont les exemplesd’entraînement.

On peut aussi utiliser un point de vue statistique et considérer que la tâche est une distribu-tion inconnue de valeurs d’entrées et de sorties. Les exemples deviennent des échantillons decette distribution prélevés de façon indépendante et identiquement distribuée. L’algorithmed’apprentissage cherche alors à maximiser la vraisemblance du modèle, c’est à dire P (yi|Xi, θ)

où xi sont les valeurs d’entrées des échantillons, yi les valeurs de sorties et θ les paramètresdu modèle.

4

Ce cadre permet la réalisation d’une variété de tâches. Par exemple :

� Classification : Transformer un ensemble de caractéristiques en un entier appartenantà une liste fermée. Cet entier représente une classe d’objet.

— Apprendre à reconnaître la race d’un chien à partir d’une image.

— Indiquer si un texte est une dissertation philosophique ou une nouvelle de sport.

� Régression : Transformer un ensemble de caractéristique en un nombre réel.

— Prédire la valeur d’une maison à partir de son nombre de pièces, sa localisation etl’évolution générale du marché.

� Transduction : Transformer un tenseur en un autre tenseur.

— Traduire une phrase d’une langue à une autre.

— Produire une description textuelle à partir d’une image.

1.3 Réseaux de neurones artificiels

Les réseaux de neurones forment une vaste catégorie de modèles unifiés par deux concepts :

� L’utilisation d’unités d’activations pour combiner l’information disponible en de nou-velles caractéristiques de l’instance.

� L’organisation des unités d’activations en couches appliquées successivement pour pro-duire des caractéristiques de plus en plus abstraites.

L’organisation des couches et de leurs unités d’activation définissent l’architecture du réseau.Dans cette section, nous expliquons les principes fondamentaux des ANNs à partir de l’archi-tecture la plus simple : le perceptron multicouches (multi-layer perceptron, MLP). La section1.5 discute d’architectures plus complexes couramment utilisées dans la littérature.

(a) Propagation avant (b) Couche (c) Unité d’activation pleinementconnectée

Figure 1.1 – Architecture MLP

5

Un MLP est définit par N couches, avec n ∈ N étant l’indice d’une couche au sein du réseau.Chaque couche est composée d’un nombre variable de jn unités d’activations un,j . Chaquecouche prend en entrée la valeur de sortie de la couche précédente hn−1 et produit en sortiehn (fig. 1.1a). Pour simplifier la notation, nous considérons que h0 = x et que hN = y, mêmesi la représentation d’entrée et la sortie du réseau ne sont habituellement pas qualifiées d’étatscachés. Les réseaux qui sont structurés autour d’une telle succession de couches sont appelésdes réseaux à propagation avant (feedforward networks).

Chaque unité d’activation un,j de la couche n est composée d’un poids par dimension duvecteur hn−1 et d’un biais. Les poids et le biais sont utilisés pour combiner linéairement lesdimensions de hn−1. Le résultat est ensuite rectifié par une fonction d’activation g (eq. 1.1, fig.1.1c). Une grande variété de fonctions peuvent servir de fonctions d’activation, mais les pluscourantes sont les fonctions relu, sigmoïde, softmax, et tangente hyperbolique (1.2). Les valeursdes poids et du biais sont considérés comme des paramètres du réseau et sont sélectionnés parl’algorithme d’apprentissage.

y = g(n∑i

wi ∗ xi + b) (1.1)

Relu(x) = max(0, x)

Sigmoïde(x) =1

1 + e−x

Softmax(x)i =exi∑Kj=1 e

xjpour i = 1, ..., K et avec x = (x1, ... , xK) ∈ RK

Tanh(x) =ex − e−x

ex + e−x

(1.2)

Chaque uj prend en entrée le même vecteur hn−1, mais produisent des valeurs de sortie dis-tinctes parce que leurs poids et leur biais sont différents. Les jn valeurs de sortie produites parles unités d’activation sont concaténées pour produire hn (fig. 1.1b). hn peut être obtenu enappliquant séquentiellement l’équation 1.1 pour chaque unité d’activation, mais en pratique,elles sont toutes résolues en parallèle. Mathématiquement, cela prend la forme d’une multi-plication matricielle entre Wn, une matrice en jn rangées contenant chacune les In poids dechaque unité d’activation, par ~hn−1 et le vecteur-colonne contenant l’état caché défini en Indimensions (eq. 1.3).

hn = g(Wnhn−1 + bn) (1.3)

6

Nous complétons cette présentation générale des MLPs par deux sous-sections expliquant dif-férents concepts s’appliquant aux ANNs. L’importance des fonctions d’activation non-linéairesest expliquée à la sous-section 1.3.1. La sous-section 1.3.2 explique comment les couches ex-traient l’information nécessaire à la résolution d’une tâche.

1.3.1 Fonctions d’activation et non-linéarité

L’application successive des couches du réseau peut être décrite de façon récursive (eq. 1.4).Cette formulation montre que tous les hn après h1 sont obtenus par une fonction composée.

hn = Ln(Ln−1(hn−2)) (1.4)

Sans fonction d’activation, chaque Ln est une transformation linéaire. Or, la compositionde deux transformations linéaires L1 et L2 est toujours équivalente à une certaine troisièmetransformation L3. Ajouter des couches à un tel réseau est donc inutile : il sera toujourspossible de résumer la transformation faite par le réseau entier en une seule couche.

Cette équivalence signifie également qu’il est impossible pour tout réseau sans fonction d’ac-tivation, indépendamment de sa profondeur, de modéliser des relations non-linéaires. Or, ungrand nombre de phénomènes ne sont explicables que par des relations non-linéaires. La fonc-tion "ou exclusif", par exemple, est une fonction simple, mais non-linéairement séparable.

La non-linéarité ajoutée par la fonction d’activation résout ce problème. Plus un réseau doté defonctions d’activation est profond, plus il est en mesure de modéliser des relations non-linéairescomplexes. C’est pourquoi la fonction d’activation est au coeur de l’efficacité des ANNs.

La figure 1.2 montre comment un réseau de deux couches de deux unités peut résoudre leproblème "ou exclusif" s’il utilise la relu pour inclure une non-linéarité entre les deux couches.Sans cette non-linéarité, le réseau serait incapable de résoudre le problème, indépendammentde son nombre de couches et d’unités d’activation.

1.3.2 Extraction de caractéristiques

La plupart des modèles d’apprentissage automatique demandent à leur concepteur d’organiserl’information afin d’être facilement digestible. Par exemple, une tâche de classification d’imagesera réalisée à partir d’une liste de caractéristiques de haut niveau prédéfinie plutôt que di-rectement à partir des pixels. Pour pouvoir entraîner ces modèles, il faut donc être en mesured’identifier les caractéristiques importantes à la réalisation de la tâche et avoir une façon dedéterminer si ces caractéristiques sont présentes dans une instance du problème. Aucune deces deux tâches n’est triviale.

7

(a) Le problème initial est nonlinéairement séparable

(b) La représentation trouvéepar la couche cachée est linéai-rement séparable

(c) Réseau résolvant le pro-blème

Figure 1.2 – Problème du ou exclusif résolu par un ANN

Dans un ANN, toutes les couches, à l’exception de la dernière, ont pour fonction de condenser,filtrer et organiser l’information disponible dans les données d’entrée afin de représenter leproblème sous une forme résoluble par la dernière couche. Cette capacité à apprendre conjoin-tement à identifier, reconnaître et utiliser les caractéristiques importantes à la résolution duproblème est la principale raison qui explique la popularité actuelle des réseaux de neurones,parce qu’elle permet aux réseaux de travailler directement sur des données brutes : un ensemblede pixels, une chaîne de caractère, une onde sonore, etc.

Le réseau exprime les caractéristiques du problème à travers une succession d’états cachés :chaque dimension de l’état caché représente une caractéristique. Le mot caractéristique estutilisé ici dans un sens très large. Les caractéristiques identifiées par les réseaux peuventreprésenter absolument n’importe quelle portion du problème et elles ne coïncident pas néces-sairement avec les caractéristiques qu’un humain utiliserait pour résoudre le problème.

À chaque couche, le réseau produit donc un ensemble de nouvelles caractéristiques par l’entre-mise de ces unités d’activation. Celles-ci, en fonction des poids qu’elles accordent à chaque ca-ractéristique de la couche précédente, combinent certains éléments d’information et en ignorentd’autres pour produire une nouvelle caractéristique. Celle-ci devient un raccourci, une façonplus succincte de faire référence à la relation que l’unité d’activation a identifiée. Collective-ment, les unités d’activation de la couche produisent un ensemble de nouveaux raccourcis quicompose l’état caché qui sera analysé par la couche suivante.

Appliqué de couches en couches, ce processus permet au réseau de graduellement éliminerl’information non pertinente à la réalisation de la tâche et de travailler directement sur desrelations complexes existant entre les éléments des données originales. C’est pourquoi on ditque le processus d’extraction des caractéristiques augmente le niveau d’abstraction de la re-présentation.

Par exemple, dans un contexte de vision, une première couche peut apprendre à identifier

8

la présence de lignes en ayant une unité d’activation reconnaissant une séquence horizontalede pixels de même couleur, et une autre reconnaissant une séquence verticale. Une deuxièmecouche ayant accès à ces caractéristiques peut les combiner pour former le concept de coinslà où une ligne verticale rejoint une ligne horizontale. Une troisième couche peut reconnaîtreque quatre coins forment un quadrilatère, et ainsi de suite.

Les couches d’un réseau utilisent donc en alternance l’abstraction et la composition d’infor-mation pour graduellement bâtir la représentation de haut niveau demandée par les autrestypes de modèle. La dernière couche utilise ensuite cette représentation de haut niveau pourréaliser la tâche.

1.4 Algorithme d’apprentissage

La performance des ANNs décrits à la section précédente dépend fortement des valeurs prisespar les paramètres de leurs couches. Nous avons jusqu’à maintenant ignoré le processus selonlequel ces valeurs sont choisies. Cette section corrige cette lacune en s’intéressant au deuxièmeélément d’un système d’apprentissage automatique : l’algorithme d’apprentissage.

1.4.1 Fonction de perte

L’algorithme d’apprentissage cherche à minimiser les erreurs commises par le modèle. Ceserreurs sont mesurées formellement par une fonction de perte f(y, y), ou y est la réponseattendue et y la réponse fournie par le modèle.

On peut définir la fonction de perte d’un grand nombre de façons, mais on utilise générale-ment l’erreur quadratique moyenne (mean square error, MSE) pour les tâches de régressionet l’entropie croisée (cross-entropy) pour les tâches de classification. Ces deux fonctions depertes sont favorisées parce qu’en minimiser la valeur revient à maximiser la vraisemblance dumodèle (Bengio et al., 2017, p.128-131).

La fonction de perte peut influencer le format de la sortie du réseau. Par exemple, la fonctiond’entropie croisée compare deux distributions de probabilités. C’est pourquoi les réseaux declassifications produisent une valeur pour chaque classe et que ces valeurs sont normalisées parla fonction softmax pour pouvoir être interprétées comme des probabilités. Cette distributionest ensuite comparée à celle attendue, qui est généralement 100% pour la véritable classe et0% pour les autres.

Les équations 1.5 décrivent quelques fonctions de perte.

9

MSE(y, y) = (y − y)2

cross-entropy(y, y) = −∑i

yilogyi

perte 0-1(y, y) =

0 y = y

1 y 6= y

(1.5)

Parce que les ANNs sont optimisés par descente du gradient (section 1.4.2), les fonctions depertes utilisées doivent avoir un gradient défini sur l’ensemble de leur domaine. Les fonctionsde pertes qui mesurent une distance entre la réponse attendue et la réponse produite possèdentgénéralement cette propriété. C’est pourquoi elles sont préférées à d’autres fonctions, comme lafonction 0-1, qui se contentent d’indiquer la présence d’une erreur sans en indiquer la gravité.

1.4.2 Descente du gradient et rétropropagation

Parce que y dépend des paramètres θ du réseau, on peut exprimer la perte comme une fonc-tion de ceux-ci : l(y, θ). L’algorithme d’apprentissage cherche les paramètres qui minimisentcette fonction. Le grand nombre de paramètres rend cette optimisation impossible à faire ana-lytiquement. C’est pourquoi on utilise des méthodes d’approximation numériques comme ladescente du gradient.

La descente du gradient (Bengio et al., 2017, p.79-89) est un algorithme itératif. À chaqueitération, la valeur de chaque paramètre du réseau est modifiée en fonction de son gradientpar rapport à la perte. L’amplitude de la modification est déterminée par la multiplicationdu gradient avec le taux d’apprentissage α, un hyperparamètre choisi par le concepteur avantle début de l’entraînement (eq. 1.6). En déplaçant les paramètres en direction opposée augradient de la fonction de perte, l’algorithme converge graduellement vers un minimum localde la fonction qui est atteint lorsque tous les gradients sont approximativement 0. La fonctionde perte d’un ANN n’est jamais convexe, de sorte que nous n’avons pas de garanti que ceminimum local soit la solution globalement optimale. Néanmoins, on observe en pratique quecette absence de garantie d’optimalité n’empêche pas la découverte de paramètres capables debien performer sur la tâche d’entraînement.

θi+1n = θin − α · ∇θn l(y, y) (1.6)

Les fonctions implémentées par les ANNs sont complexes et calculer directement le gradientde chaque paramètre par rapport à la perte n’est pas très pratique : ce calcul serait dépendantde l’architecture du réseau, varierait en fonction de la couche où se trouve le paramètre et

10

parce qu’il doit être répété pour chaque paramètre du réseau, il demanderait des ressourcescomputationnelles considérables.

Pour contourner ce problème, on utilise le théorème de dérivation des fonctions composées. Enconsidérant l’ANN comme une composition de fonctions plus simples, il est possible de calculerle gradient par récursion. On peut par exemple considérer chaque couche comme une sous-fonction, auquel cas l’équation 1.7 montre comment il est possible de calculer récursivementle gradient d’une couche à partir de celui de la suivante. En pratique, on compose la fonctionde façon beaucoup plus granulaire, descendant jusqu’aux opérations arithmétiques de basecomme l’addition ou la multiplication. Cela permet de définir de nouveaux types de coucheset de les agencer dans de nouvelles architectures sans avoir à changer la façon dont le gradientest calculé.

La composition de la fonction est définie formellement par un graphe de calcul où chaquenoeud représente soit une variable de la fonction, soit le résultat d’une opération intermé-diaire. Ce graphe décrit l’ensemble des opérations liant les données d’entrée du réseau x à laperte et inclut au passage tous les paramètres du réseau. Ce graphe peut ensuite être utilisépour calculer le gradient de chaque noeud à partir de celui de ces voisins : remontant de laperte jusqu’à x. On évite ainsi de calculer les gradients plusieurs fois ce qui limite les res-sources computationnelles nécessaires. Parce que cet algorithme formule le calcul du gradienten une chaîne s’étendant de la fin du réseau jusqu’à son début, il est appelé l’algorithme derétropropagation (backpropagation) (Bengio et al., 2017, p.197-217).

∇lθn = ∇θn+1θn · ∇lθn+1 (1.7)

Nous avons jusqu’à maintenant fait comme si l(y, θ) ne dépendait que de θ. Dans les faits, laperte dépend aussi de l’instance x et de la réponse attendue y qui y est associée. Cela dit, parcequ’on ne cherche pas à minimiser la perte sur une instance particulière, mais sur l’ensemblede la distribution des instances, on cherche à minimiser l’espérance de la perte plutôt quela perte elle-même. Parce que nous ne connaissons habituellement pas la distribution exactedu phénomène, nous devons l’estimer à partir de la perte moyenne d’un échantillon commel’ensemble d’entraînement.

L’estimé le plus précis de l’espérance s’obtient en évaluant la perte pour chaque exemple du jeud’entraînement et en en calculant la moyenne. Malheureusement, l’imposante taille des jeuxd’entraînement utilisés en apprentissage profond fait en sorte qu’évaluer la perte sur chaqueexemple peut prendre un temps considérable (Bengio et al., 2017, p.270-272). C’est pourquoiune approche stochastique (Stochastic Gradient Descent, SGD) (Bengio et al., 2017, p.286-288) est souvent utilisée pour accélérer l’entraînement. La SGD utilise un nombre restreintd’instances, appelés collectivement batch, pour estimer l’espérance de perte à chaque étaped’optimisation. L’estimation perd en précision, mais se calcule plus vite, de sorte que plus

11

d’étapes d’optimisation peuvent être faites dans un temps donné. En pratique, ce compromispermet d’obtenir des résultats comparables beaucoup plus rapidement, ce qui explique sapopularité. (backpropagation)(Bengio et al., 2017, p.270-275).

1.4.3 Descente du gradient et fonctions d’activation

Dans une optimisation par descente du gradient, la taille des mises à jour est un facteurcrucial à l’atteinte d’un bon résultat. Si elles sont trop grandes, on risque une oscillation entredifférentes régions de la fonction de perte parce que celle-ci est hautement non-linéaire. Cetteoscillation peut mener à une divergence de l’algorithme. Si elles sont trop petites, un plusgrand nombre d’étapes d’optimisation est nécessaire et le processus devient trop lent.

Le taux d’apprentissage α assure un certain contrôle sur la taille des mises à jour, maislorsqu’on optimise plusieurs variables en même temps, il n’est pas suffisant. Si le gradientdes différentes variables varie considérablement, un taux d’apprentissage adéquat pour unevariable peut être trop grand ou trop petit pour une autre.

C’est pourquoi on dit que le gradient d’un réseau doit être stable : il doit conserver un mêmeordre de grandeur à travers toutes les couches du réseau. Les fonctions d’activation jouent unrôle important pour assurer cette stabilité.

Les fonctions sigmoïdes et tangentes hyperboliques, beaucoup utilisées dans les premiersANNs, ont comme caractéristique principale une convergence asymptotique. Celle-ci fait ensorte que le gradient de la fonction s’affaiblit rapidement quand x s’éloigne du centre de lafonction. Or, pour discriminer clairement les différentes instances du problème, le réseau doitproduire une variété de valeurs de sortie, incluant celles loin du centre de la fonction. Cela créeune situation où l’apprentissage du réseau diminue sa capacité à apprendre. Parce que le gra-dient des couches superficielles dépend de celui des couches profondes, le problème s’aggraveavec la profondeur du réseau (Bengio et al., 2017, p.189-190).

Pour ces raisons, les réseaux contemporains tendent à utiliser des fonctions d’activation non-asymptotiques comme la relu. La relu présente une non-linéarité moins prononcée que lesfonctions asymptotiques, mais elle fournit un gradient stable dans sa portion positive et esttrès simple à calculer (Bengio et al., 2017, p.187-188).

1.4.4 Sur-apprentissage

L’ensemble d’entraînement n’est qu’un échantillon du phénomène qui nous intéresse. Si l’échan-tillonnage est adéquat, on peut supposer qu’un modèle démontrant de bonnes performancessur cet échantillon sera en mesure de généraliser au phénomène entier. Malheureusement, pourdes raisons qui sont explorées dans les sections suivantes, il est fréquent que les ANNs peinentà généraliser. On dit alors qu’ils souffrent de sur-apprentissage.

12

On mesure le sur-apprentissage en réservant une portion des exemples d’entraînement dans undeuxième ensemble dit de validation. Ces exemples ne sont pas présentés au modèle durantl’entraînement : l’optimisation des poids est faite en ignorant ces exemples. À la fin de l’en-traînement, on mesure la performance du modèle sur l’ensemble de validation. Parce que lesdeux ensembles sont des échantillons du même phénomène, on s’attend à obtenir des perfor-mances similaires. La différence de performance entre l’ensemble d’entraînement et l’ensemblede validation indique le degré de sur-apprentissage dont souffre le modèle (Bengio et al., 2017,p.107-109, 118).

Dans l’espace des ensembles de poids possibles, il y a des ensembles qui performent bienuniquement sur le jeu d’entraînement et d’autres qui performent bien à la fois sur le jeu d’en-traînement et sur celui de validation. Parce que le processus d’optimisation n’a volontairementpas d’information sur l’ensemble de validation, il est incapable de départager les deux catégo-ries de poids. Pour limiter le sur-apprentissage, notre meilleur recours est donc de manipuler leprocessus d’entraînement pour maximiser les chances qu’il converge vers un ensemble de poidspermettant une bonne généralisation. La sous-section suivante explore cette manipulation plusen détail.

1.4.5 Régularisation

La régularisation est l’ensemble des méthodes utilisées pour diminuer la capacité de repré-sentation du modèle afin de limiter le sur-apprentissage. Cette sous-section commence parexpliquer le concept de capacité de représentation et son lien avec le sur-apprentissage avantde présenter les trois méthodes de régularisation utilisées par les réseaux entraînés dans lecadre de ce mémoire.

Capacité de représentation

On appelle capacité de représentation du modèle l’espace de toutes les fonctions que le modèlepeut reproduire. Plus la capacité d’un modèle est grande, plus il est en mesure de modifierson comportement pour tenir compte des données d’entraînement. La capacité d’un modèledépend de son nombre de paramètres, mais aussi des valeurs que ces paramètres peuventprendre et de la façon dont le modèle les utilise (Bengio et al., 2017, p.110). Dans un ANN,augmenter la profondeur du réseau ou le nombre d’unités d’activation par couche sont deuxmanières simples d’augmenter la capacité du modèle.

L’existence du sur-apprentissage peut sembler à première vue étonnante : si les deux en-sembles échantillonnent le même phénomène, comment les caractéristiques extraites par leréseau peuvent être utiles à la modélisation du premier, mais pas du deuxième ? Cette in-congruité disparaît lorsqu’on réalise qu’il est possible pour un modèle ayant suffisamment decapacité d’afficher de bonnes performances sans véritablement modéliser le phénomène.

13

Dans la plupart des contextes d’entraînement, le modèle visite plusieurs fois chaque exempled’entraînement parce que le nombre d’étapes d’optimisation nécessaire à la convergence estbeaucoup plus grand que le nombre d’exemples disponibles. Cela lui donne l’occasion d’opti-miser ces poids pour mémoriser les exemples d’entraînement plutôt que de modéliser la tâche.Si cela se produit, ces performances diminuent significativement lors de l’évaluation parce qu’iln’a pas eu l’occasion de mémoriser l’ensemble de validation.

La mémorisation des exemples d’entraînement demande une plus grande capacité que la mo-délisation du phénomène. Une unité d’activation extrayant une caractéristique pertinente à latâche peut être utilisée sur toutes les instances ; une unité d’activation identifiant un exemplen’est utile que pour identifier cet exemple précis. Considérant l’immense taille des jeux dedonnée typiquement utilisés pour entraîner un ANN, la mémorisation de chaque exemple estdonc extrêmement coûteuse en termes de paramètres.

Dans cette optique, l’entraînement d’un ANN est similaire à la régression polynomiale sur unensemble de points. Quand on limite le degré du polynôme d’approximation, on obtient unecourbe qui, sans passer exactement par tous les points, capture la tendance de la distribution.Mais plus le degré du polynôme augmente, plus il a la capacité de moduler sa courbe pourpasser par un grand nombre de points. Cette courbe complexe limite les erreurs sur les pointsconnus, mais traduit moins bien la tendance générale.

La meilleure façon de limiter le sur-apprentissage est donc de contrôler la capacité du réseau :lui en donner suffisamment pour permettre la modélisation du phénomène, mais trop peu pourpermettre une simple mémorisation. Dans un approximateur de fonction aussi complexe quel’ANN, la capacité n’est pas une simple quantité : il est possible de la moduler de plusieursfaçons pour favoriser différents types de solution. Ces différentes façons de contrôler la capacitéd’un réseau sont appelées méthodes de régularisation. Les sous-sections suivantes détaillentles méthodes de régularisation utilisées dans le cadre de ce mémoire.

Pénalité aux paramètres

La pénalité aux paramètres (weight decay) (Bengio et al., 2017, p.223-232) consiste à ajouterun terme à la perte du réseau (eq. 1.8). La perte totale devient la somme de la fonction de perte"standard" l, basée sur la sortie du réseau y et la sortie attendue y, et la pénalité p qui dépenddes paramètres θ du réseau. La pondération entre l et p est assurée par l’hyperparamètre γ(eq. 1.8).

ltotal = l(y, y) + γp(θ) (1.8)

La pénalité peut prendre plusieurs formes, mais les plus utilisées sont les pénalités sur les

14

normes L1 et L2 des vecteurs de paramètres. Ces pénalités ajoutent un a priori favorisant lessolutions où les poids du modèle conservent des valeurs faibles. Parce que la pénalité de lanorme L2 est non-linéaire, elle tend à favoriser des solutions où tous les paramètres sont petits,mais non-nuls. À l’inverse, parce que tous les poids sont pénalisés également par L1, elle tend àfavoriser des solutions où le poids décisionnel est maintenu sur les caractéristiques permettantune meilleure classification et amené à 0 pour les autres. Parce que les poids à 0 annulent legradient et nuisent à l’apprentissage, L2 est habituellement préféré à L1. Cependant, si oncherche à diminuer la dimensionnalité du modèle, L1 peut aider à identifier les dimensions àéliminer.

l1(x) = |x1|+ ...+ |xn|

l2(x) =√x21 + ...+ x2n

(1.9)

Normalisation par batch

La normalisation par batch (Ioffe and Szegedy (2015)) est une technique permettant de ré-gulariser le réseau, limiter les occurrences d’instabilité numérique et accélérer l’entraînementen stabilisant le gradient dans l’ensemble du réseau. La normalisation par batch considèreque les valeurs produites pour chaque instance d’une batch par une unité d’activation donnéeforment des échantillons issus d’une même distribution. Elle utilise ces échantillons pour esti-mer l’espérance et la variance de la distribution. Ces métriques sont utilisées pour normaliserles échantillons conformément à l’équation 1.10, où x est le vecteur des valeurs non normali-sées, y le vecteur des valeurs normalisées, E[X] et Var[x] sont l’espérance et la variance desvaleurs contenues dans x, respectivement, γ et β sont des paramètres appris qui contrôlentla moyenne et la variance de la distribution normalisée et ε est une petite quantité chargéed’assurer la stabilité numérique.

y =x− E[x]√V ar[x] + ε

· γ + β (1.10)

Les raisons qui expliquent l’efficacité de la normalisation par batch sont encore sous discussionsdans la littérature (Santurkar et al. (2018), Bjorck et al. (2018)). Les résultats qu’elle obtientempiriquement sont cependant indiscutables, ce qui explique son utilisation dans une grandevariété d’architectures.

L’efficacité de la normalisation par batch a suscité le développement de plusieurs variantes.Elles utilisent toutes la même équation de normalisation, mais varient dans leur définition duvecteur d’échantillons x. La normalisation par couche (layer normalization, Ba et al. (2016))considère toutes les valeurs de hi,n, l’état caché produit par la couche n sur l’instance i,comme issus de la même distribution. Avec cette méthode, y indique l’importance relative

15

des différentes caractéristiques de hi,n, indépendamment des valeurs produites pour les autresinstances de la batch. La normalisation par instance (instance normalization, Ulyanov et al.(2016)) est une variante de la normalisation par couche spécifique aux CNNs (section 1.5.1).Avec cette méthode, chaque feature map de hi,n constitue une distribution distincte. y indiquealors l’importance de la caractéristique représentée par la feature map dans chaque région dela grille relativement aux autres.

Architecture et partage des paramètres

La compréhension de la structure interne des données d’entrée est souvent essentielle à laréalisation d’une tâche. Une image couleur, par exemple, est une grille de pixels où chaquepixel est défini selon trois canaux : rouge, bleu et vert. On sait que l’information contenuedans la grille est localisée. Par exemple, on peut définir le concept de ligne comme étant uneséquence de pixels voisins de même couleur. Ce concept met en relation des éléments voisinsde la grille plutôt que des éléments distants.

Un MLP ignore cette structure et considère chaque dimension du vecteur d’entrée commeétant à priori indépendante des autres. Dans une image, cela signifie que tout concept depixel ou de canal doit être appris indépendamment par chaque unité d’activation. De plus,parce l’unité d’activation est appliquée une seule fois sur l’ensemble de hn, si elle apprendà reconnaître une caractéristique locale comme une ligne, elle n’apprend à reconnaître cetteligne qu’à un endroit précis dans l’image. Parce qu’elle considère toutes les dimensions de hnimpliquées dans cette ligne comme indépendantes des autres, elle n’a pas les outils nécessairespour pouvoir généraliser le concept de ligne à d’autres localisations dans l’image. Cela signifieque chaque ligne pouvant potentiellement apparaître dans l’image doit, pour être détectée parle réseau, avoir une unité d’activation qui est exclusivement dédiée à sa détection. Cela signifieégalement que chacune de ces unités d’activation doit apprendre indépendamment le conceptde ligne : elles ne peuvent pas utiliser l’expérience du réseau dans la détection de lignes ailleursdans l’image. Les seuls exemples applicables sont ceux où il existe une ligne précisément auxpixels que cette unité d’activation considère.

Cela fait en sorte qu’un MLP a besoin d’un grand nombre d’unités d’activation pour apprendreà extraire les caractéristiques générales permettant de bien modéliser la tâche. Cela nous placedans une situation intenable : nous devons fournir une grande capacité de représentation auMLP si nous voulons qu’il apprenne les relations nécessaires à une bonne généralisation, maiscette capacité peut tout aussi bien être utilisée pour simplement mémoriser les exemples. Celamène directement à des situations de sur-apprentissage.

Pour contrer ce problème, on peut changer la structure de l’ANN pour qu’il tienne compte de lastructure de la donnée. Pour y arriver, on divise la donnée complète en ces unités constituantes(un pixel, par exemple) et on les arrange dans une structure de donnée répétitive qui rend

16

explicite leurs relations (comme placer des pixels dans une grille bidimensionnelle pour formerdes images). On peut ensuite définir les unités d’activation pour qu’elles ne travaillent que surune répétition de la structure à la fois et les appliquer successivement sur chaque répétition.Cela permet d’avoir une seule unité d’activation dédiée à la détection de lignes, par exemple, etde l’appliquer sur chaque voisinage de pixels pour détecter une ligne à cet endroit. Cela limitela quantité d’unités d’activation nécessaires et permet aux unités d’activation d’apprendre leconcept qu’elles extraient à partir d’exemples tirés de l’ensemble de la donnée plutôt que d’unelocalité précise (Bengio et al., 2017, p.309-312).

En forçant le réseau à interpréter la donnée de façon structurée, on limite significativementsa capacité : il ne peut plus apprendre de fonction qui ignore cette structure. Mais parcequ’une structure bien définie aide l’apprentissage de la tâche, on élimine des solutions qui sur-apprennent et favorise celles susceptibles de généraliser. Des exemples d’architectures utilisantle partage de paramètres sont présentées à la section 1.5.

1.4.6 Recherche d’hyperparamètres et ensemble de test

La calibration du modèle pour favoriser la généralisation dépend de plusieurs facteurs et il estdifficile de prédire l’effet exact de chacun d’entre eux ainsi que leurs interactions. C’est pourquoices facteurs sont considérés comme des hyperparamètres du processus d’entraînement : desparamètres dont la valeur est fixée avant l’entraînement et qui ne peut pas être modifiée parl’algorithme d’apprentissage.

Afin de maximiser nos chances d’obtenir une bonne solution, il est coutume d’entraîner lemodèle plusieurs fois en faisant varier les hyperparamètres entre chaque entraînement. Ce pro-cessus est appelé l’optimisation d’hyperparamètres. Il existe plusieurs stratégies pour conduirecette recherche, avec différents niveaux de sophistication. Les expériences présentées dans cemémoire utilisent la méthode très simple de l’optimisation indépendante. Chaque hyperpa-ramètre est présumé comme étant indépendant des autres. Pour chaque hyperparamètre, ondéfinit une plage de valeurs plausibles et une valeur "par défaut" qui est utilisée tant quecet hyperparamètre n’a pas été optimisé. Chaque élément de la plage est testé et une valeuroptimale pour cet hyperparamètre est déterminé. Cette valeur optimale remplace la valeurpar défaut et est utilisée durant l’optimisation des autres hyperparamètres. Cette méthode al’inconvénient de ne pas mesurer systématiquement l’interaction des hyperparamètres entreeux, mais est très économe en termes de temps d’entraînement.

Indépendamment de l’algorithme de recherche, le modèle ayant obtenu le meilleur score surl’ensemble de validation est celui qui est conservé. Ce mode de sélection crée nécessairementun biais en faveur de modèles qui, par hasard, performent bien sur l’ensemble de validation.Pour avoir une évaluation moins biaisée des performances du modèle, il est courant de réserverun troisième ensemble d’exemples appelé ensemble de test. Ce troisième ensemble ne sert qu’à

17

cette dernière évaluation et n’est pas utilisé dans la sélection du modèle ((Bengio et al., 2017,p.107-112).

1.5 Architectures avancées

Les MLPs ont jusqu’à maintenant été au centre de notre discussion, mais ils ne sont pas lesseuls types d’ANNs disponibles. Cette section couvre trois variantes architecturales courantesque nous avons utilisées dans le cadre de nos travaux.

1.5.1 Réseaux Convolutifs

Fonctionnement général

Certaines données sont organisées localement : elles peuvent être représentées par une grilleoù les éléments voisins sont plus fortement corrélés que les éléments distants. Une image estun exemple d’une telle donnée : ces pixels peuvent être placés dans une grille et les pixelsvoisins sont plus susceptibles d’appartenir au même objet que les pixels distants. Dans unetelle grille, chaque élément est généralement défini par une ou plusieurs dimensions appeléescanaux. Dans une image couleur, ces canaux sont le rouge, le bleu et le vert.

Les réseaux convolutifs (convolutionnal neural network, CNN ) (Bengio et al., 2017, p. 321-361)sont conçus pour faciliter l’analyse de ces données. Ils y arrivent en utilisant un type particulierd’unité d’activation appelé filtre. Plutôt que de combiner simultanément toutes les dimensionsdu vecteur d’entrée, un filtre combine un nombre limité de dimensions correspondant à unensemble d’éléments voisins dans la grille. Le rôle du filtre est d’extraire une caractéristiquede cette localité. En centrant successivement le filtre sur chaque élément de la grille, on produitune nouvelle grille appelée feature map. La feature map indique la présence ou l’absence de lacaractéristique pour chaque localité de la grille.

Le nombre d’éléments combinés par un filtre est appelé sa taille. Si la grille est multidimen-sionnelle, comme dans le cas des images qui forment une grille en deux dimensions, la tailledu filtre est définie dans chaque dimension. Pour pouvoir facilement centrer le filtre, sa tailleest habituellement impaire.

La figure 1.3a illustre le processus d’application d’un filtre plusieurs fois sur hn−1 pour former lafeature map hn,j . Chaque élément hn−1,i désigne un élément dans une grille unidimensionnelle.Les éléments sont définis en c canaux. Chaque wj correspond à un vecteur de poids de taillec où chaque dimension correspond à un canal d’entrée. Le filtre définit trois ensembles depoids : un pour l’élément central (wj,0), un pour celui à sa gauche (wj,−1) et un pour celuià sa droite (wj,1). Pour alléger la figure, l’indice n de la couche à laquelle wj appartient estomit, mais les poids restent uniques à chaque couche. Dans le même souci d’allègement, nous

18

avons représenté une grille unidimensionnelle, mais le principe se généralise facilement à desgrilles multidimensionnelles.

(a) Sans padding

(b) Avec padding

Figure 1.3 – Unité d’activation j de la couche n d’un CNN

L’équation 1.11 présente formellement comment sont calculées les valeurs d’une feature mapdans le cas unidimensionnel. hn,j est la feature map sortante, W le filtre, hn−1 l’ensemblede feature maps entrant et k la taille du filtre. n est l’indice de la couche, j l’indice d’unefeature map de cette couche, i l’indice de l’élément dans la feature map, x l’indice de l’élé-ment du filtre et z l’indice des canaux de hn−1. L’équation suppose un k impair et une grilleunidimensionnelle.

hn,j,i =k∑x=0

Z∑z=0

Wn,j,x,zhn−1,z,i+x− k−12

(1.11)

Une couche convolutive est composée de J filtres. Chacun de ces filtres produit une featuremap. Celles-ci sont concaténées pour produire une grille où chaque élément est définie en J

canaux. Cette grille sert d’entrée à la couche suivante.

19

Champs perceptif

Le champ perceptif (Bengio et al., 2017, p.324-330) est un concept permettant de déterminerquels éléments de h0 influencent la valeur d’un élément de hn. Le champ perceptif croit avecn. Pour h1, le champ perceptif est déterminé directement par la taille du filtre. Pour hn avecn > 1, les éléments visés par le filtre sont eux-mêmes des combinaisons d’éléments des filtresprécédents, ce qui accroît le champs perceptif. La figure 1.4 montre comment cet effet decombinaison de combinaisons permet d’augmenter le champ perceptif.

La notion de champs perceptive est utile parce qu’elle indique que les caractéristiques extraitespar les couches profondes d’un CNN sont moins fortement localisées que celles des couchessuperficielles.

Figure 1.4 – Champs perceptif après deux couches avec des filtres de taille 3

Padding

L’opération de convolution est normalement indéfinie en bordure de la grille, parce que certainspoids du filtre n’ont pas de valeur associée. Cela réduit la taille des feature maps de coucheen couche, ce qui est habituellement indésirable.

Ce problème est résolu par le padding ((Bengio et al., 2017, p.338-339). Cette technique consisteà ajouter des éléments en bordure de la grille afin que les filtres puissent s’appliquer sur lescoins de celle-ci. Généralement, les vecteurs ainsi ajoutés sont des vecteurs nuls. Plus lesfiltres sont de grande taille, plus il faut ajouter de vecteurs de padding. La figure 1.3b montrecomment l’ajout de padding permet de préserver la taille originale de la séquence.

Pooling

Le pooling (Bengio et al., 2017, p. 330-334) est une technique utilisée dans les CNNs pouraugmenter le nombre de filtres dans les couches profondes du réseau tout en gardant stable laquantité de calcul nécessaire à l’évaluation de chaque couche.

Le pooling condense l’information de la grille en diminuant sa taille, généralement de moitié.Pour une grille bidimensionnelle, cela signifie condenser l’information de quatre éléments en un

20

seul. Différents types de pooling condensent l’information de différentes façons : le max poolingutilise la valeur maximale de chaque groupe alors que le average pooling utilise la moyenne.

En diminuant la taille de la grille d’un certain facteur f , on diminue d’autant les calculsnécessaires à l’application d’un filtre sur cette grille. Cela nous permet d’ajouter des filtres àchaque couche sans augmenter la quantité de calcul nécessaire à son évaluation. Pour garderconstant la quantité de calcul, on ne peut cependant pas augmenter le nombre de filtre dumême facteur f . Parce que la taille d’un filtre est définie par le nombre de feature mapsproduit par la couche précédente, augmenter le nombre de filtres augmente aussi la taille detous les filtres subséquents. Conséquemment, on peut augmenter le nombre de filtres par laracine carrée de f . Par exemple, si on compresse de moitié chaque dimension d’une imagebidimensionnelle, pour un facteur de compression total de 4, on peut doubler le nombre defiltres utilisé par les couches subséquentes.

On remarque en pratique que les gains obtenus par l’augmentation du nombre de filtres outre-passent la perte d’information inhérente au processus de condensation. On estime que la perted’information est minime parce que l’accroissement du champ perceptif de couche en couchefait en sorte que les régions de la grille tendent à s’homogénéiser avec le temps. De plus, lescaractéristiques plus abstraites extraites par les couches profondes tendent à occuper un plusgrand espace dans la grille originale, de sorte qu’elles sont moins impactées par la perte derésolution. Par exemple, dans une image, l’emplacement d’une roue peut être décrit avec unemoins grande résolution que celui d’une ligne.

Habituellement, le pooling réduit la taille de la grille par un facteur prédéterminé. La taillede la grille résultante dépend alors de la taille de la grille d’origine. Il est aussi possible deprocéder à l’inverse et de prédéterminer la taille de la grille résultante. Le facteur de réductiondépend alors de la taille de la grille d’origine. Cette méthode est appelée pooling adaptatif parla librarie PyTorch.

Le pooling global est une forme de pooling adaptatif particulière où la taille de la grille résul-tante est fixée à 1 pour toutes les dimensions. Cela transforme la grille en un vecteur d’unedimension par feature map. Ce vecteur rend les caractéristiques extraites par le CNN plusfacilement utilisables par une couche linéaire. Le pooling global est souvent utilisé juste avantles couches produisant la valeur de régression ou la distribution de classification.

1.5.2 Réseaux résiduels

Le réseau résiduel (He et al. (2016)) est une architecture à propagation avant qui modifiel’organisation des couches du réseau. Parce que l’architecture ne décrit pas le fonctionnementinterne des couches ou de leurs unités d’activation, elle peut être utilisée conjointement avecd’autres modifications architecturales utilisant le paradigme de la propagation avant, commeles CNNs.

21

Un réseau résiduel organise ces couches en groupes de D couches appelés blocs résiduels.Chacun de ces blocs produit hn à partir de hn−1 (fig. 1.5a). À l’intérieur d’un bloc, les couchessont appliquées successivement à hn−1 pour produire une série de représentations temporairest. Une fois toutes les couches du bloc appliquées, on additionne tD a hn−1 pour obtenir hn(fig. 1.5b).

Cela permet au bloc d’apprendre une fonction résiduelle. Considérant une fonction f(x), onappelle r(x) la fonction résiduelle de f(x) si, pour tout x, r(x) = x + f(x). Dans le contexted’un ANN, apprendre une fonction résiduelle signifie ainsi que plutôt que de produire hn àpartir de hn−1, le bloc produit la différence entre hn−1 et hn à partir de hn−1.

Ceci peut poser un problème si les dimensions de hn−1 et de hn sont différentes. Cette situationse produit quand les couches internes produisent un tD de dimensions différentes que hn−1.Pour régler le problème, le bloc résiduel apprend une couche supplémentaire Lz qui projettehn−1 dans un espace vectoriel de même dimension que hn pour permettre à l’addition d’avoirlieu (fig. 1.5c).

(a) Propagation avant (b) Bloc résiduel où les dimensionsde hn−1 et hn sont identiques

(c) Bloc résiduel où les dimensionsde hn−1 et hn sont différentes

Figure 1.5 – Réseau résiduel

Il est observé empiriquement que l’utilisation de blocs résiduels favorise l’apprentissage desANNs et améliore leurs performances. Trois raisons sont habituellement suggérées pour expli-quer cette amélioration.

Premièrement, l’utilisation de blocs résiduels favorise l’apprentissage de la fonction identité.La fonction identité est utile pour partager aux couches profondes les caractéristiques extraitespar les couches superficielles. Normalement, une caractéristique extraite par la couche n ne

22

peut être utilisée que par la couche n+ 1. Il est cependant possible d’imaginer que le conceptexprimé par cette caractéristique soit utile à plusieurs niveaux d’abstraction et que le réseaugagnerait à pouvoir l’utiliser sur plus d’une couche. Cela se produit si une unité d’activationde la couche n + 1 apprend la fonction identité, transmettant telle quelle l’information à lacouche n+2. L’utilisation de la fonction identité pour transmettre une valeur telle quelle d’unecouche à l’autre est parfois appelée skip connection dans la littérature.

Depuis l’introduction des blocs résiduels (He et al. (2016)), il est supposé que leur utilisationfacilite l’apprentissage de la fonction identité. Si on apprend directement la fonction identitéI, on a f(x) = x. Si on apprend la fonction identité de façon résiduelle, on a f(x) = x+ r(x),avec r(x) = 0. Il est supposé qu’il est plus facile pour les couches d’un réseau de produiresystématiquement 0 que de reconduire x pour toutes valeurs de x. Ceci est particulièrementvrai dans des réseaux utilisant la normalisation par batch et la relu, où la distribution dessorties tend à être centrée autour de 0 et où toute valeur négative est ramenée à 0. Cela dit, lavalidité de cette supposition n’a pas encore été, à notre connaissance, prouvée formellement.

Deuxièmement, les additions du bloc résiduel stabilisent la propagation du gradient dans leréseau. Une addition a toujours un gradient de 1, alors que le gradient d’une multiplicationdépend de ces opérandes. Quand celle-ci sont entre 0 et 1, comme c’est souvent le cas dans unANN, le gradient diminue de couche en couche, ce qui ralenti le processus d’apprentissage descouches superficielles. Les blocs résiduels limitent ce problème en complémentant le gradientde la multiplication par celui de l’addition.

Troisièmement, la profondeur des blocs résiduels crée un lien direct entre des variables quiseraient autrement séparés par une ou plusieurs couches. Cette circulation plus directe dugradient permet de mieux déterminer l’impact des couches superficielles du réseau sur l’erreurfinale et facilite ainsi l’apprentissage.

1.5.3 Réseau récurrents

Fonctionnement général

Certaines données peuvent être interprétées comme une séquence d’éléments plus simples quiles compose. Dans ces situations, les éléments de la séquence sont souvent corrélés entre eux :connaître les premiers éléments aide à prédire les suivants. Un texte est un exemple classiquede données séquentielles : une phrase est une séquence de mots et en connaître le début aideà en prédire la fin.

Les réseaux récurrents (recurrent neural network, RNN) (Bengio et al., 2017, p.363-408) sontconçus pour l’analyse de tels problèmes séquentiels. Les éléments sont analysés un à la foisdans une série d’étapes de calcul. À chaque étape, le vecteur xn représentant l’élément à analy-ser est concaténé à un deuxième vecteur hn−1 qui résume la séquence vue jusqu’à maintenant.

23

Ce vecteur h est aussi appelé la "mémoire" du RNN. Le réseau utilise une couche pleinementconnectée pour produire un nouveau vecteur résumé hn à partir de cette concaténation. Unedeuxième couche pleinement connectée produit la valeur de sortie on à partir de hn. Ce trai-tement, qui consiste à combiner un nouvel élément et un contexte en un nouveau contexte,forme une cellule RNN. L’architecture d’un réseau RNN complet consiste à appliquer la mêmecellule ou ensemble de cellules (section 1.5.3) à tous les éléments de la séquence. Parce que leflot d’information d’un RNN transite plusieurs fois par le même ensemble de couches plutôtque d’être passé de couches en couches, les RNNs ne sont généralement pas considérés commedes réseaux à propagation avant.

Notons que nous utilisons dans cette section et les suivantes l’indice n pour indiquer lesétapes de calcul, alors que la littérature utilise plus fréquemment t. Notre utilisation de nsert à souligner que l’application successive de la cellule RNN aux éléments de la séquenced’entrée est l’équivalent pour les RNNs de la succession de couches des réseaux à propagationavant. Cette équivalence sera importante au chapitre 3, c’est pourquoi nous préférons l’établird’emblée.

Il existe plusieurs types de cellules RNNs. L’équation 1.12 illustre les équations définissant letype "standard", qui est le plus simple. xn y est l’entrée à l’étape n, hn la mémoire du RNNà l’étape n, on la sortie à l’étape n et f et g des fonctions représentées par une ou plusieurscouches pleinement connectées.

hn = f(hn−1‖xn)

on = g(hn)(1.12)

Cette architecture permet au réseau d’apprendre à analyser un élément à partir de soncontexte. Parce que les mêmes poids sont utilisés à chaque étape, deux éléments avec uncontexte similaire seront analysés de façon similaire. Par exemple, cela permet au RNN d’ap-prendre que le mot suivant le sujet est le verbe et ce, indépendamment des mots exacts qu’onretrouve dans la phrase.

Les valeurs de sortie de chaque étape ne sont pas nécessairement utilisées. Dans des tâches declassification, par exemple, on s’intéresse généralement uniquement à la dernière sortie. Lestâches de transduction peuvent utiliser toutes les sorties en utilisant chaque sortie comme unvecteur représentant un élément de la nouvelle séquence, mais cette technique ne peut êtreutilisée que dans les cas où les séquences d’entrée et de sortie sont de mêmes longueurs. Pourrésoudre le problème général de transduction, on utilise plutôt une architecture séquence àséquence (Sutskever et al. (2014)) qui, traditionnellement, n’utilise elle aussi que la dernièrevaleur de sortie. Les mécanismes d’attention (Bahdanau et al. (2015)) permettent de mettreà contribution toutes les valeurs de sortie et peuvent être utilisés dans une grande variété

24

d’applications.

La cellule de base présentée par les équations 1.12 est peu utilisée en pratique. La mémoired’une telle cellule peine à conserver de l’information pour une longue période, ce qui empêchele réseau de reconnaître les relations entre des éléments distants de la séquence. De plus, legradient de la cellule tend à être instable, ce qui nuit à l’apprentissage.

D’autres types de cellules ont été mises au point pour remédier à ces problèmes. Elles utilisentdes structures plus complexes, appelées portes, pour contrôler l’évolution de la mémoire dansle temps. C’est pourquoi ces cellules sont qualifiées de "à porte" (gated).

Cellules à porte

La cellule RNN de base peine à modéliser les relations entre des éléments distants parceque sa mémoire est instable. Comme nous l’avons mentionné dans la section 1.5.2, la fonctionidentité est difficile à apprendre à partir de transformations linéaires. Plutôt que d’apprendre àproduire un nouveau vecteur mémoire à chaque étape de calcul, les cellules à portes apprennentà modifier la mémoire existante. Elles partagent donc le même principe de base que les blocsrésiduels, même si ce principe est implémenté de façon différente.

Il existe un grand nombre de cellules à porte. Cette section discute des deux principales : lacellule Long Short Term Memory (LSTM, fig. 1.6a, Hochreiter and Schmidhuber (1997)) et lacellule Gated Recurent Unit (GRU, fig. 1.6b, Chung et al. (2014)). Notons que les schémas dela figure 1.6 indexent les étapes de calcul par t plutôt que n.

(a) LSTM 1 (b) GRU 2

Figure 1.6 – RNNs à porte

Les LSTMs utilisent un vecteur c pour stocker la mémoire de la cellule. À chaque étape decalcul n, la mémoire est mise à jour et utilisée pour produire une valeur de sortie hn. Lecomportement exact de la cellule est contrôlé par quatre portes. Une porte est une couchelinéaire prenant en entrée la concaténation de xn et hn−1 pour produire un vecteur de mêmes

2. Figure reproduite de Varsamopoulos et al. (2018)2. Figure reproduite de Jabreel and Moreno (2019)

25

dimensions que c. Chaque porte a un rôle spécifique à jouer dans le fonctionnement de lacellule. Elles sont désignées sous les noms de porte d’oubli (F ), porte candidat (C), porte demise à jour (I) et porte de sortie (O).

Le traitement d’un élément de la séquence se fait en trois étapes. Premièrement, F déter-mine quelles informations peuvent être retirées de la mémoire. F est activée par une fonctionsigmoïde, ce qui fait que les dimensions de sa sortie fn sont comprises entre 0 et 1. fn estmultipliée point à point avec Cn, de sorte qu’une dimension à 0 signifie que l’information estoubliée, une dimension à 1 signifie qu’elle est pleinement conservée et une valeur intermédiairesignifie une atténuation partielle de l’information.

Deuxièmement, la cellule ajoute de l’information à sa mémoire préalablement libérée. Pour sefaire, elle utilise les portes C et I. C est activée par une tangente hyperbolique pour produiredes valeurs entre -1 et 1. Le vecteur produit représente le candidat : la valeur vers laquelle onveut faire tendre la mémoire. I est activée par la sigmoïde, pour obtenir des valeurs entre 0et 1. Chaque dimension du candidat est partiellement ajoutée à la mémoire en fonction de lapondération déterminée par in. Après cette étape, on obtient cn, une somme pondérée entrecn−1 et cn. Les poids de la pondération sont contrôlés par fn et in

Finalement, le signal de sortie hn est produit à partir de cn. La porte O, activée par une fonc-tion sigmoïde, produit une pondération appliquée point à point aux dimensions de tanh(cn).L’application de la tangente hyperbolique normalise la sortie pour n’avoir que des valeurscomprises entre -1 et 1.

Les équations 1.13 définissent formellement les différents éléments d’une cellule LSTM.

fn = σ(F (hn, xn)),

in = σ(I(hn, xn)),

cn = tanh(C(hn, xn))

on = σ(O(hn, xn))

cn = cn−1 · fn + in · cnhn+1 = tanh(cn) · on

(1.13)

La cellule GRU est une version simplifiée de la cellule LSTM. Le principe général de la celluleest conservé : la nouvelle version de la mémoire est une somme pondérée entre son ancienneversion et une version candidate produite par une porte. Les deux cellules sont cependantassez différentes dans leurs détails.

Premièrement, les GRUs n’utilisent pas de vecteurs cn : leurs vecteurs hn servent à la fois demémoire et de sortie. À cause de ce changement, les GRUs n’ont pas de porte de sortie pourtransformer la mémoire en sortie.

26

Deuxièmement, la somme des pondérations entre la mémoire et le candidat somment à 1 pourtoutes les dimensions. Ce résultat est obtenu en générant un seul vecteur de pondération znpour le candidat et d’utiliser 1− zn pour la mémoire. Avec cette méthode, la porte Z combineles fonctionnalités des portes F et I du LSTM.

Finalement, la fonction pour générer le candidat est un peu plus complexe dans le GRU.Avant d’être concaténé à xn pour servir d’entrée à la porte candidat H, hn−1 est multipliépoint à point avec le vecteur de pondération rn. rn est produit par une porte R activée parune sigmoïde pour produire un vecteur de pondération avec des valeurs entre 0 et 1.

Les équations 1.14 définissent formellement les différentes étapes de calcul d’une cellule GRU.

zn = σ(Z(hn, xn)),

rn = σ(R(hn, xn)),

ht = tanh(H(hn−1 · rn, xn))

hn = zn · hn + (1− zn) · hn−1

(1.14)

Les performances relatives des LSTMs et des GRUs varient en fonction de la tâche et lalittérature n’a pas encore tranché sur l’architecture préférable dans le cas général. Le GRUconserve cependant un intérêt particulier dût à son plus petit nombre de paramètres.

RNN multicouche

Comme les autres types d’architecture, un RNN peut avoir plusieurs couches. Chacune desD couches d’un RNN multicouche est composée d’une cellule distincte rd ayant ses proprespoids. Chaque couche a aussi son propre vecteur de sortie hd,n si le réseau utilise des cellulesLSTM, son vecteur cd,n. Pour chaque élément de la séquence, la première couche reçoit xn etmet à jour h0,n−1 pour produire h0,n. Plutôt que de recevoir xn comme donnée d’entrée, lescouches suivantes reçoivent le vecteur de sortie mis à jour de la couche précédente : hd,n =

rd(hd,n−1, hd−1,n). La valeur de sortie du réseau pour l’étape n est la sortie produite par ladernière couche du réseau.

RNN comme structure de contrôle

Siegelmann and Sontag (1992) ont démontré que les RNNs forment un langage Turing-complet.Cela signifie qu’il est théoriquement possible pour un RNN de reproduire n’importe quelprogramme. Cela ne signifie cependant pas qu’il est facile d’apprendre n’importe quel pro-gramme, parce qu’un RNN ne peut apprendre que les programmes accessibles par descentedu gradient. Ce résultat indique néanmoins qu’il est concevable d’utiliser les RNNs dans uneplus grande variété de contextes que les autres architectures d’ANNs.

27

Figure 1.7 – Architecture d’un RNN multicouche

Neelakantan et al. (2016) montre par exemple qu’un peut utiliser un RNN pour contrôler unalgorithme. Leur programmeur neuronal est un ANN qui apprend à générer des requêtes SQLpour répondre à des questions formulées en langage naturel. Le réseau est composé de deuxRNNs. Le premier est utilisé de façon "traditionnelle" pour transformer les mots de la questionen un vecteur la résumant. Le deuxième est chargé de contrôler le processus de génération dela requête SQL. La génération est faite en plusieurs étapes. Parce que la mémoire contient unrésumé des décisions prises aux étapes antérieures, chaque choix est fait dans le contexte dutravail déjà effectué.

Le lecteur remarquera à la section 3.2.2 que les PBCNNs non markoviens utilisent eux aussi unRNN pour contrôler leur comportement. Il s’agit d’un autre exemple d’utilisation d’un RNNcomme structure de contrôle.

28

Chapitre 2

Interprétation agent des ANNs

L’apprentissage supervisé (supervised learning) et l’apprentissage par renforcement (reinforce-ment learning, RL) sont généralement considérés comme deux branches distinctes de l’appren-tissage automatique. L’apprentissage supervisé cherche à résoudre des problèmes pour lesquelsla réponse optimale à une situation est connue. La tâche de l’apprenant est alors de reproduireles réponses optimales dans une variété d’instances du problème visé. Il est similaire à l’ap-prentissage formel pratiqué dans les écoles, où les élèves peuvent compter sur un professeurpour leur indiquer leurs erreurs et la bonne réponse.

L’apprentissage par renforcement cherche à résoudre des problèmes où la réponse optimale àune situation n’est pas connue. La tâche d’apprentissage n’est plus seulement de reproduire lecomportement optimal, mais aussi d’identifier quel est ce comportement optimal. L’apprenantdoit interagir avec son environnement et apprendre par essai et erreur les actions qui abou-tissent au résultat souhaité. Ce concept est similaire à un apprentissage informel, où un enfantpar exemple apprend à marcher en déterminant par l’expérience quels mouvements résultenten un déplacement et quels mouvements résultent en une chute.

Ce chapitre explore les liens qui unissent ces deux formes d’apprentissage. Nous y montronsque l’entraînement d’un ANN pour résoudre une tâche supervisée peut être considéré commeun problème d’apprentissage par renforcement. À notre connaissance, cette démonstrationconstitue une contribution originale de ce mémoire à la littérature. Selon nous, cette équi-valence est intéressante principalement parce qu’elle permet de décrire les ANNs comme desagents utilisant une politique. Notre objectif au chapitre suivant sera d’améliorer l’efficacitédes réseaux en modifiant cette politique.

Nous divisons le chapitre en deux sections. La section 2.1) présente formellement le problèmede l’apprentissage par renforcement et défini les concepts nécessaires à notre démonstration.La section 2.2 utilise ces concepts pour décrire un ANN à propagation avant apprenant unetâche supervisée.

29

L’apprentissage par renforcement défini un cadre extrêmement souple qui peut décrire unegrande variété de tâches. Dans ce chapitre, nous considérons uniquement les tâches détermi-nistes et épisodiques. Par déterministe, on entend des problèmes où la fonction de transition, lafonction récompense et la fonction politique produisent une valeur vectorielle ou scalaire plutôtqu’une distribution de probabilité sur un ensemble de vecteurs ou scalaires. Par épisodique, onentend qu’il existe dans l’environnement des états finaux dont l’atteinte provoque la complé-tion de la tâche et la réinitialisation de l’environnement. L’ensemble de notre démonstrationsuppose implicitement ces deux conditions.

2.1 Le problème de l’apprentissage par renforcement

2.1.1 Vue d’ensemble

Le RL modélise l’apprentissage d’une tâche comme l’interaction d’un apprenant appelé agentavec son environnement (Sutton and Barto, 2018, p.51-85). L’environnement est défini par unespace d’états S, les espaces d’actions As avec s ∈ S décrivant les actions disponibles dans unétat donné, une fonction de transition t et une fonction récompense r. Certains de ces élémentsreprésentent des caractéristiques intrinsèques de la tâche et d’autres peuvent être librementdéfinis par les concepteurs de l’agent. Ils sont cependant tous hors du contrôle de l’agent etde l’algorithme d’apprentissage. L’agent doit apprendre à résoudre sa tâche en respectant lescontraintes de son environnement.

La tâche est réalisée en une série de N étapes. À n = 0, l’agent est dans un état initial s0 ∈ S.Il choisit une action a ∈ As0 . La fonction de transition t indique comment l’exécution de cetteaction modifie l’état : sn+1 = t(sn, an). L’agent peut alors choisir une nouvelle action et laboucle se poursuit jusqu’à l’atteinte d’un état final indiquant la fin de la tâche.

À chaque transition d’état, l’environnement émet aussi un signal de récompense. La valeurde ce signal est déterminé par la fonction de récompense r : rn = r(sn+1). Si l’atteinte del’état est conforme aux objectifs de l’agent, le signal est positif. Sinon, il est négatif. Ainsi,en maximisant la somme de ses récompenses, l’agent maximise sa performance sur la tâche.Cette somme des récompenses est appelée le retour et est notée R. La figure 2.1 illustre laboucle utilisée par l’agent pour résoudre sa tâche. La ligne pointillée indique la frontière entredeux itérations de la boucle.

Pour maximiser ses récompenses, l’agent améliore sa politique π. La politique est la fonctionindiquant à l’agent l’action à exécuter selon l’état où il se trouve : an = π(sn). La tâche del’algorithme d’apprentissage est de trouver la politique optimale, c’est à dire la politique quimaximise le retour espéré de l’agent. On peut exprimer formellement cet objectif avec l’équa-tion : J(π) = Eπ[r]. Il existe de nombreux algorithmes permettant d’optimiser la politique.Pour choisir parmi ces choix, il faut considérer la nature de la tâche ainsi que la façon dont

30

Figure 2.1 – Boucle de résolution d’une tâche en apprentissage par renforcement

sont définis les autres éléments du problème comme les états, les actions et la politique.

Après cette présentation sommaire, les sous-sections suivantes détaillent les aspects de l’ap-prentissage par renforcement les plus pertinents pour la suite du mémoire.

2.1.2 Espaces d’états et d’actions

Granularité : Les états et les actions sont des abstractions : ils décrivent la tâche à réaliser,mais la façon dont ils la décrivent est ultimement une décision des concepteurs de l’agent (Sut-ton and Barto, 2018, p.52-53). Il est donc possible de décrire le même problème avec plusieursespaces d’états et d’actions distincts. On peut supposer que ces choix de représentation ontun impact sur le processus d’apprentissage : Zhang et al. (2020) présente un tableau détaillantles performances théoriques de différents algorithmes en fonction, notamment, de la taille desespaces d’états et d’actions. La nature exacte de ces interactions reste cependant en dehors dela portée de ce mémoire. Pour nos fins, il suffit d’observer qu’un problème peut être décrit defaçon valide par plusieurs espaces d’actions.

Nous nous intéressons spécifiquement à la possibilité d’augmenter ce que nous appelons lagranularité de l’espace d’action. La plupart des actions ne sont pas atomiques, mais peuventêtre scindées en plusieurs étapes. Un algorithme informatique, par exemple, est habituellementune séquence de sous-routines plus simples. On peut imaginer un agent dont la tâche est dechoisir à chaque étape quel algorithme exécuter. On peut augmenter la granularité de l’espaced’action en remplaçant les algorithmes par l’ensemble des sous-routines que ces algorithmesutilisent. Clairement, l’agent aura besoin de prendre un plus grand nombre de décision, maisil est toujours capable d’exécuter les algorithmes en sélectionnant la bonne séquence de sous-routines. Les solutions offertes par l’espace d’action moins granulaire est un stricte sous-ensemble des solutions offertes par l’espace d’action plus granulaire.

Cette notion de granularité dans l’espace d’action nous sera utile lorsque nous tenterons de

31

définir l’espace d’action d’un ANN supervisé.

Abstraction : Le cadre RL est souvent utilisé pour résoudre des tâches concrètes, où lesétats et actions correspondent à des concepts tangibles intuitivement compréhensible par unhumain : jeux de société (Silver et al. (2017)), jeux vidéos (Mnih et al. (2013)), extraction dephrases d’un texte pour en produire le résumé (Gao et al. (2018)), etc. Dans leur définition duproblème RL, Sutton et Barto précisent néanmoins que les concepts RL peuvent aussi décriredes concepts plus abstraits, comme des états mentaux ou des opérations mathématiques (Sut-ton and Barto, 2018, p.52-53). Cela signifie que le problème RL n’est pas a priori incompatibleavec les constructions mathématiques et informatiques que sont les ANNs.

Représentation : D’un point de vue pratique, les concepteurs de l’agent doivent égale-ment choisir une façon de représenter chaque état et action dans l’algorithme d’apprentissage.Il existe deux options : utiliser un indice ou un vecteur. Une représentation par indice estappropriée quand les ensembles S ou A sont discrets et dénombrables. L’indice permet alorsd’identifier dans quel état de cet ensemble l’agent se trouve ou quelle action dans l’ensembleil souhaite exécuter. Si les éléments contenus dans S et A sont continus ou autrement indé-nombrables, une représentation vectorielle est préférable. Parce la forme des états et actionsinfluencent les types de politiques pouvant être utilisés, il est possible de vouloir utiliser desvecteurs même si les ensembles sont discrets.

Propriété de Markov : La propriété de Markov (Sutton and Barto, 2018, p.61-65) est unélément essentiel de toute discussion sur les états en apprentissage par renforcement. Un étatmarkovien résume parfaitement la séquence des états antérieurs. Cela permet d’exprimer leschangements dans l’environnement uniquement à partir de l’état courant et de la prochaineaction. Si la propriété de Markov n’est pas respectée, la transition peut dépendre d’informa-tions contenues quelque part dans la séquence, mais absentes de l’état courant. L’équation2.1 définit formellement cette propriété dans la dynamique d’un environnement dont les étatssont markoviens.

t(st, at) = t(st, at, rt, st−1, at−1, ..., r1, s0, a0) (2.1)

Une politique efficace doit, au moins implicitement, tenir compte de la fonction de transitionparce que l’impact des actions de l’agent sur son environnement est à la base du signal derécompense. Elle dépend donc des mêmes informations que la fonction de transition. Cela si-gnifie que l’utilisation d’états de Markov simplifie grandement la tâche de l’agent, parce qu’ellepermet à la politique de dépendre uniquement de l’état courant. En pratique, la plupart desalgorithmes d’apprentissage par renforcement supposent que les états respectent la propriétéde Markov.

32

Il n’est malheureusement pas toujours possible d’utiliser des états de Markov. Si la différenced’information entre l’état courant et la séquence est faible, il peut être possible d’appliquerles algorithmes comme si la propriété de Markov était respectée et obtenir quand même desrésultats intéressants. Mais si la perte d’information est trop sévère, les algorithmes doiventêtre adaptés.

La conception d’algorithmes capables de travailler en l’absence d’états markoviens est un sujetde recherche actif dont la portée est généralement en dehors de ce mémoire. Cela dit, nousattirons l’attention du lecteur sur la méthode développée par Hausknecht and Stone (2015). Cetarticle contourne le problème des états non-markoviens en ajoutant un LSTM à l’architectureDQN utilisée par Mnih et al. (2013). La nature récurrente du LSTM est utilisée pour analyserune séquence d’états non markoviens pour produire un état résumé qu’on espère markovien.Ce résumé est ensuite utilisé par la politique pour choisir une action. Ce producteur de résumésest entraîné conjointement avec la politique pour maximiser les retours obtenus par l’agent.

2.1.3 Fonctions de transition et récompense

Les fonctions de transition (Sutton and Barto, 2018, p.51-53) et de récompense décrivent lesinteractions entre les états, les actions et l’objectif de l’agent. Pour cette raison, elles dépendentdans une certaine mesure des définitions des espaces d’états et d’actions. Elles doivent cepen-dant représenter fidèlement l’environnement dans lequel évolue l’agent, ce qui limite le rôle desconcepteurs dans leurs définitions. Il arrive aussi fréquemment que ces fonctions ne soient pasexplicitement représentées dans le programme d’apprentissage. Par exemple, si l’agent évoluedans un environnement physique, la transition d’un état à l’autre n’est pas obtenue par l’ap-plication d’une fonction mathématique. Elle est plutôt le résultat de l’interaction physique del’agent avec son environnement qui modifie celui-ci dans la réalité. Ce changement est captépar les senseurs de l’agent et c’est en comparant ce nouvel état à l’état antérieur qu’on peutreconnaître qu’il y a eu une transition. Dans ces situations, la fonction de transition est unconcept abstrait décrivant la dynamique de l’environnement plus qu’une véritable fonctionformelle qui la prescrit.

Si l’agent évolue dans un environnement virtuel, les fonctions de transition et de récompenseseront formellement définies et appliquées. Mais la nature de la tâche prescrit habituellementleur comportement. Si un agent joue aux échecs à travers un programme, les transitions entreles états de l’échiquier seront représentées dans le programme et formeront une fonction detransition, mais les règles du jeu d’échec sont prédéfinies et les concepteurs de l’agent nepeuvent pas arbitrairement les modifier.

Cela dit, certaines tâches n’ont pas de dynamique d’environnement prédéfinie. Dans les tâcheshautement abstraites représentant un processus cognitif, les états et actions représentent lesfaçons dont l’agent peut raisonner sur les données disponibles. Ces processus cognitifs peuvent

33

être modélisés de façon arbitraire par les concepteurs de l’agent.

Notons que les fonctions de transition et de récompense peuvent être connues ou inconnuesde l’agent. Si elles sont connues, l’agent peut utiliser cette connaissance dans son algorithmed’apprentissage, par exemple en dérivant les fonctions. Certaines techniques traditionnellesd’apprentissage par renforcement comme la programmation dynamique (Sutton and Barto,2018, p.89-110) ont besoin de connaître ces fonctions pour pouvoir s’exécuter. Cette connais-sance ne trivialise pas les problèmes d’apprentissage par renforcement. Par exemple, connaîtrel’objectif du jeu d’échec revient à connaître sa fonction récompense et savoir comment se dé-placent les pièces est équivalent à connaître sa fonction de transition. Nous supposons quen’importe quel joueur connaît ces deux informations avant de jouer sa première partie, maisjouer aux échecs reste une tâche complexe.

Dans beaucoup de problèmes réels, en revanche, l’agent ne connaît pas les fonctions de tran-sition et de récompense et doit apprendre à les estimer en interagissant avec l’environnement.Ces interactions permettent à l’agent d’obtenir les valeurs produites par ces fonctions sousdiverses conditions et il peut utiliser ces valeurs pour inférer la fonction sous-jacente.

2.1.4 Politique

À chaque étape n, l’agent utilise sa politique π pour choisir l’action à exécuter. Cette fonc-tion relie un état à une action : an = π(sn). On peut la modéliser de plusieurs façons. Laplus courante consiste à estimer la fonction de valeur. La fonction de valeur Qπ (Sutton andBarto, 2018, p.68-75) associe à chaque paire état-action (s, a) le retour espéré si l’agent choisitl’action a lorsqu’il est dans l’état s, puis suit les directives de la politique π. L’équation 2.2définit formellement la fonction de valeur pour les problèmes déterministes et épisodiques quinous intéressent, ce qui explique l’absence du facteur de décompte γ présent chez les auteurss’intéressant au cas général. On y note Sf l’ensemble composé de tous les états qui sont desétats finaux. On y remarque que Q est ultimement une application récursive de r, t et π.

Qπ(st, at) =

r(st+1) +Q(st+1, π(st+1)) si st+1 /∈ Sfr(st+1) si st+1 ∈ Sf

avec st+1 = t(st, at) (2.2)

Parce que la fonction de valeur indique le retour espéré d’une action, son utilisation informel’agent des conséquences à long-terme de celle-ci. À une étape n donnée, il est toujours optimalpour un agent de choisir l’action qui maximise la fonction de valeur pour l’état courant.

La fonction de valeur est généralement inconnue, c’est pourquoi les approches où la politiqueest basée sur Q doivent en apprendre un estimé Q. Parce que la politique dépend de la fonctionde valeur et que la fonction de valeur dépend de la politique, l’algorithme d’apprentissageoscille entre deux étapes. Elle commence par utiliser une politique pour obtenir l’expérience

34

nécessaire à l’amélioration de Q avant d’utiliser ce nouvel estimé pour améliorer la politique.L’algorithme poursuit cette boucle jusqu’à convergence de la politique et de Q.

Q peut être représentée sous forme tabulaire. Dans un tableau, chaque case contient la valeurestimée de Q pour la paire état-action correspondant à la case. Cette méthode a l’avantaged’être simple, mais peut rarement s’appliquer sur des problèmes réels. En effet, la taille del’espace des paires état-action est généralement suffisamment grand pour qu’un tel tableaudemande une quantité de mémoire prohibitive. Dans ces situations, une approche courammentutilisée est d’utiliser un approximateur de fonction paramétré comme un ANN. Cela permet demieux contrôler la demande en mémoire parce qu’elle est dictée par le nombre de paramètresde l’estimateur plutôt que par la taille de l’espace état-action.

Un approximateur de fonction paramétré peut aussi être utilisé pour directement représen-ter la politique. Ces politiques sont optimisées en utilisant le gradient de la récompense parrapport à leurs paramètres θ plutôt qu’en affinant un estimé de la fonction de valeur. C’estpourquoi ces méthodes sont appelées méthodes basées sur le gradient de la politique (policygradient methods) et sont basées sur le théorème du gradient de la politique (policy gradienttheorem). Ce théorème a d’abord été formulé pour le cas stochastique (Sutton et al. (2000)),puis généralisé pour inclure aussi le cas déterministe (Silver et al. (2014)). L’équation 2.3rapporte l’équation du théorème du gradient de la politique déterministe. Elle indique que legradient de l’objectif J par rapport aux paramètres θ de la politique est donné par l’espérancedu produit entre le gradient de l’action choisie par rapport à θ et le gradient de la fonctionde valeur par rapport à l’action choisie. Ce résultat montre qu’on peut optimiser directementla performance de l’agent par montée du gradient si la politique et la fonction de valeur sontdérivables. De ce théorème on obtient l’équation de mise à jour de la politique décrite parl’équation 2.4.

∇θJ(πθ) = Es∼ρπ [∇θπθ(s)∇aQπ(s, a)|a=πθ(s)] (2.3)

θi+1 = θi + α∇θπθ(sn)∇aQπ(sn, an)|a=πθ(sn) (2.4)

Il est facile de dériver la politique, parce que l’ANN qui la représente est connu et dérivable. Ladérivée de Q est cependant en pratique aussi rarement connue que Q elle-même. C’est pourquoiles algorithmes s’appuyant sur le théorème du gradient de la politique continue apprennentun estimé de la fonction de valeur, même s’ils ne l’utilisent pas pour guider directementla politique. Cette estimation peut être faite via une approche acteur-critique (Konda andTsitsiklis (2000)), où on apprend conjointement la politique avec une approximation de lafonction de valeur Q. Q est dérivable si on la représente par un ANN. (Silver et al. (2014)).

35

2.2 Agent ANN

Cette section développe l’idée selon laquelle l’optimisation supervisée d’un ANN à propagationavant peut être exprimée comme un problème d’apprentissage par renforcement où la politiquede l’agent est optimisée selon le théorème du gradient de la politique déterministe. Ce résultatmet en évidence l’utilisation par l’ANN d’une politique, même si celle-ci ignore la majorité del’information disponible dans le signal d’état.

On peut découper l’apprentissage par renforcement en quatre parties. Premièrement, la dyna-mique d’environnement, définie par les états s, les actions a et la fonction de transition t quiindique comment les actions modifient les états. Deuxièmement, la politique π qui indique àl’agent quelle action choisir en fonction de l’état. Troisièmement, la fonction de récompense rqui fournit à l’agent une rétroaction sur ses actions. Finalement, l’algorithme d’apprentissagequi utilise cette rétroaction pour améliorer la politique. Pour montrer que l’apprentissage su-pervisé est un problème d’apprentissage par renforcement, il faut établir une équivalence entreces quatre portions du problème RL et le problème de l’apprentissage supervisé.

Dynamique d’environnement Nous commençons notre démonstration par la dynamiqued’environnement qui inclut les états, les actions et la fonction de transition.

Un ANN supervisé transforme la représentation vectorielle x d’une instance du problème en lareprésentation vectorielle y d’une prédiction. x et y sont des représentations de l’état d’avan-cement de la résolution du problème, analogues à des états en apprentissage par renforcement.On peut poser s0 = x et s1 = y, avec s1 qui est un état final du problème.

Rappelons qu’étant donné un état sn, on peut déterminer le prochain état sn+1 si on connaîtdeux éléments : l’action an et la fonction de transition t. Le choix de l’action a est sous lecontrôle de l’agent et c’est le rôle de l’algorithme d’apprentissage de trouver une politique quichoisit les actions les plus appropriées. t reste en revanche en dehors du contrôle du processusd’apprentissage.

De la même façon, étant donné un état caché hn, on peut déterminer le prochain état hn+1

si on connaît deux éléments : les paramètres du réseau θ et son architecture f . Le choixde θ est du ressort de l’algorithme d’apprentissage, mais l’architecture f est fixée à l’avance.Suivant cette observation, on peut poser a = θ et t = f . En appliquant les substitutions poséesjusqu’ici, l’équation de transition sn+1 = t(sn, a) devient y = f(x, θ). On écrit habituellementy = fθ(x) en apprentissage supervisé, mais les deux notations sont ultimement équivalentes.Dans les deux cas, on a une représentation de l’état actuel du problème, un choix fait parl’algorithme d’apprentissage et une fonction prédéfinie qui décrit comment ce choix modifiel’état du problème.

Nous avons discuté à la section 2.1.3 de comment la fonction de transition est généralement

36

prescrite par la structure du problème à résoudre et hors du contrôle des concepteurs de l’agent,tout en signalant qu’il existait des exceptions. Manifestement, la définition des problèmessupervisés n’impose pas l’architecture de réseau à utiliser, ce qui place l’apprentissage supervisédans ces cas d’exception.

Politique La fonction politique indique comment l’agent choisit l’action à exécuter. Géné-ralement, cette décision est prise en fonction de l’état actuel sn. Dans un ANN, cependant,la paramétrisation θ de f ne dépend pas de x : les mêmes paramètres sont appliqués indé-pendamment de l’instance. Cela ne signifie pas que le réseau ne suit pas une politique, maisseulement que cette politique est plus simple qu’à l’habitude. En effet, nous pouvons adéqua-tement décrire le comportement du réseau avec la fonction : π(s) = θ ∀ s

Augmenter la granularité Nous avons jusqu’à maintenant considéré que la productiond’une prédiction par l’ANN est le fruit d’une seule action. Cette interprétation est conformeà celle généralement utilisée dans la littérature, ce qui nous permettait de mieux établir l’in-tuition derrière notre démonstration. Mais l’architecture que nous présenterons au chapitre3 dépend d’une interprétation où la prédiction est le fruit d’une séquence d’actions. Cetteinterprétation est tout aussi valide, puisque comme nous l’avons discuté à la section 2.1.2, ladéfinition de l’espace d’actions est arbitraire. Il suffit de définir de nouveaux espaces d’états etd’actions qui scindent le calcul de la fonction f implémentée par le réseau en plusieurs étapes.

Dans un ANN, cette subdivision de l’espace d’actions se fait le plus naturellement au niveaudes couches. L’équation 2.5 nous rappelle que f est une fonction composée de l’applicationrécursive de chaque couche du réseau. On y remarque que l’application de chaque ln, c’est àdire l’application de la fonction implémentée par la couche n, est équivalente à l’applicationd’une fonction de transition, avec tn = ln, sn = hn et an = θn. Les cas particuliers h0 et hNcorrespondent toujours à x et y, respectivement.

f(x, θ) = lN (hN−1, θN )

hn =

ln(hn−1, θn−1) si n > 0

x si n = 0

(2.5)

L’ajout d’un indice n à la fonction de transition indique que son comportement change enfonction de n. Mais n n’est pas une information contenue dans hn ou θn, qui sont les deuxparamètres de t. Pour régler ce problème, nous devons redéfinir notre signal d’état s pourqu’il devienne le tuple (hn, n). Avec cette redéfinition, t peut être formellement décrite parl’équation 2.6. À chaque transition, la fonction ln, paramétrée par θn, est appliquée à hn−1 etn est incrémenté pour indiquer le passage à la couche suivante.

37

t(s, a) = (ln(hn−1, a), n)|s=(hn−1,n−1) (2.6)

Après avoir redéfini la dynamique d’environnement pour permettre les transitions couchespar couches, il faut aussi redéfinir notre politique. Chaque couche d’un ANN est paramétréedifféremment, mais les couches sont toujours appliquées dans le même ordre, indépendammentde hn. Aussi, même si la politique dépend formellement du signal d’état entier s, elle n’utiliseen pratique que la portion de ce signal correspondant à n et ignore celle correspondant à hn.L’équation 2.7 décrit formellement cette politique.

πθ(s) = θn|s=(hn,n) (2.7)

Fonction récompense Maintenant que notre dynamique d’environnement a la granularitésouhaitée, nous pouvons poursuivre notre démonstration et définir la fonction récompense r.En apprentissage supervisé, la rétroaction est produite après la production d’une prédiction parle réseau. Cette rétroaction est la perte, une mesure de distance entre la prédiction du réseauy et la réponse attendue y. Étant donné que y est une valeur attribuée à la représentationd’instance x dans le jeu de donnée, on peut concevoir y comme une fonction vérité v quidépend de x. Cela nous permet de noter la perte : L(y, v(x)).

Cette structure de rétroaction peut être reproduite en apprentissage par renforcement en ayantune fonction récompense qui retourne 0 pour tout état non-terminal et l’inverse de la fonctionde perte pour un état terminal. La fonction de perte produit normalement une petite valeurpour indiquer un bon résultat. Pour l’utiliser dans un contexte de montée du gradient, il fautdonc l’inverser. On peut considérer que cette fonction est connue de l’agent puisque la fonctionde perte, et sa dérivée, sont directement utilisées dans l’algorithme de rétropropagation.

L’équation 2.8 définie la fonction de perte. On y remarque que L dépend de x, une informationne faisant pas partie jusqu’à maintenant de s, le seul paramètre de r. Nous résolvons leproblème est ajoutant x à notre signal d’état. Notre nouveau signal est le tuple (hn, n, x) et unétat est terminal si n = N . L’équation 2.9 met à jour notre définition de t pour tenir en comptel’ajout de x dans le tuple du signal d’état. Puisque la valeur de x n’est pas modifiée durant letraitement de l’instance, elle est simplement retransmise telle quelle à chaque transition.

r(s) =

−L(hn, v(x)) si n = N

0 si n 6= Navec s = (hn, n, x) (2.8)

t(s, a) = (ln(hn−1, a), n, x)|s=(hn−1,n−1,x) (2.9)

38

Parce que notre fonction r est nulle pour les états non-terminaux, on obtient Q en simplifiantl’équation 2.2 pour obtenir l’équation 2.10. Q dépend uniquement de la perte sur l’état final. Ladéfinition récursive de h peut être substituée dans l’équation principale pour obtenir l’équationcomplète pour un état donné.

Qπ(sn′ , an′) = −L(hN , v(x))|sn=(hn,n,x), an=θn

hn =

ln−1(hn−1, θn−1) si n 6= n′

hn si n = n′

(2.10)

Espace d’états et espace d’action Durant la démonstration, nous avons progressivementidentifié les informations nécessaires à la composition de notre signal d’état. Maintenant quenous les avons toutes identifiées, nous pouvons définir formellement les espaces d’états etd’actions.

Posons Hn, l’ensemble de toutes les représentations vectorielles possibles pour l’état caché à lacouche n. H0 est le cas particulier correspondant à X, l’ensemble de toutes les représentationsd’instance possibles et HN est le cas particulier correspondant à Y , l’ensemble de tous lesvecteurs possibles représentant une prédiction. Finalement, on pose S, l’ensemble composé detous les tuples (hn, n, x) avec hn ∈ Hn, 0 <= n <= N et x ∈ X.

Au niveau des actions, Θs, l’ensemble des actions possibles à l’état s, ne varie finalementqu’en fonction de n. On peut définir Θs = Θn, toutes les paramétrisations θn possibles pourla couche n.

Maintenant que nous avons défini tous les éléments d’un problème RL, nous pouvons monter lafigure 2.2 qui substitue les éléments RL de la figure 2.1 par les éléments d’un réseau superviséqui leur sont équivalents. Cette figure n’est qu’une autre façon de représenter le réseau décritpar la figure 1.1a.

Figure 2.2 – Réseau supervisé présenté comme un problème RL

39

Algorithme d’apprentissage Après avoir montré qu’on peut définir une dynamique d’en-vironnement, une politique et une fonction récompense à partir des concepts de l’apprentissagesupervisé, il reste à montrer une équivalence au niveau des algorithmes d’apprentissage. L’al-gorithme d’apprentissage de l’apprentissage supervisé est la composition de 3 algorithmes :la propagation avant, la rétropropagation et la descente du gradient. L’équation de mise àjour des paramètres (eq. 1.6) condense en une expression les trois algorithmes. La propagationavant est l’application des couches successives pour calculer y et la perte l(y, y) associée. Larétropropagation est le calcul de la dérivée de l(y, y) par rapport à chaque paramètre de θ. Ladescente du gradient est la mise à jour de θ en ajoutant une fraction α du gradient à la valeurcourante de θ.

Notons que la propagation avant est mathématiquement équivalente à l’évaluation de Q telleque définie à l’équation 2.10. Le calcul de la dérivée de Q par rapport aux paramètres dela politique de l’équation 2.4 s’obtient par rétropropagation et la descente du gradient estéquivalente à la montée du gradient si on inverse le signe du gradient. Cela étant dit, procédonsaux substitutions nécessaires pour montrer l’équivalence entre l’algorithme d’optimisation parle gradient de la politique déterministe (eq. 2.4) et l’algorithme d’apprentissage supervisé (eq.1.6).

L’équation 2.4 cherche à optimiser tous les paramètres de θ à chaque étape n. L’équation 2.7nous indique cependant que la politique retourne comme action seulement une portion de cesparamètres : θn. La dérivée par rapport à θ est donc nulle pour tous les paramètres /∈ θn.L’équation 2.11a reprend donc l’équation, mais en optimisant seulement θn à chaque étape n.

À l’équation 2.11b, on substitue Qπ(s, a) par son équivalent définie à l’équation 2.10 qui estla fonction de perte. Parce qu’on sait que πθ(sn) = θn, on remplace a et πθ(sn) par θn.

Finalement, on sait que la dérivée d’une variable par rapport à elle-même est toujours 1, cequi nous permet d’éliminer le terme ∇θnθn. On peut aussi substituer hN par son équivalent yet v(x) par son équivalent y. Après cette simplification et substitutions, on obtient l’équation2.11c qui est identique à l’équation 1.6

θi+1n = θin + α · ∇θnπθ(sn) · ∇aQπ(sn, θn) (2.11a)

θi+1n = θin + α · ∇θnθn · ∇θn l(hN , v(x)) (2.11b)

θi+1n = θin + α · ∇θn l(y, y) (2.11c)

40

2.3 Résumé du chapitre

L’apprentissage par renforcement (RL) est une discipline de l’apprentissage automatique quis’intéresse à la résolution de problèmes pour lesquels le comportement optimal attendu del’apprenant est inconnu. L’apprenant, appelé un agent, doit déterminer quel est le comporte-ment optimal en interagissant avec un environnement qui lui envoi périodiquement un signalde récompense. Ce signal lui indique si son comportement est conforme à ses objectifs.

Nous avons montré qu’un ANN entraîné sur une tâche supervisée se comporte essentielle-ment comme un agent dont les espaces d’états et d’actions sont continus. Le fait que l’agentconnaisse à la fois la dynamique d’environnement exprimée par la fonction de transition et lafonction de récompense lui permet d’évaluer directement la fonction de valeur Q plutôt qued’en apprendre une approximation. Parce que Q est dérivable par rapport aux paramètres dela politique, on peut optimiser la politique en utilisant une forme de l’algorithme de la montéedu gradient basée sur le théorème du gradient de la politique déterministe. Cet algorithmeest équivalent à la descente du gradient utilisée pour résoudre les problèmes d’apprentissagesupervisé. Finalement, toutes ces équivalences nous permettent de conclure que l’entraînementd’ANNs sur des problèmes supervisés constitue une classe spécifique de problèmes d’appren-tissage par renforcement.

Cette conclusion permet de considérer le réseau comme un agent dont le comportement estcontrôlé par une politique. Nous avons cependant constaté que cette politique est inusuellequand on la compare à celles habituellement apprises en apprentissage par renforcement. Eneffet, elle ignore une grande portion de l’information contenue dans le signal d’état. Cetteconstatation nous mène à poser l’hypothèse que les performances des ANNs pourraient êtreaccrues si leur architecture était révisée pour utiliser une politique considérant l’ensemble del’information disponible. Ces modifications sont le sujet du chapitre 3.

41

Chapitre 3

CNN à politique

Nous avons établis au chapitre précédent que les ANNs entraînés sur des tâches superviséespeuvent être considérés comme des agents d’apprentissage par renforcement utilisant une po-litique statique, c’est à dire une politique qui ne considère que l’étape de résolution n pourchoisir l’action an. Cela résulte en un agent qui utilise la même séquence d’action indépen-damment des circonstances dans lesquelles il se trouve. Même si l’utilisation de politiquesstatiques a permis aux ANNs d’obtenir dans les dernières années d’excellents résultats, il resteque de telles politiques sont inusuelles en apprentissage par renforcement. Intuitivement, onsait que la plupart des tâches du monde réel demandent de s’adapter aux circonstances. Maisoutre l’intuition, nous n’avons trouvé dans la littérature aucune trace du concept de politiquestatique. À la fois notre manuel de référence (Sutton and Barto (2018)) et les articles que nousavons consultés utilisent le terme "politique" pour désigner ce que nous appelons une politiquedynamique : une fonction qui relie l’ensemble du signal d’état à une action. Au meilleur denotre connaissance, l’utilisation d’une politique par les ANNs est donc une curiosité.

Ce constat nous amène à demander si l’utilisation d’une politique dynamique, ce qui seraitplus conforme au "véritable" apprentissage par renforcement, pourrait améliorer les ANNsentraînés sur des tâches supervisées. Ce mémoire cherche à fournir un début de réponse àcette question. Ce chapitre contient la principale contribution de ce mémoire à la littérature :la définition des réseaux convolutifs à politique (policy based convolutionnal neural network :PBCNN). Les PBCNNs utilisent une structure de prédiction de poids similaire à celle utiliséepar les hypernetworks statiques (Ha et al. (2017)). La prédiction de poids se fait à partir devecteurs contenant de l’information sur les résultats intermédiaires de calcul, contrairementaux hypernetworks qui utilisent des vecteurs fixes pour chaque couche. Ce changement permetde faire passer le réseau d’une politique statique à une politique dynamique. Nous espérons quece passage à une politique dynamique améliorera le réseau. Spécifiquement, nous cherchons àmesurer des gains en efficacité, c’est à dire un maintien des performances accompagné d’unebaisse des ressources consommées.

42

Nous ouvrons ce chapitre par une section sur la question de l’efficacité des ANNs. Nous yprésentons le problème ainsi que les différentes solutions existant dans la littérature. Nousaccordons une attention particulière aux hypernetworks statiques pour faciliter la présentationsubséquente des PBCNNS.

Les deux sections suivantes se consacrent à deux variantes de PBCNNs. La première est la plussimple et suppose que le signal d’état décrit au chapitre 2 respecte la propriété de Markov.C’est pourquoi nous la nommons PBCNN markovien. La deuxième suppose que le signal d’étatne respecte pas la propriété de Markov et ajoute une composante au réseau pour lui permettrede construire un état de Markov à partir d’une séquence d’observations non markoviennes.Nous nommons cette deuxième variante PBCNN non markovien.

3.1 Efficacité des ANNs

L’augmentation de la taille des réseaux explique en grande partie l’amélioration de ceux-ci dansles dernières années. Cette croissance engendre néanmoins trois problèmes. Premièrement, ilsdeviennent plus long à entraîner, ce qui allonge les cycles de développement. Deuxièmement lataille et le temps d’entraînement accrus augmentent l’utilisation de ressources informatiquesce qui engendre des coûts logistiques, financiers et environnementaux. Finalement, certainsmilieux de déploiement disposent de ressources limitées qui peuvent empêcher le déploiementde réseaux trop gros. C’est le cas, notamment, des plateformes mobiles et embarquées.

Ces trois raisons expliquent pourquoi il existe un intérêt grandissant pour accroître l’effica-cité des ANNs, c’est à dire diminuer leur consommation de ressources tout en préservantleurs performances. Cette section présente deux familles de méthodes ayant cet objectif : lacondensation des réseaux et la prédiction de poids. Nous nous attardons particulièrement auxhypernetworks statiques, une architecture basée sur la prédiction de poids dont nous nousinspirons pour définir les PBCNNs. Nous terminons la section en expliquant pourquoi nousestimons probable que l’utilisation d’une politique dynamique améliore l’efficacité de notreréseau.

3.1.1 Condensation d’un réseau existant

La condensation cherche à diminuer la taille d’un réseau déjà entraîné. La condensation di-minue les coûts d’exploitation d’un modèle et permet son déploiement sur des plateformesaux ressources plus limitées, mais ne diminue pas les ressources nécessaires à son entraîne-ment. Au contraire, la condensation est souvent elle-même coûteuse et son coût s’ajoute àcelui de l’entraînement. Il s’agit donc d’une approche intéressante, mais insuffisante pour ré-soudre le problème d’efficacité dans son ensemble. Cette section présente trois méthodes decondensation : l’émondage, la quantification des poids et la distillation des connaissances.

43

L’émondage consiste à éliminer du réseau les poids dont la valeur est proche de zéro. La sup-pression des poids entraîne généralement une perte de performance. C’est pourquoi l’émondageest suivi d’un réentraînement pour permettre au réseau de s’adapter à sa diminution de taille.Il est fréquent de procéder à plusieurs cycles d’émondage-réentraînement pour diminuer gra-duellement la taille du réseau. Ces nombreuses itérations font de l’émondage une techniquecoûteuse à mettre en application. L’émondage a d’abord été proposé dans Han et al. (2016)avant d’être perfectionné dans de nombreuses publications telles que Jia et al. (2018) et Wanget al. (2018)

La quantification de poids diminue la taille nécessaire au stockage de chaque paramètre duréseau. Après l’entraînement, on détermine n centroïdes à partir de la distribution des poidsappris. Les centroïdes sont conservés en mémoire dans une table dédiée. Les paramètres duréseau sont ensuite remplacés par l’indice de leur centroïde. À l’exécution, l’indice est utilisépour récupérer la valeur du centroïde. Si la table de centroïdes est de taille raisonnable, l’indicepeut être stocké en mémoire de façon plus succincte qu’un nombre réel (Han et al. (2016)).

La distillation de connaissances consiste à entraîner un petit réseau à reproduire les sortiesd’un réseau plus gros. Cette méthode peut être utilisée quand la sortie du réseau fournitplus d’information que l’étiquette du jeu d’entraînement. Dans les tâches de classification, parexemple, la distribution produite par le réseau contient de l’information sur la similarité desclasses, parce que les scores des classes similaires sont corrélés. Ces informations supplémen-taires aident le petit réseau à obtenir de meilleures performances. (Polino et al. (2018), Mishraand Marr (2018))

3.1.2 Prédictions de poids

Les poids d’un réseau ne sont pas indépendants les uns des autres. La corrélation entre leursvaleurs est si forte, que Denil et al. (2013) démontre que dans des conditions optimales, 95%des poids d’un réseau peuvent être prédits à partir du 5% restant.

La prédiction de poids cherche à utiliser cette corrélation pour diminuer la taille du réseau.Avec cette technique, les poids d’un réseau principal sont prédits par un deuxième sous-réseauplutôt que d’être appris directement par descente du gradient. Les paramètres optimisés parl’algorithme d’apprentissage ne sont plus les poids du réseau principal, mais ceux du sous-réseau. Parce que ce sous-réseau est moins volumineux que le réseau principal, cela permet dediminuer le nombre de paramètres total du système.

Nous concentrons notre intérêt sur trois architectures issues de la littérature de la prédictionde poids. Ces architectures affichent des similitudes intéressantes avec les PBCNNs. Il s’agitdes dynamic filter networks (DFN, Jia et al. (2016)), des hyperRNNs et des hypernetworksstatiques (Ha et al. (2017)). Nous présentons rapidement les DFNs et les HyperRNNs, maisnous concentrons nos explications sur les hypernetworks statiques parce que les PBCNNs sont

44

basés sur cette architecture.

Dynamic filter network

Les DFNs appliquent la prédiction de poids à la tâche de transformation d’image. À partird’un angle de rotation, le sous-réseau de prédiction produit les poids d’un filtre de convolutionproduisant cette rotation sur l’image d’entrée. À chaque inférence, une seule prédiction depoids est faite.

Les DFNs forment un des rares exemples de réseaux utilisant une politique dynamique. Eneffet, les poids du DFN varient en fonction de l’angle de rotation, qui est une caractéris-tique d’instance. Les PBCNNs se distinguent des DFNs de deux façons. Premièrement, ilssont utilisables sur des tâches de classification d’image plutôt que de transformation d’image.Deuxièmement, le réseau principal du DFN est composé d’une seule couche, alors que celuides PBCNNs peuvent en contenir un nombre arbitraire.

HyperRNN

Un hyperRNN est un arrangement de deux RNNs. Le deuxième RNN prédit les poids dupremier. Cette prédiction est faite à chaque étape de la séquence, de sorte que le comportementdu RNN principal change en fonction de la séquence analysée jusqu’à maintenant. Même siles RNNs ne sont pas des réseaux à propagation avant et qu’ils ne sont donc pas à proprementparlé couverts par l’analyse faite au chapitre 2, la capacité de l’hyperRNN à adapter soncomportement en fonction des résultats intermédiaires du traitement de la séquence lui confèredes propriétés semblables à celles d’un réseau à propagation avant utilisant une politiquedynamique. Le PBCNN se distingue du HyperRNN justement en étant un réseau à propagationavant qui peut être appliqué à des données non séquentielles.

Hypernetworks statique

L’hypernetwork statique est un CNN résiduel utilisé sur des tâches de classification d’images.Les poids de sa première couche li et sa dernière couche lf sont appris normalement pardescente du gradient. Entre li et lf , on retrouve 18 blocs résiduels bn de 2 couches convolutives.Les poids de ces couches ne sont pas appris directement, mais prédits par une fonction p àpartir d’un ensemble de vecteurs e définis en d dimensions. Les vecteurs e représentent ladistribution des poids de la couche et p décompresse l’information pour retrouver la couchecomplète. Les vecteurs e et les poids de p sont des paramètres du réseau appris par descentedu gradient.

L’application de p à un vecteur e produit un blocs de poids θ de dimensions s×3×3×s, ce quicorrespond à s filtres 3×3 acceptant s canaux d’entrées. Si une couche n est composée de plusde s couches ou doit accepter plus de s canaux d’entrées, ce blocs de poids est insuffisant pour

45

décrire l’entièreté de la couche. C’est pourquoi chaque couche n est définie par In vecteurs en,iauxquels sont appliqués p pour produire In blocs de poids θn,i. Les θn,i sont ensuite concaténéspour former des couches avec un plus grand nombre de filtres acceptant un plus grand nombrede canaux d’entrées. Cette méthode fonctionne parce que toutes les couches du réseau utilisentun nombre de filtres qui est un multiple de s. Étant donné une couche définie en In vecteurs,θn est l’ensemble de poids complet de dimensions s

√In× 3× 3× s

√In obtenu en concaténant

tous les θn,i.

La figure 3.1 illustre l’architecture générale de l’hypernetwork statique alors que le processusde concaténation des θn,i est illustré à la figure 3.2.

Figure 3.1 – Architecture de l’hypernetwork statique

Les premiers blocs de l’hypernetwork statique utilisent des couches de s filtres définis par 1vecteur en,i. Le réseau effectue une compression par pooling après chaque tranche de 6 blocs.

46

Figure 3.2 – Concaténation des θn,i pour former θn.

Chaque compression double le nombre de filtres utilisés par chaque couche ainsi que le nombrede canaux définis pour chaque filtre. Au total, chaque compression quadruple le nombre depoids contenus par chaque couche. On peut ainsi définir In = 4cn où cn est le nombre decompressions ayant eu lieu avec la couche n. Parce que les compressions se font aux 6 blocs,on peut poser c = n\6, où \ est l’opérateur de la division entière. Ha et al. (2017) utilise unevaleur de s de 16.

La fonction de prédiction des poids p est implémentée par un sous-réseau de deux couches plei-nement connectées p1 et p2. Bien qu’elle soit composée de deux couches pleinement connectées,p n’est pas un MLP : ces couches sont appliquées de façon un peu particulière. Comme dansun MLP, p1 prend en entrée un vecteur e en d dimensions et produit s× d dimensions. Maiscontrairement à un MLP, p2 accepte un vecteur de seulement d dimensions plutôt qu’un vec-teur de s× d dimensions. La sortie de p1 est interprétée comme s vecteurs de d dimensions etp2 est appliquée en parallèle sur chacun de ces vecteurs. Chaque application de p2 produit unvecteur de 3× 3× s dimensions correspondant à un filtre 3× 3 acceptant s canaux d’entrées.Chacun de ces vecteurs sont concaténés pour obtenir θn,i, un tenseur défini en quatre axes dedimensions s× 3× 3× s. La figure 3.3 illustre comment p est appliquée à un vecteur en,i pourobtenir θn,i.

Figure 3.3 – Application de p à en,i pour obtenir θn,i. Les annotations dans les tenseursintermédiaires indiquent leurs dimensions.

47

Les poids de li et lf ne sont pas prédits parce que leurs dimensions ne correspondent pas auxblocs θn,i produits par p. li est une couche convolutive définie en s filtres d’une profondeuréquivalente au nombre de canaux des images d’entrée. Les entrées sont habituellement desimages couleurs définies en trois canaux. Ainsi, à moins que s = 3, les poids de li ne peuventpas être prédits par p.

Le nature de la couche lf dépend de la tâche. Dans les tâches de classification, il s’agit d’unecouche pleinement connectée prenant en entrée un max pooling global de hN et produisant unvecteur dont le nombre de dimensions correspond au nombre de classes du problème. Encoreune fois, les poids d’une telle couche ne peuvent pas être produites par p. C’est pourquoi ilssont appris directement par descente du gradient.

La figure 3.1 illustre l’architecture de l’hypernetwork statique.

3.1.3 Politique dynamique

Nous posons l’hypothèse que le remplacement d’une politique statique par une politique dy-namique permet de diminuer l’espace des paramètres du réseau tout en préservant ces perfor-mances. Ceci correspondrait à une augmentation de son efficacité. Cette sous-section présentele raisonnement qui sous-tend cette hypothèse.

Comme expliqué au chapitre 1, le rôle d’une unité d’activation est d’extraire une caractéris-tique. Cette caractéristique est une combinaison de celles disponibles dans la représentationcachée produite par la couche précédente. Cette combinaison est décrite par les poids θ del’unité d’activation. Comme nous l’avons vu au chapitre 2, θ est analogue au concept d’actionen apprentissage par renforcement. Il s’en suit que si chaque action du réseau consiste à ex-traire de nouvelles informations sur l’instance traitée, le rôle de la politique est de déterminerquelles informations extraire.

Intuitivement, on peut supposer que l’utilité d’une caractéristique donnée varie en fonction del’instance. Sur une tâche de classification par exemple, une caractéristique pourrait servir àdépartager deux classes spécifiques et être peu utile dans la classification des autres classes.Si la politique du réseau est statique, cette caractéristique sera néanmoins extraite sur toutesles instances. Idéalement, parce que l’extraction d’une caractéristique implique l’utilisation deressources, nous voudrions que la caractéristique soit évaluée uniquement dans les cas où elleaide la classification.

Une politique dynamique peut potentiellement choisir les caractéristiques à extraire pour maxi-miser le gain d’information. Dans une tâche de classification par exemple, elle peut permettred’extraire dans les premières couches des informations générales qui permettent d’éliminer dela considération un certain nombre de classes. Elle pourrait ensuite concentrer son extrac-tion sur des caractéristiques qui permettent de départager spécifiquement les classes restantes.

48

Cette capacité à cibler les caractéristiques à extraire limiterait le nombre total de caractéris-tiques extraites ce qui diminuerait la taille de chaque couche. Cette diminution entraîne uneréduction de la consommation de ressources par le réseau.

3.2 PBCNN

Nous voulons vérifier l’hypothèse exprimée à la section 3.1.3 en formulant une architecturedotée d’une politique dynamique et en comparant ces performances à celles d’une architec-ture dotée d’une politique statique. Nous entendons par politique statique une politique dontl’action prescrite varie uniquement en fonction de l’indice n de la couche et qui ignore les ca-ractéristiques spécifiques de l’instance traitée. À l’inverse, une politique dynamique considèreà la fois l’indice n de la couche et les caractéristiques de l’instance. Une politique dynamiquefait en sorte que les poids des couches du réseau varient entre les instances, ce qui sembledemander l’utilisation de la prédiction de poids.

Les PBCNNs sont le résultat de cette démarche. Ils doivent leur nom au fait qu’ils utilisent unepolitique dynamique inspirée de celle utilisée en apprentissage par renforcement. Les PBCNNsréutilisent la fonction p des hypernetworks statiques, mais modifient les vecteurs que cettefonction prend en entrée pour inclure de l’information contextuelle. Nous avons testé deuxvariantes de PBCNNs. La première utilise uniquement l’information issue du signal d’état snque nous avons définis au chapitre 2 comme étant le tuple (hn, n, x). En procédant de la sorte,on suppose que sn est une source d’information suffisante pour choisir une action. Autrementdit, on suppose que sn respecte la propriété de Markov. C’est pourquoi nous avons qualifiécette variante de PBCNN markovien.

Notre deuxième variante ne présume pas de la véracité de cette hypothèse. Elle intègre unetechnique cherchant à apprendre à formuler un état markovien à partir d’une série d’observa-tions non markoviennes. Nous avons nommé cette deuxième variante PBCNN non markovien.

3.2.1 PBCNN markovien

Le PBCNN markovien reprend l’essentiel des caractéristiques de l’hypernetwork statique. Celasignifie qu’il s’agit d’un CNN résiduel de 18 blocs avec une taille de filtre initiale s de 16 canauxet une compression par pooling à chaque 6 blocs. Notre architecture se distingue par deuxmodifications : le changement de la définition des vecteurs en,i et le changement de méthodede normalisation dans les blocs résiduels.

Définition de e

Nous cherchons à ajouter une dimension contextuelle aux vecteurs en,i afin que le réseaupuisse ajuster les caractéristiques qu’il extrait en fonction des résultats obtenus aux extractions

49

Figure 3.4 – Architecture du PBCNN markovien. ++ est l’opérateur de concaténation

précédentes. Nous le faisons en considérant uniquement le tuple sn composé de (hn, n, x). C’està dire que nous ignorons la séquence d’états antérieurs [s0, ..., sn−1].

L’information relative aux extractions précédentes se trouve dans hn, c’est pourquoi nousvoulons modifier la fonction p pour qu’elle prédise les poids à partir d’une concaténation d’unvecteur en,i et d’un signal hn issus de hn. Notons que parce que chaque couche est représentéepar sa propre collection de In vecteurs en.i, les vecteurs en,i forment un signal issus de n. Parla concaténation de hn et en,i, on obtient ainsi une politique qui tient compte de hn et n.Comme nous l’avons expliqué à la section 1.3.2, le processus de composition et d’abstractionfait en sorte que hn est un condensé des informations pertinentes de x. Pour cette raison, nousavons décidé que la politique ignorerait la portion x du signal d’état afin de limiter le nombrede paramètres de p.

Deux raisons nous empêchent de simplement définir hn = hn. Premièrement, les hn produits

50

par un CNN comptent beaucoup trop de dimensions (plus de 16 000 seulement pour une petitegrille de 32× 32 éléments définis en 16 canaux) pour servir de vecteurs d’entrée aux couchespleinement connectées de p. Aussi, nous définissons hn comme étant le pooling maximal globalde hn. Cela condense l’information de hn en une seule dimension par feature map, une taillebeaucoup plus raisonnable.

Le deuxième problème est que l’augmentation du nombre de filtres dans les couches profondesdu réseau fait varier la taille de h. Or, p demande des entrées de taille fixe. Nous réglons leproblème en concaténant un nombre stable de dimensions de hn à chaque vecteur en,i. Lesdimensions de hn qui sont concaténées à un vecteur en,i donné sont déterminées par les filtresqui sont associés à ce vecteur e. Par exemple, si un en,i est utilisé pour prédire des poidsappartenant aux s premiers filtres d’une couche, on le concatène aux s premières dimensionsde hn. Quand le nombre de filtres double, le nombre de fractions de hn double également et lenombre de vecteurs e auxquels chaque fraction est concaténée double aussi. Cet arrangementassure à p des vecteurs d’entrée de taille fixe sur l’ensemble du réseau. Notons cependant qu’ilprésente l’inconvénient de limiter les interactions entre les canaux : chaque groupe de s filtresne dépendent que des caractéristiques extraites par le même groupe de s filtres à la coucheprécédente plutôt que de dépendre de l’ensemble des caractéristiques extraites.

La figure 3.4 montre comment l’introduction de hn modifie l’architecture de l’hypernetworkstatique pour former le PBCNN markovien.

Méthode de normalisation

Comme beaucoup de CNNs, les hypernetworks statiques utilisent la normalisation par batch.Nous avons cependant remarqué qu’elle provoquait de l’instabilité numérique lorsque utiliséedans le PBCNN markovien. Les raisons qui expliquent cette incompatibilité ne sont pas absolu-ment claires. Néanmoins, il semble raisonnable de supposer qu’elle est causée par l’introductionde la politique dynamique.

La normalisation par batch considère que toutes les valeurs produites par une unité d’activa-tion font partie d’une même distribution. Cela est raisonnable si toutes ces valeurs représententune même caractéristique, puisque cela permet de déterminer la présence relative d’une carac-téristique donnée par rapport à toutes les instances de cette caractéristique. Mais l’ajout dela politique dynamique fait en sorte que la caractéristique extraite par une unité d’activationvarie en fonction de l’instance. Dans ces conditions, la normalisation par batch compare et nor-malise des quantités qui n’ont pas un véritable lien entre elles. Il est possible que cela amènede l’instabilité. Il est cependant intéressant de noter que nous n’avons pas remarqué cetteinstabilité avec les PBCNNs non markoviens qui utilisent pourtant eux aussi une politiquedynamique.

Nous avons réglé les problèmes d’instabilité en changeant la méthode de normalisation utili-

51

sée par les blocs résiduels. Nous avons testé la normalisation par couche et la normalisationpar instance. Les deux ont éliminé l’instabilité numérique. Elles nous semblent égalementplus appropriées dans nos circonstances puisqu’elles indiquent la force relative des différentescaractéristiques au sein d’une même instance sans présumer de liens statistiques entre les ins-tances. Nous avons comparé formellement les résultats obtenus par les deux méthodes dansnos expériences et présentons les résultats de cette comparaison au chapitre 4.

Mises à part ces modifications au vecteur d’entrée de la fonction p et le changement de fonctionde normalisation, notre implémentation du PBCNN markovien est identique à l’hypernetworkstatique présenté dans Ha et al. (2017).

3.2.2 PBCNN non markovien

Le PBCNN markovien repose sur l’hypothèse que le tuple (hn, en), où en est l’ensemble desvecteurs en,i associés à la couche n, constitue un état de Markov. Cette hypothèse nous semblepeu susceptible d’être vérifiée dans la réalité. La nature combinatoire des caractéristiquescomposant hn fait en sorte que leurs valeurs ne peuvent être interprétées que dans le contextedes caractéristiques les ayant précédées dans hn−1. Les valeurs de hn−1 sont elles-mêmes descombinaisons de hn−2 et ainsi de suite jusqu’à la racine du réseau. Pour cette raison, il sembleprobable que la connaissance de la séquence [h0, ..., hn−1] puisse influencer les décisions duréseau. Pour tenir compte de cette possibilité, nous définissons le PBCNN non markovien,une variante du PBCNN qui ne suppose pas que s constitue un signal d’état markovien. Elleapprend plutôt à produire un signal d’état markovien à partir de la séquence [s0, ..., sn−1]. Lafigure 3.5 illustre l’architecture du PBCNN non markovien.

Figure 3.5 – Architecture du PBCNN non markovien

Dans l’hypernetwork statique, en,i et en+1,i sont deux vecteurs distincts dont les valeurs sont

52

apprises séparément par descente du gradient. Nous modifions cette situation en posant queen+1,i = r(en,i, ˜hn+1), avec r une fonction implémentée par un RNN. en+1,i est ensuite utiliséepar p pour produire θn+1,i en utilisant la même fonction p que précédemment. Ce change-ment modifie le rôle de en,i. Plutôt que d’être une représentation de la distribution des poidsde la couche n, il devient un résumé de la séquence des hn rencontrés jusqu’à présent etsert de mémoire au RNN r. Cette organisation est une application de la technique décritedans Hausknecht and Stone (2015) qui consiste à utiliser un RNN pour transformer une séried’états non-markoviens en une représentation vectorielle pouvant être utilisée comme un étatmarkovien.

Lorsque en+1,i dépend de en,i, il devient plus difficile d’augmenter In dans les couches profondesdu réseau. Il faut déterminer comment est initialisée la nouvelle chaîne de vecteurs mémoires.Nous avons décidé d’éviter ce problème en fixant le nombre de filtres utilisés par le PBCNNmarkovien à 32, le nombre médian de filtres utilisés par l’hypernetwork statique. Étant donnéle s de 16, cela nous donne une valeur de I unique de 4 : In = 4 ∀ n.

Malheureusement, une cellule RNN contient plus de paramètres que ceux contenus dans lesvecteurs en,i utilisés par l’hypernetwork statique. Cela signifie que même si dans un PBCNNnon markovien, la grande majorité des en,i ne sont pas des paramètres, l’espace de paramètresdu réseau complet augmente par rapport aux hypernetworks. Parce que nous cherchons à dimi-nuer la taille du réseau et non à l’augmenter, nous avons utilisé un autre truc de segmentationpour diminuer l’espace de paramètres de la cellule RNN.

Commençons par rappeler que le nombre de paramètres de chaque porte d’une cellule RNN àporte dépend de la taille de la donnée d’entrée et de la taille de la mémoire m de la cellule. Eneffet, chaque porte prend en entrée la concaténation de xn avec mn−1 et produit un vecteurdont la taille correspond à celle de la mémoire. Dans un PBCNN non markovien, xn = hn etmn−1 = en−1,i, ce qui donne une taille de xn de 32 et une taille d de mn−1 de 64. À chaque n,La cellule est appliquée en parallèle sur les I vecteurs de mémoire pour les maintenir à jour.

Nous diminuons la taille de la cellule en redéfinissant mn pour utiliser de plus petits vecteurs.Cela fait en sorte que chaque porte de la cellule est composée d’un plus petit nombre d’unitéd’activation, ce qui diminue le nombre de paramètres demandé par la porte. Nous segmentonschaque en,i en J segments de taille égale pour obtenir un ensemble de sous vecteurs en,i,j detaille d/J . On redéfinit mn−1 = en−1,i,j , ce qui diminue la taille de m d’un facteur J . La celluleest toujours appliquée en parallèle sur tous les en,i,j pour les maintenir à jour.

p est toujours appliquée en parallèle sur une collection de en,i pour obtenir les blocs de poidsθn,i. Chaque en,i est obtenu en concaténant les J en,i,j ayant les mêmes indices n et i. Cette seg-mentation de en,i empêche le RNN de combiner les dimensions de en,i appartenant à différentssegments. Ces restrictions sont susceptibles d’avoir un impact négatif sur les performances duréseau. C’est pourquoi nos expériences mesurent l’évolution des performances pour différentes

53

valeurs de J.

3.3 Résumé

Avant de terminer ce chapitre, résumons les deux architectures que nous avons développé.

Le PBCNN markovien est une variation de l’hypernetwork statique où le vecteur d’entrée dela fonction de prédiction de poids p est modifié pour inclure hn, un vecteur rassemblant del’information spécifique à l’instance et aux résultats intermédiaires du traitement. En faisantvarier la définition de hn , on peut définir plusieurs variations de PBCNNs markoviens. Parceque sous cette architecture, les caractéristiques extraites par une même unité d’activationvarient en fonction de l’instance, il est probablement préférable d’utiliser une méthode denormalisation différente de la normalisation par batch.

Le PBCNN non markovien est une variation du PBCNN markovien qui utilise un RNN pourcalculer en,i,j à partir de en−1,i,j et hn. en,i redevient la seule entrée de la fonction de prédictionp. La segmentation de en,i en J facteurs a pour but de diminuer la taille des cellules RNNs.Plusieurs configurations du PBCNN markovien peuvent être définies en faisant varier le typede cellule et le nombre de couches dans le RNN, le facteur de segmentation du vecteur deprédiction, la façon de définir le vecteur hn et la méthode de normalisation utilisée par lesblocs résiduels.

Les expériences menées dans le cadre de ce mémoire cherche à s’assurer que ces deux archi-tectures peuvent effectivement être entraînées par descente du gradient et à comparer leursperformances à celles de l’hypernetwork statique. Les détails d’expérimentation et les résultatssont présentés au chapitre 4.

54

Chapitre 4

Expérimentations

Ce chapitre présente les expériences menées pour mesurer l’efficacité des PBCNNs et les ré-sultats obtenus. Il est composé de quatre sections. La première décrit les tâches et les jeuxde données utilisés dans les expériences. La seconde identifie notre base de comparaison. Latroisième discute du protocole expérimental et des détails d’entraînement. Finalement, la qua-trième présente les résultats obtenus.

4.1 Tâche et protocole

Nos expériences ont été faites sur la tâche de classification d’image CIFAR10. CIFAR10 estun jeu de données composé de 60000 images de résolution 32 × 32. Chaque image représenteune classe d’objet parmi 10. Le réseau reçoit en entrée une image et doit prédire correctementla classe de l’objet qui y est représenté. Cinq classes représentent des espèces d’animaux. Lescinq autres représentent des types de véhicules.

Nous avons choisi cette tâche parce qu’elle a le bon niveau de complexité pour tester unenouvelle architecture de vision numérique. CIFAR10 est suffisamment complexe pour mettreà l’épreuve le concept de l’architecture, mais assez simple pour permettre l’entraînement deréseaux relativement petits. Les petits réseaux sont plus rapides à entraîner, ce qui permetd’itérer plus rapidement sur la nouvelle architecture. Il s’agit ainsi d’un bon compromis parrapport à d’autres jeux de données classiques de classification d’images. La tâche MNIST,par exemple est tellement simple qu’elle peut être résolue par un MLP et la tâche ImageNetdemande typiquement des réseaux de plusieurs millions de paramètres pour être résolue. Notreréseau, en comparaison, ne compte que dix milles paramètres. CIFAR10 a également l’avantaged’être la tâche utilisée pour évaluer l’hypernetwork statique (Ha et al. (2017)) qui nous sertde base de comparaison.

55

4.2 Base de comparaison

Puisque les PBCNNs peuvent être décrits à plusieurs égards comme des modifications deshypernetworks statiques, il semble naturel d’utiliser ces derniers comme base de référence. Lelecteur peut se référer à la section 3.1.2 pour se rappeler les détails de l’architecture hypernet-work statique. Cette section se concentre sur les détails d’entraînement.

L’entraînement de l’hypernetwork dans Ha et al. (2017) est faite en batch de 128 instanceset dure 1 000 000 de batchs. Considérant la taille du jeu d’entraînement, cela correspond à2133 époques. Le taux d’apprentissage débute à 0.002 et est diminué périodiquement durantl’entraînement. Nous utilisons l’implémentation PyTorch de Mittal (2019). Cette implémenta-tion utilise le gestionnaire de taux d’apprentissage MultiStepLR qui diminue de moitié le tauxd’apprentissage à des moments prédéterminés. Parce que la variation du taux d’apprentissageemployé dans l’article original ne correspond pas à une diminution de moitié, l’horaire dutaux d’apprentissage que nous utilisons diffère légèrement de celui de l’article original. Mit-tal (2019) diminue de moitié le taux d’apprentissage après 168000, 336000, 400000, 450000,550000 et 600000 batchs. L’optimisation est faite avec l’algorithme ADAM. Une normalisationL2 de 0.0005 est appliquée sur les poids du réseau. Le jeu d’entraînement est augmenté parun padding de 4 pixels suivi d’une coupe (crop) aléatoire.

Nous avons essayé sans succès de reproduire les résultats publiés dans Ha et al. (2017). Nousobtenons une exactitude sur l’ensemble de test de 86%, ce qui est 7% plus faible que cequi est rapporté dans l’article. L’implémentation de Mittal (2019) est conforme aux détailsd’entraînement mentionnés dans l’article, de sorte qu’il est difficile de déterminer la sourcede cette différence. Il est possible que les résultats publiés correspondent à une initialisationaléatoire du réseau particulièrement favorable. Pour ce mémoire, nous comparons les résultatsmoyens sur 5 entraînements de nos PBCNNs aux résultats moyens sur 5 entraînements quenous avons obtenus en entraînant l’hypernetwork statique.

L’horaire d’entraînement utilisé par Ha et al. (2017) est incroyablement long et en analysantla courbe de progression de la perte et de l’exactitude d’un entraînement suivant cet horaire,on remarque que les performances du réseau convergent bien avant la fin de l’entraînement.Contrairement à Ha et al. (2017), nous ne sommes pas affiliés à Google Brain et les ressourcescomputationelles à notre disposition sont plus limitées. Nous ne pouvons pas nous permettred’entraîner nos modèles pendant des centaines d’époques sans amélioration des performances.Nous avons ainsi raccourci les périodes où chaque taux d’apprentissage est utilisé pour mieuxrefléter le moment où nous avons constaté l’atteinte de plateaux dans les performances. Aprèscomparaison, nous avons constaté que les résultats finaux obtenus avec l’horaire original etceux obtenus avec l’horaire raccourci étaient essentiellement identiques. C’est pourquoi nousavons produit tous nos résultats avec cet horaire raccourci. Avec cet horaire, nous diminuonsde moitié le taux d’apprentissage après 75, 150, 200, 225, 250 et 275 époques.

56

Il est impossible d’exclure que les résultats rapportés par Ha et al. (2017) soit le fruit d’uneinitialisation aléatoire particulièrement favorable suivie d’un entraînement très long. Si c’estle cas, notre réduction du temps d’entraînement nous condamnerait à être incapable de re-produire les résultats. Nous sommes cependant prêts à courir ce risque dans la mesure oùil est simplement irréaliste pour nous de conduire toutes nos expériences avec des horairesd’entraînements de plus de 2000 époques.

4.3 Protocole

Notre expérimentation consiste à entraîner différentes configurations des deux PBCNNs décritsau chapitre 3 pour comparer les ressources utilisées et les performances obtenues sur l’ensemblede tests à celles de l’hypernetwork statique. La tâche utilisée est CIFAR10 et nous utilisonsessentiellement le protocole d’entraînement utilisé par Ha et al. (2017) et décrit à la section 4.2.Nous apportons cependant deux légères modifications. Premièrement, nous utilisons l’horaireraccourci qui a déjà été décrit. Deuxièmement, nous avons retiré la pénalité L2 sur les poidsdu réseau parce que nos expériences préliminaires ont indiqué que cette pénalité nuisait auxperformances du réseau. Chaque expérience est faite 5 fois en faisant varier l’initialisationaléatoire du réseau. Nous rapportons le résultat moyen sur ces 5 entraînements.

À l’exception des modifications décrites au chapitre 3 et des modifications apportées pourchaque expérience et qui seront explicitement mentionnées, les détails d’architecture de nosPBCNNs sont identiques à ceux des hypernetworks statiques. Cela inclut le nombre et la tailledes couches, l’organisation résiduelle du réseau, etc.

Nous mettons à l’essai les deux catégories de PBCNNs décrits au chapitre 3 : les PBCNNsmarkoviens et les PBCNNs non-markoviens. Pour chaque catégorie, certains hyperparamètresdu réseau ont été identifiés pour expérimentation. Nous cherchons à optimiser ces hyperpara-mètres afin de maximiser les performances et minimiser l’utilisation de ressources.

Pour limiter le nombre de permutations à tester, nous utilisons la méthode d’optimisationd’hyperparamètres décrite à la section 1.4.6 qui considère chaque hyperparamètre commeindépendant des autres. Il est possible que cette approche nous empêche de détecter une"combinaison magique" qui offre de meilleures performances, mais c’est une approche quinous semble raisonnable pour avoir un compromis entre le nombre d’essais et l’atteinte debons résultats.

Une fois nos choix architecturaux fixés, nous comparons chaque catégorie de PBCNNs auxhypernetworks. Nous comparons sous 5 configurations. Pour la première, les dimensions descouches sont celles décrites à la section 3.1.2. Pour la seconde, le nombre de filtres de chaquecouche est réduit de moitié. Pour la troisième, quatrième et cinquième, nous revenons à lapleine taille du réseau, mais entraînons avec seulement 75%, 50% et 25% du jeu d’entraînement,

57

respectivement. Évidemment, nous nous attendons à une dégradation des performances pourles configurations 2 à 5 par rapport à la première. Nous espérons que la politique flexiblefacilitera l’apprentissage de solutions capables de généraliser et qu’elle limitera la perte deperformance par rapport aux hypernetworks.

4.4 PBCNN markovien

Nous avons identifié un seul hyperparamètre à optimiser dans la définition du PBCNN marko-vien : le choix de la fonction de normalisation utilisée par les blocs résiduels. Comme mentionnéà la section 3.2.1, la normalisation par batch repose sur l’hypothèse que chaque feature mapreprésente la même caractéristique pour chaque instance de la batch. Cette hypothèse ne s’ap-plique pas aux PBCNNs et nous croyons que la normalisation par batch cause de l’instabiliténumérique pour cette raison. C’est pourquoi nous voulons tester d’autres méthodes de nor-malisation. Nous avons identifié deux méthodes de normalisation susceptibles de convenir auxPBCNNs markoviens : la normalisation de couche dont la distribution de normalisation estcomposée de toutes les valeurs de toutes les features maps d’une instance donnée et la nor-malisation d’instance dont la distribution de normalisation considère chaque feature map dechaque instance séparément.

Le tableau 4.1 contient les résultats de notre comparaison entre les deux méthodes de normali-sation. On remarque la normalisation par couche bénéficie d’un léger avantage d’un peu moinsd’un point de pourcentage en exactitude sur l’ensemble de validation. Les deux méthodes sontidentiques en termes de ressources utilisées.

Table 4.1 – PBCNN markovien : Performances et ressources en fonction de la méthode denormalisation

Type de normalisation Paramètres Calculs(FLOPS) Exactitudeentraînement

Exactitudevalidation

Normalisation de couche 7.06e+04 2.14e+08 0.91 0.8391Normalisation d’instance 7.06e+04 2.14e+08 0.88 0.8308

4.5 PBCNN non markovien

Pour les PBCNNs non markoviens, nous avons identifié trois hyperparamètres avec lesquelsexpérimenter : le facteur de segmentation J de en,i, le type de cellules RNNs utilisé et leurnombre. L’utilisation de la normalisation par batch pose les mêmes problèmes théoriques quedans le PBCNN markovien, mais nous n’avons pas remarqué d’instabilité numérique avec sonutilisation dans le PBCNN non markovien. Considérant que les expériences sur le PBCNNnon markovien ont été faites en premier, nous n’avons identifié le problème causé par la nor-

58

malisation par batch qu’après l’obtention de nos résultats. C’est pourquoi nous ne comparonspas dans cette section les autres options de normalisation.

L’optimisation de chaque hyperparamètre constitue une phase d’expérimentation. En phase 1,nous considérons la segmentation de en,i en 1, 2 ou 4 segments. En phase 2, nous comparons lescellules LSTMs aux cellules GRUs. En phase 3, nous mesurons les gains obtenus en utilisantun RNN multicouche (section 1.5.3) pour représenter r. Chaque couche maintient sa collectionde ed,n,i,j et les cellules profondes mettent à jours chaque ed,n,,i,j à partir du vecteur équivalentde la cellule précédente : ed,n,i,j = rd(ed,n−1,i,j , ed−1,n,i,j).

À chaque phase, nous comparons les résultats obtenus en exactitude sur l’ensemble de valida-tion ainsi que le nombre de paramètres et la quantité d’opérations sur point flottant nécessairepour traiter une instance. Nous nous basons sur ces trois métriques pour choisir la valeur d’hy-perparamètre qui sera retenue pour les phases d’expérimentation ultérieures.

Le tableau 4.2 indique les résultats obtenues pour la phase 1. Les réseaux y ont été entraî-nés avec 1 cellule GRU et un nombre variable de segments pour en,i. On y constate que lasegmentation en 4 segments permet de réduire l’espace de paramètres d’environ 15% tout enpréservant les performances essentiellement au même niveau. C’est pourquoi nous conserveronsce niveau de segmentation pour les phases ultérieures.

Table 4.2 – Phase 1 : Résultats pour différentes valeurs de J et 1 cellule GRU

Valeur de J Paramètres Calculs(FLOPS) Exactitudeentraînement

Exactitudevalidation

1 9.19e+04 3.72e+08 0.88 0.81102 8.11e+04 3.69e+08 0.88 0.80894 7.81e+04 3.68e+08 0.87 0.8095

Table 4.3 – Phase 2 : Résultats pour 1 cellule RNN de différents types avec J = 4

Type de cellule RNN Paramètres Calculs(FLOPS) Exactitudeentraînement

Exactitudevalidation

GRU 7.81e+04 3.68e+08 0.87 0.8064LSTM 7.86e+04 3.68e+08 0.87 0.7955

Le tableau 4.3 indique les résultats obtenus pour la phase 2 qui compare les cellules RNNsGRU et LSTM. La différence de performance et de paramètres entre les deux sont faibles, maisavantages le GRU dans les deux cas. C’est pourquoi c’est le type de cellule qui est retenuepour la suite.

Le tableau 4.4 indique les résultats obtenus pour la phase 3 où nous avons fait varier le nombrede cellules RNNs utilisées . Les meilleures performances ont été obtenues par la séquence de

59

Table 4.4 – Phase 3 : Résultats pour un nombre variable de cellules GRUs avec J = 4

Nombre de cellules RNN Paramètres Calculs(FLOPS) Exactitudeentraînement

Exactitudevalidation

1 7.81e+04 3.68e+08 0.87 0.80642 7.96e+04 3.68e+08 0.89 0.81444 8.27e+04 3.69e+08 0.89 0.8059

deux cellules, au prix d’une augmentation du nombre de paramètres de 2%. Cela nous sembleêtre un prix acceptable pour une augmentation des performances d’un peu moins d’un point depourcentage en exactitude. Notre ensemble d’hyperparamètres pour le PBCNN non markovienest donc de 2 cellules GRUs et 4 segments de en,i.

4.6 Comparaison à la base de référence

Avec nos hyperparamètres choisis pour les PBCNNs markoviens et non markoviens, nous com-parons les deux architectures aux hypernetworks statiques. Tel que mentionné à la section 4.3,nous les comparons en faisant varier le nombre de canaux d’analyse et la quantité de donnéesd’entraînement utilisée, afin de vérifier si une architecture résiste mieux à une diminution deces ressources disponibles. Tous les résultats attribués aux hypernetworks statiques ne sontpas ceux rapportés par Ha et al. (2017), mais ceux que nous avons obtenus après nos propresentraînements de l’implémentation de Mittal (2019).

4.6.1 Nombre de canaux d’analyse

Dans cette sous-section, nous comparons les réseaux "complets" aux réseaux "réduits". Par"complet", nous entendons les réseaux utilisant le nombre de canaux d’analyse mentionnéprécédemment dans le mémoire : 16, puis 32, puis 64 pour l’hypernetwork statique et le PBCNNmarkovien et 32 pour le PBCNN non markovien. Par "réduit", nous entendons un nombre decanaux d’analyse réduit de moitié, donc 8, puis 16, puis 32 pour l’hypernetwork statique et lePBCNN markovien et 16 pour le PBCNN non markovien. Le tableau 4.5 présente les résultatspour les réseaux complets et le tableau 4.6 présente ceux pour les réseaux réduits.

Table 4.5 – Performances des différents réseaux à taille pleine et sur ensemble d’entraînementcomplet

Réseau Paramètres Calculs(FLOPS) Exactitudeentraînement

Exactitudetest

Hypernet 1.05e+05 2.43e+08 0.96 0.8626PBCNN markovien 7.06e+04 2.14e+08 0.91 0.8391

PBCNN non-markovien 7.96e+04 3.68e+08 0.89 0.8144

60

Table 4.6 – Performances des différents réseaux à taille réduite et sur ensemble d’entraînementcomplet

Réseau Paramètres Calculs(FLOPS) Exactitudeentraînement

Exactitudetest

Hypernet 5.57e+04 6.89e+07 0.90 0.8427PBCNN markovien 4.56e+04 6.36e+07 0.8337 0.7988

PBCNN non-markovien 4.43e+04 1.00e+08 0.81 0.7698

Ces résultats sont peu reluisants. D’abord, ils nous indiquent que les PBCNNs sont moinsrésistants à une diminution de leur nombre de filtres que l’hypernetwork statique. En effet,l’hypernetwork a perdu 2% d’exactitude, alors que la perte des deux PBCNNs est plus de l’ordredes 4%. Pire, on remarque que les performances de l’hypernetwork réduit restent meilleurque celles des PBCNNs de taille complète. Cela nous indique que l’hypernetwork n’est passeulement plus performant que le PBCNN, mais aussi plus efficace, ce qui est clairementcontraire à nos objectifs.

4.6.2 Taille du jeu d’entraînement

Pour vérifier la capacité des réseaux à généraliser à partir d’un plus petit nombre d’exemples,nous les avons entraînés avec une fraction du jeu d’entraînement de CIFAR10. Pour éviterde mesurer une baisse de performance liée à une diminution du nombre d’optimisations, nousavons augmenté le nombre d’époques proportionnellement à la diminution de la taille du jeud’entraînement. Cela permet au nombre total de batchs vues par le réseau de rester stable. Letableau 4.7 rapporte les résultats pour un entraînement avec 100% du jeu d’entraînement, letableau 4.8 pour un entraînement avec 75% , le tableau 4.9 pour un entraînement avec 50%et le tableau 4.10 pour un entraînement avec 25%.

Table 4.7 – Performances des différents réseaux à taille complète et sur ensemble d’entraîne-ment complet

Réseau Paramètres Calculs(FLOPS) Exactitudeentraînement

Exactitudetest

Hypernet 1.05e+05 2.43e+08 0.96 0.8626PBCNN markovien 7.06e+04 2.14e+08 0.91 0.8391

PBCNN non-markovien 7.96e+04 3.68e+08 0.89 0.8192

Ici encore, on remarque que les PBCNNs sont déclassés par l’hypernetwork statique. Leursperformances sont inférieures lorsque entraînés sur l’ensemble d’entraînement complet et dé-croissent plus rapidement lorsqu’on restreint le nombre d’exemples d’entraînement.

61

Table 4.8 – Performances des différents réseaux à taille complète et sur 75 % de l’ensembled’entraînement

Réseau Paramètres Calculs(FLOPS) Exactitudeentraînement

Exactitudetest

Hypernet 1.05e+05 2.43e+08 0.96 0.8410PBCNN markovien 7.06e+04 2.14e+08 88 0.8061

PBCNN non-markovien 7.96e+04 3.68e+08 0.88 0.7819

Table 4.9 – Performances des différents réseaux à taille complète et sur 50 % de l’ensembled’entraînement

Réseau Paramètres Calculs(FLOPS) Exactitudeentraînement

Exactitudetest

Hypernet 1.05e+05 2.43e+08 0.96 0.8142PBCNN markovien 7.06e+04 2.14e+08 0.87 0.7642

PBCNN non-markovien 7.96e+04 3.68e+08 0.86 0.7430

Table 4.10 – Performances des différents réseaux à taille complète et sur 25 % de l’ensembled’entraînement

Configuration Paramètres Calculs(FLOPS) Exactitudeentraînement

Exactitudetest

Hypernet 1.05e+05 2.43e+08 0.95 0.7490PBCNN markovien 7.06e+04 2.14e+08 0.84 0.6867

PBCNN non-markovien 7.96e+04 3.68e+08 0.80 0.6627

62

Discussion et conclusion

Retour sur les objectifs

Au début de nos travaux, nous avions trois objectifs de recherche. Premièrement, nous voulionsexplorer les liens théoriques pouvant être tracés entre l’apprentissage supervisé et l’apprentis-sage par renforcement. Deuxièmement, nous voulions utiliser ces liens théoriques pour formulerune nouvelle architecture d’ANN pouvant être utilisée sur des tâches supervisées. Finalement,nous voulions comparer les performances de cette architecture par rapport aux architecturesexistantes. Nous espérions particulièrement augmenter leur efficacité, c’est à dire réduire laquantité de ressources utilisée pour obtenir une performance donnée.

Nous pouvons affirmer que notre premier objectif de recherche est pleinement rempli. Nousavons démontré que l’algorithme de descente du gradient par rétropropagation utilisé pourentraîner les ANNs supervisés est équivalent à celui utilisé pour optimiser une politique dé-terministe par son gradient. Cette équivalence nous indique qu’on peut considérer la paramé-trisation θn d’une couche n comme étant l’action an choisie par un agent au temps n. Cetteaction est choisie par la politique π(sn) = θn. Nous avons qualifié cette politique de statiqueparce que les actions qu’elle choisit ne varient ni en fonction de l’instance x, ni en fonctiondes états intermédiaires sn rencontrés durant le traitement.

Les politiques utilisées en apprentissage par renforcement ne sont généralement pas statiques :l’agent réagit à sa situation actuelle plutôt que de toujours répéter les mêmes actions dansle même ordre. Cette constatation nous a fourni l’intuition nécessaire à l’atteinte de notredeuxième objectif. Si un ANN peut être compris comme un agent de RL et que pratiquementaucun agent de RL n’utilise de politique statique parce que l’utilisation d’une politique dy-namique fournit un avantage distinct à la résolution de leur tâche, les ANNs ne devraient-ilspas, eux aussi, utiliser une politique dynamique ?

À partir de cette intuition, nous avons formulé une architecture d’ANN qui utilise une politiquedynamique. Avec une telle politique, les poids de chaque couche du réseau varient en fonctiondes résultats obtenus aux couches précédentes. Cela nous amène clairement dans le domainede la prédiction de poids, une sous-discipline de l’apprentissage profond où les valeurs desortie d’un premier réseau servent de poids pour les couches d’un deuxième réseau. Selon le

63

formalisme que nous avons établis, le premier réseau joue le rôle d’une politique qui contrôleles actions du deuxième.

Nous nous sommes basés sur l’architecture hypernetwork statique. Cette architecture utilise unsous réseau de deux couches pleinement connectées pour prédire les poids du réseau principalà partir d’une séquence de vecteurs de couche. La politique d’un tel réseau reste statique parceque la prédiction se fait à partir d’un vecteur représentant uniquement n, la profondeur de lacouche. Nous pouvons cependant la rendre dynamique en modifiant les vecteurs utilisés pourla prédiction de poids afin qu’ils contiennent de l’information contextuelle.

C’est exactement ce que nous avons fait en définissant l’architecture PBCNN. La premièrevariante de cette architecture, le PBCNN markovien, concatène hn, un signal dérivé de hn,aux en,i, les vecteurs de couches utilisés par l’hypernetwork. Le réseau suppose que cetteconcaténation résulte en un vecteur pouvant servir d’état de Markov. La deuxième variante, lePBCNN non markovien, suppose qu’il est trop difficile de définir un état de Markov pour tenterde le faire à priori. Elle utilise plutôt une ou plusieurs cellules RNNs pour apprendre à produirecet état à partir d’une séquence de vecteurs hn issus de la séquence des hn. Indépendammentde la variante utilisée, les poids de chaque couche du PBCNN dépendent, au moins en partie,des caractéristiques extraites par les couches précédentes. Cela nous permet d’obtenir un ANNsupervisé doté d’une politique dynamique. Notre deuxième objectif est complet.

Finalement, nous testons cette nouvelle architecture en la comparant à d’autres déjà publiées.En raison de leur similitude avec les PBCNNs nous avons choisis les hypernetworks statiquescomme base de comparaison. Nous avons mesuré les performances en test atteintes sur latâche de classification d’images CIFAR10, mais aussi le nombre de paramètres contenus dansle modèle et le nombre d’opérations sur point flottant effectuées pour traiter une instance.Nous voulions idéalement montrer une amélioration sur une ou plusieurs de ces métriques.

Nos tests ont montré que les PBCNNs pouvaient effectivement être entraînés par descente dugradient avec rétropropagation ce qui en fait des architectures valides d’ANNs. Malheureuse-ment, les résultats obtenus n’ont pas été à la hauteur de nos attentes. Qu’ils soient markoviensou non, les PBCNNs produisent une exactitude en test plus basse que les hypernetworks sta-tiques. Pour les PBCNNs markoviens, la baisse est d’autour de 2%. Pour les PBCNNs nonmarkoviens, elle est encore plus prononcée à 4.5%. Cette baisse de performance s’accompagned’une baisse dans la taille de l’espace de paramètres : autour de 33% pour le PBCNN marko-vien et 24% pour le non markovien. Le PBCNN markovien réduit en outre de 12% le nombred’opérations, mais l’utilisation de la cellule RNN provoque une augmentation de 50% pour lePBCNN non markovien. Malheureusement, un hypernetwork plus petit parvient aux mêmeséconomies en termes de paramètres et de calcul tout en conservant des performances meilleuresque celle de nos PBCNNs plus volumineux.

Notre troisième objectif est donc partiellement atteint : nous avons entraîné les PBCNNs et les

64

avons comparés à la littérature. Les résultats de cette comparaison ne sont cependant pas à lahauteur de nos attentes. Nous sommes notamment déçus que les performances des PBCNNsnon markoviens soient moins bonnes que celles des markoviens, puisque nous les avions conçusprécisément pour palier à des faiblesses que nous anticipions dans ces derniers.

Nos résultats indiquent qu’apprendre une politique dynamique aussi performante qu’une po-litique statique n’est pas une tâche triviale. Il est possible qu’une telle politique doive êtretellement vorace en ressources qu’elle ne puisse pas être utilisée pour augmenter l’efficacitédes ANNs. Nous avons déjà pu voir cet effet sur le nombre d’opérations effectuées par lesPBCNNs markoviens. Il est également possible qu’une politique dynamique capable de rivali-ser avec les performances des politiques statiques soit aussi vorace en termes de paramètres.

Cela dit, nous ne croyons pas que les résultats présentés dans ce mémoire suffisent à tirer cetteconclusion. Davantage de recherches doivent être faites sur les PBCNNs. C’est pourquoi nousfinissons ce mémoire avec la section 4.6.2 qui mentionne plusieurs avenues d’études possiblessur le sujet des PBCNNs.

Travaux futurs

Plusieurs observations faites au cours de nos recherches ont suscité des questions pour lesquellesl’obtention de réponses satisfaisantes demandent des expériences en dehors de la portée de cemémoire. Nous les rassemblons ici afin d’indiquer au lecteur des pistes de recherches futuresau sujet des PBCNNs.

Informations internes

Une première catégorie d’expériences vise à récolter plus d’information sur le fonctionnementinterne des PBCNNs. Nos expériences se sont exclusivement concentrées sur leurs prédictionsfinales, sans s’intéresser aux valeurs intermédiaires produites par le réseau. Cela a permis defaire une première évaluation du concept, mais pour pouvoir l’améliorer, nous avons besoin demesurer précisément où le comportement des PBCNNs diffère de nos attentes.

La principale de ces attentes est la notion d’adaptabilité aux caractéristiques de l’instancetraitée. Nous nous attendons à ce que les poids θ prédits varient en fonction de l’instance.Si le réseau apprend seulement à ignorer l’information contextuelle que notre architecture luifournit pour apprendre une politique essentiellement statique, il s’agit d’un problème majeurqui doit être réglé en priorité. On peut aussi s’attendre à ce que les poids des premièrescouches soient plus stables et que la variabilité augmente au fur et à mesure que le réseauobtient de l’information sur l’instance et oriente son traitement en fonction de ces informations.Finalement, on s’attend à ce que les poids utilisés pour traiter des instances appartenant àune même classe soient plus similaires que ceux utilisés pour traiter des instances de classe

65

différentes. Une expérience devrait être faite pour enregistrer les poids prédits et en analyserles distributions pour s’assurer que ces hypothèses sont vérifiées dans la réalité.

Une autre information interne d’importance majeure est la circulation du gradient au sein duréseau. Si certaines régions du réseau reçoivent un gradient trop faible ou trop fort, cela peutnuire fortement à la capacité du réseau d’apprendre sa tâche. L’innovation architecturale desPBCNNs amène leurs paramètres à interagir d’une façon inhabituelle par rapport aux autresANNs. La capacité des couches superficielles d’influencer les couches profondes via h est, ànotre connaissance, un caractère unique aux PBCNNs. Il est possible que ces interactionsmodifient la circulation du gradient d’une façon qui soit nuisible à l’apprentissage du réseau.Une expérience devrait être montée pour valider que le gradient reste de haute qualité dansl’ensemble du réseau.

Modifications architecturales

Nous proposons ici quelques modifications architecturales qui pourraient améliorer les perfor-mances des PBCNNs. Il s’agit soit de concepts généraux devant être concrétisés ou d’idéessoulevées par les résultats de nos expériences.

Premièrement, il est probablement possible d’augmenter la segmentation de en,i utilisée par lesPBCNNs non markoviens. Nous supposions que cette économie de paramètres entraînerait unediminution marquée des performances du réseau, mais ce n’est pas ce que nous avons observé.Ces résultats nous indiquent que notre décision de limiter nos expériences à 4 segments étaitpeut-être trop conservatrice de notre part. Il serait intéressant d’augmenter le nombre desegments et observer à partir de quel niveau de segmentation on observe une diminution desperformances. Cela permettrait de minimiser l’empreinte mémoire et de calcul des cellulesRNNs.

Deuxièmement, les méthodes de normalisation alternatives que nous avons utilisé avec lePBCNN markovien devraient être mises à l’essai sur le PBCNN non markovien. Les norma-lisations par couche et par instance semblent plus appropriées que la normalisation par batchparce que la politique dynamique fait en sorte que les caractéristiques extraites par une unitéd’activation changent d’instance en instance.

Finalement, il est possible de modifier la façon dont hn est obtenue à partir de hn. Par exemple,la fonction de pooling global peut être changée pour utiliser la moyenne ou le top-n valeurs.On pourrait aussi conserver une certaine forme de localisation dans les caractéristiques enutilisant un pooling adaptatif non global. On peut aussi envisager des approches utilisant uneautre fonction que le pooling. Cela semble nécessaire si on cherche à permettre aux PBCNNsnon markoviens d’augmenter le nombre de canaux d’analyse dans les couches profondes duréseau. Cela est présentement impossible parce que les cellules RNNs dépendent d’un vecteurhn de taille fixe. La taille de hn dépend en retour du nombre de canaux utilisé. Il faut donc

66

définir un hn dont la taille ne dépend pas du nombre de canaux.

Récurrence sur les étapes de calcul

Les résultats que nous avons présentés au chapitre 4 montrent de meilleures performancespour les PBCNN markoviens que les non markoviens. Devant de tels résultats, il pourraitêtre tentant d’abandonner la méthode non markovienne et chercher à améliorer l’approcheprésentant, à priori, les meilleures performances. Nous croyons qu’il s’agirait d’une erreurpour deux raisons. Premièrement, l’utilisation des cellules RNNs dans la prédiction des poidsest une approche peu explorée dans la littérature. Comme nous l’avons mentionné à la section4.6.2, il est possible de modifier les détails de cette approche de plusieurs façons. Chacune deces modifications pourrait permettre aux PBCNNs non markoviens de combler l’écart qui lessépare des markoviens.

Deuxièmement, les caractéristiques de récurrence des PBCNNs non markoviens ouvrent laporte à plusieurs autres innovations architecturales. Les cellules RNNs sont habituellementutilisées pour effectuer une récurrence sur les éléments des données d’entrée parce que c’estcomme ça qu’elles sont utilisées dans les RNNs. L’utilisation qu’en font les PBCNNs nonmarkoviens est différente. La récurrence ne porte pas sur les éléments de donnée, mais sur lesétapes de calcul. Chaque couche du réseau est calculée en fonction de la couche précédenteet les résultats obtenus par cette couche. Cela signifie que la taille du réseau, en termes deparamètres, est indépendante du nombre de couches. Il devient alors possible d’appliquer lapolitique un nombre arbitraire de fois sans augmenter la taille du réseau. Il est concevabled’utiliser cette propriété pour définir une politique composée d’un grand nombre de para-mètres pour de l’utiliser sur un problème complexe habituellement résolu par des réseaux trèsprofonds. Dans une telle situation, le coût élevé, en termes de paramètres, de la politique setrouve amorti sur un plus grand nombre de couches. Cela rend la comparaison avec d’autresarchitectures plus favorables. Cela suppose que les piètres performances que nous avons ob-servées s’expliquent principalement par une trop faible capacité de la politique, ce qui reste àvérifier.

La récurrence sur les étapes de calcul permet aussi de faire varier le nombre d’étapes enfonction de l’instance. Il semble raisonnable, par exemple, de demander au réseau de travaillerplus longtemps sur une instance complexe que sur une instance simple. Une politique statiqueempêche cette adaptation, mais une politique dynamique récurrente permettrait de le faire.Cette idée est essentiellement celle développée dans Graves (2016), où un RNN apprend àdéterminer combien d’étapes de calcul il souhaite consacrer à chaque élément de la séquence.La limite de l’approche proposée par Graves (2016) est que parce qu’elle est basée sur un RNN,elle ne peut ultimement être appliquée qu’à des données séquentielles. Intégrer ce concept àun PBCNN non markovien permettrait de l’appliquer à des données non séquentielles.

67

Conclusion

Nos travaux ont permis d’identifier une équivalence théorique importante entre l’apprentis-sage par renforcement et l’apprentissage supervisé. Même si l’architecture que nous avons miseau point pour tirer profit de cette équivalence déçoit en termes de performances, nous esti-mons qu’il faut la considérer comme le prototype d’un nouveau type de réseau. Il existe denombreuses avenues de recherche qui peuvent potentiellement améliorer ce prototype et quiméritent d’être explorées dans le cadre de travaux futurs.

68

Bibliographie

J. L. Ba, J. R. Kiros, and G. E. Hinton. Layer normalization. arXiv preprint arXiv :1607.06450,2016.

D. Bahdanau, K. Cho, and Y. Bengio. Neural machine translation by jointly learning toalign and translate. In Y. Bengio and Y. LeCun, editors, 3rd International Conference onLearning Representations, ICLR 2015, San Diego, CA, USA, May 7-9, 2015, ConferenceTrack Proceedings, 2015. URL http://arxiv.org/abs/1409.0473.

Y. Bengio, I. Goodfellow, and A. Courville. Deep learning, volume 1. MIT press Massachusetts,USA :, 2017.

J. Bjorck, C. P. Gomes, B. Selman, and K. Q. Weinberger. Understanding batch normalization.In S. Bengio, H. M. Wallach, H. Larochelle, K. Grauman, N. Cesa-Bianchi, and R. Garnett,editors, Advances in Neural Information Processing Systems 31 : Annual Conference onNeural Information Processing Systems 2018, NeurIPS 2018, December 3-8, 2018, Montréal,Canada, pages 7705–7716, 2018. URL https://proceedings.neurips.cc/paper/2018/

hash/36072923bfc3cf47745d704feb489480-Abstract.html.

J. Chung, C. Gulcehre, K. Cho, and Y. Bengio. Empirical evaluation of gated recurrent neuralnetworks on sequence modeling. In NIPS 2014 Workshop on Deep Learning, December 2014,2014.

M. Denil, B. Shakibi, L. Dinh, M. Ranzato, and N. De Freitas. Predicting parameters in deeplearning. In Advances in neural information processing systems, pages 2148–2156, 2013.

Y. Gao, C. M. Meyer, and I. Gurevych. APRIL : interactively learning to summarise bycombining active preference learning and reinforcement learning. In E. Riloff, D. Chiang,J. Hockenmaier, and J. Tsujii, editors, Proceedings of the 2018 Conference on EmpiricalMethods in Natural Language Processing, Brussels, Belgium, October 31 - November 4,2018, pages 4120–4130. Association for Computational Linguistics, 2018. doi : 10.18653/v1/d18-1445. URL https://doi.org/10.18653/v1/d18-1445.

69

X. Glorot, A. Bordes, and Y. Bengio. Deep sparse rectifier neural networks. In Proceedingsof the fourteenth international conference on artificial intelligence and statistics, pages 315–323, 2011.

A. Graves. Adaptive computation time for recurrent neural networks. arXiv preprintarXiv :1603.08983, 2016.

D. Ha, A. M. Dai, and Q. V. Le. Hypernetworks. In 5th International Conference on LearningRepresentations, ICLR 2017, Toulon, France, April 24-26, 2017, Conference Track Procee-dings. OpenReview.net, 2017. URL https://openreview.net/forum?id=rkpACe1lx.

S. Han, H. Mao, and W. J. Dally. Deep compression : Compressing deep neural network withpruning, trained quantization and huffman coding. In Y. Bengio and Y. LeCun, editors,4th International Conference on Learning Representations, ICLR 2016, San Juan, PuertoRico, May 2-4, 2016, Conference Track Proceedings, 2016. URL http://arxiv.org/abs/

1510.00149.

M. J. Hausknecht and P. Stone. Deep recurrent q-learning for partially observable mdps. In2015 AAAI Fall Symposia, Arlington, Virginia, USA, November 12-14, 2015, pages 29–37.AAAI Press, 2015. URL http://www.aaai.org/ocs/index.php/FSS/FSS15/paper/view/

11673.

K. He, X. Zhang, S. Ren, and J. Sun. Deep residual learning for image recognition. InProceedings of the IEEE conference on computer vision and pattern recognition, pages 770–778, 2016.

S. Hochreiter and J. Schmidhuber. Long short-term memory. Neural computation, 9(8) :1735–1780, 1997.

S. Ioffe and C. Szegedy. Batch normalization : Accelerating deep network training by reducinginternal covariate shift. In International conference on machine learning, pages 448–456.PMLR, 2015.

M. Jabreel and A. Moreno. A deep learning-based approach for multi-label emotion classifi-cation in tweets. Applied Sciences, 9(6) :1123, 2019.

H. Jia, X. Xiang, D. Fan, M. Huang, C. Sun, Q. Meng, Y. He, and C. Chen. Droppruning formodel compression. arXiv preprint arXiv :1812.02035, 2018.

X. Jia, B. De Brabandere, T. Tuytelaars, and L. V. Gool. Dynamic filter networks. In Advancesin Neural Information Processing Systems, pages 667–675, 2016.

V. R. Konda and J. N. Tsitsiklis. Actor-critic algorithms. In Advances in neural informationprocessing systems, pages 1008–1014. Citeseer, 2000.

70

A. Mishra and D. Marr. Apprentice : Using knowledge distillation techniques to improvelow-precision network accuracy. In International Conference on Learning Representations,2018. URL https://openreview.net/forum?id=B1ae1lZRb.

G. Mittal. Hypernetworks. https://github.com/g1910/HyperNetworks, 2019.

V. Mnih, K. Kavukcuoglu, D. Silver, A. Graves, I. Antonoglou, D. Wierstra, and M. Riedmiller.Playing atari with deep reinforcement learning. arXiv preprint arXiv :1312.5602, 2013.

A. Neelakantan, Q. V. Le, and I. Sutskever. Neural programmer : Inducing latent programswith gradient descent. In Y. Bengio and Y. LeCun, editors, 4th International Conference onLearning Representations, ICLR 2016, San Juan, Puerto Rico, May 2-4, 2016, ConferenceTrack Proceedings, 2016. URL http://arxiv.org/abs/1511.04834.

A. Polino, R. Pascanu, and D. Alistarh. Model compression via distillation and quantization.In International Conference on Learning Representations, 2018. URL https://openreview.

net/forum?id=S1XolQbRW.

S. Santurkar, D. Tsipras, A. Ilyas, and A. Madry. How does batch normalization help op-timization ? In S. Bengio, H. M. Wallach, H. Larochelle, K. Grauman, N. Cesa-Bianchi,and R. Garnett, editors, Advances in Neural Information Processing Systems 31 : AnnualConference on Neural Information Processing Systems 2018, NeurIPS 2018, December 3-8,2018, Montréal, Canada, pages 2488–2498, 2018. URL https://proceedings.neurips.cc/

paper/2018/hash/905056c1ac1dad141560467e0a99e1cf-Abstract.html.

H. T. Siegelmann and E. D. Sontag. On the computational power of neural nets. In Proceedingsof the fifth annual workshop on Computational learning theory, pages 440–449, 1992.

D. Silver, G. Lever, N. Heess, T. Degris, D. Wierstra, and M. A. Riedmiller. Deterministicpolicy gradient algorithms. In Proceedings of the 31th International Conference on MachineLearning, ICML 2014, Beijing, China, 21-26 June 2014, volume 32 of JMLR Workshop andConference Proceedings, pages 387–395. JMLR.org, 2014. URL http://proceedings.mlr.

press/v32/silver14.html.

D. Silver, J. Schrittwieser, K. Simonyan, I. Antonoglou, A. Huang, A. Guez, T. Hubert, L. Ba-ker, M. Lai, A. Bolton, et al. Mastering the game of go without human knowledge. Nature,550(7676) :354–359, 2017.

I. Sutskever, O. Vinyals, and Q. V. Le. Sequence to sequence learning with neural networks.In Advances in neural information processing systems, pages 3104–3112, 2014.

R. S. Sutton and A. G. Barto. Reinforcement learning : An introduction. MIT press, 2018.

71

R. S. Sutton, D. A. McAllester, S. P. Singh, and Y. Mansour. Policy gradient methods forreinforcement learning with function approximation. In Advances in neural informationprocessing systems, pages 1057–1063, 2000.

D. Ulyanov, A. Vedaldi, and V. Lempitsky. Instance normalization : The missing ingredientfor fast stylization. arXiv preprint arXiv :1607.08022, 2016.

S. Varsamopoulos, K. Bertels, and C. G. Almudever. Designing neural network based decodersfor surface codes. arXiv preprint arXiv :1811.12456, 2018.

S. Wang, Z. Li, C. Ding, B. Yuan, Q. Qiu, Y. Wang, and Y. Liang. C-lstm : Enablingefficient lstm using structured compression techniques on fpgas. In Proceedings of the 2018ACM/SIGDA International Symposium on Field-Programmable Gate Arrays, pages 11–20,2018.

Z. Zhang, X. Ji, and S. S. Du. Is reinforcement learning more difficult than bandits ? a near-optimal algorithm escaping the curse of horizon. arXiv preprint arXiv :2009.13503, 2020.

72