Ces dernières années, il y a eu une résurgence dans le domaine de l'intelligence artificielle. Il s’étend au-delà du monde académique avec des acteurs majeurs comme Google , Microsoft et Facebook créer leurs propres équipes de recherche et créer des acquisitions .

Cela peut être attribué en partie à l'abondance de données brutes générées par les utilisateurs des réseaux sociaux, dont une grande partie doit être analysée, à la montée des solutions de science des données , ainsi qu'à la puissance de calcul bon marché disponible via GPGPU .

Mais au-delà de ces phénomènes, cette résurgence a été alimentée en grande partie par une nouvelle tendance de l'IA, notamment en apprentissage automatique , connu sous le nom de «Deep Learning». Dans ce didacticiel, je vais vous présenter les concepts et algorithmes clés du deep learning, en commençant par l'unité de composition la plus simple et en développant les concepts de machine learning en Java.

lorsque vous utilisez un élément méta avec des requêtes multimédias, vous devez toujours

(Pour information complète: je suis également l'auteur d'une bibliothèque Java Deep Learning, disponible Ici et les exemples de cet article sont implémentés à l'aide de la bibliothèque ci-dessus. Si tu aimes ça, vous pouvez le soutenir en lui attribuant une étoile sur GitHub , pour lequel je serais reconnaissant. Les instructions d'utilisation sont disponibles sur le page d'accueil .)

Un tutoriel de trente secondes sur l'apprentissage automatique

Au cas où vous ne seriez pas familier, regardez ceci introduction à l'apprentissage automatique :

La procédure générale est la suivante:

1. Nous avons un algorithme qui donne une poignée d'exemples étiquetés, disons 10 images de chiens avec l'étiquette 1 («Chien») et 10 images d'autres choses avec l'étiquette 0 («Pas un chien») - notez que nous collons principalement à supervisé , classification binaire pour ce poste.
2. L'algorithme «apprend» à identifier des images de chiens et, lorsqu'il est nourri d'une nouvelle image, espère produire le bon libellé (1 s'il s'agit d'une image de chien et 0 dans le cas contraire).

Ce paramètre est incroyablement général: vos données peuvent être des symptômes et vos étiquettes de maladies; ou vos données peuvent être des images de caractères manuscrits et vos étiquettes les caractères réels qu'ils représentent.

Perceptrons: premiers algorithmes d'apprentissage profond

L'un des premiers algorithmes d'entraînement supervisé est celui du perceptron, un élément de base du réseau neuronal.

Dis que nous avons n points dans le plan, étiquetés «0» et «1». On nous donne un nouveau point et nous voulons deviner son étiquette (cela s'apparente au scénario 'Chien' et 'Pas chien' ci-dessus). Comment faisons-nous ça?

Une approche pourrait consister à regarder le voisin le plus proche et à renvoyer l'étiquette de ce point. Mais une façon légèrement plus intelligente de procéder serait de choisir une ligne qui sépare le mieux les données étiquetées et de l'utiliser comme classificateur.

Dans ce cas, chaque élément de données d'entrée serait représenté comme un vecteur X = ( x_1, x_2 ) et notre fonction serait quelque chose comme '' 0 'si en dessous de la ligne,' 1 'si au-dessus'.

Pour représenter cela mathématiquement, laissez notre séparateur être défini par un vecteur de poids dans et un décalage vertical (ou biais) b . Ensuite, notre fonction combinerait les entrées et les poids avec une fonction de transfert de somme pondérée:

Le résultat de cette fonction de transfert serait alors introduit dans une fonction d'activation pour produire un marquage. Dans l'exemple ci-dessus, notre fonction d'activation était un seuil de coupure (par exemple, 1 si supérieur à une certaine valeur):

Entraînement du Perceptron

L'entraînement du perceptron consiste à lui fournir plusieurs échantillons d'apprentissage et à calculer la sortie pour chacun d'eux. Après chaque échantillon, les poids dans sont ajustés de manière à minimiser les erreur de sortie , défini comme la différence entre le voulu (cible) et le actuel les sorties. Il existe d'autres fonctions d'erreur, comme erreur quadratique moyenne , mais le principe de base de la formation reste le même.

Inconvénients du perceptron unique

L'approche à perceptron unique de l'apprentissage profond a un inconvénient majeur: elle ne peut qu'apprendre fonctions linéairement séparables . Quelle est la gravité de cet inconvénient? Prenez XOR, une fonction relativement simple, et notez qu'elle ne peut pas être classée par un séparateur linéaire (remarquez l'échec de la tentative, ci-dessous):

Pour résoudre ce problème, nous devrons utiliser un perceptron multicouche, également connu sous le nom de réseau de neurones à feedforward: en fait, nous allons composer un groupe de ces perceptrons ensemble pour créer un mécanisme d'apprentissage plus puissant.

Réseaux de neurones Feedforward pour le Deep Learning

Un réseau de neurones n'est en réalité qu'une composition de perceptrons, connectés de différentes manières et fonctionnant sur différentes fonctions d'activation.

Pour commencer, nous allons examiner le réseau de neurones feedforward, qui possède les propriétés suivantes:

• Une entrée, une sortie et un ou plusieurs caché couches. La figure ci-dessus montre un réseau avec une couche d'entrée à 3 unités, une couche cachée à 4 unités et une couche de sortie à 2 unités (les termes unités et neurones sont interchangeables).
• Chaque unité est un seul perceptron comme celui décrit ci-dessus.
• Les unités de la couche d'entrée servent d'entrées pour les unités de la couche cachée, tandis que les unités de couche cachée sont des entrées dans la couche de sortie.
• Chaque connexion entre deux neurones a un poids dans (similaire aux poids du perceptron).
• Chaque unité de couche t est généralement connecté à chaque unité de la couche précédente t - 1 (bien que vous puissiez les déconnecter en réglant leur poids sur 0).
• Pour traiter les données d'entrée, vous «fixez» le vecteur d'entrée à la couche d'entrée, en définissant les valeurs du vecteur comme des «sorties» pour chacune des unités d'entrée. Dans ce cas particulier, le réseau peut traiter un vecteur d'entrée tridimensionnel (du fait des 3 unités d'entrée). Par exemple, si votre vecteur d’entrée est [7, 1, 2], vous définissez la sortie de l’unité d’entrée supérieure sur 7, l’unité du milieu sur 1, et ainsi de suite. Ces valeurs sont ensuite propagées vers les unités cachées en utilisant la fonction de transfert de somme pondérée pour chaque unité cachée (d'où le terme propagation directe), qui à leur tour calculent leurs sorties (fonction d'activation).
• La couche de sortie calcule ses sorties de la même manière que la couche masquée. Le résultat de la couche de sortie est la sortie du réseau.

Au-delà de la linéarité

Et si chacun de nos perceptrons était autorisé à utiliser uniquement une fonction d'activation linéaire? Ensuite, la sortie finale de notre réseau sera encore être une fonction linéaire des entrées, juste ajustée avec une tonne de poids différents qu'elle est collectée dans tout le réseau. En d'autres termes, une composition linéaire d'un ensemble de fonctions linéaires n'est encore qu'une fonction linéaire. Si nous sommes limités aux fonctions d’activation linéaires, alors le réseau de neurones à feedforward n’est pas plus puissant que le perceptron, quel que soit le nombre de couches dont il dispose.

Une composition linéaire d'un ensemble de fonctions linéaires n'est encore qu'une fonction linéaire, de sorte que la plupart des réseaux de neurones utilisent des fonctions d'activation non linéaires.

Pour cette raison, la plupart des réseaux de neurones utilisent des fonctions d'activation non linéaires comme la logistique , de poisson , binaire ou redresseur . Sans eux, le réseau ne peut apprendre que des fonctions combinaisons linéaires de ses entrées .

Perceptrons de formation

L'algorithme d'apprentissage en profondeur le plus courant pour l'entraînement supervisé des perceptrons multicouches est connu sous le nom de rétropropagation. La procédure de base:

1. Un échantillon de formation est présenté et propagé à travers le réseau.

2. L'erreur de sortie est calculée, généralement l'erreur quadratique moyenne:

   

   Où t est la valeur cible et Oui est la sortie réelle du réseau. D'autres calculs d'erreur sont également acceptables, mais le MSE est un bon choix.

3. L'erreur de réseau est minimisée à l'aide d'une méthode appelée descente de gradient stochastique .

   La descente de gradient est universelle, mais dans le cas des réseaux neuronaux, ce serait un graphique de l'erreur d'apprentissage en fonction des paramètres d'entrée. La valeur optimale pour chaque poids est celle à laquelle l'erreur atteint un minimum global . Pendant la phase de formation, les poids sont mis à jour par petites étapes (après chaque échantillon de formation ou un mini-lot de plusieurs échantillons) de telle manière qu'ils essaient toujours d'atteindre le minimum global - mais ce n'est pas une tâche facile, car vous aboutissent souvent à des minima locaux, comme celui de droite. Par exemple, si le poids a une valeur de 0,6, il doit être changé vers 0,4.

   Ce chiffre représente le cas le plus simple, celui dans lequel l'erreur dépend d'un seul paramètre. Cependant, l'erreur réseau dépend de chaque le poids du réseau et la fonction d'erreur sont beaucoup, beaucoup plus complexes.

   Heureusement, la rétropropagation fournit une méthode pour mettre à jour chaque poids entre deux neurones par rapport à l'erreur de sortie. La dérivation elle-même est assez compliquée, mais la mise à jour du poids pour un nœud donné a la forme (simple) suivante:

   

   Où EST est l'erreur de sortie, et Wi est le poids de l'entrée je au neurone.

   Essentiellement, le but est de se déplacer dans le sens du gradient par rapport au poids je . Le terme clé est, bien sûr, la dérivée de l'erreur, qui n'est pas toujours facile à calculer: comment trouver cette dérivée pour un poids aléatoire d'un nœud caché aléatoire au milieu d'un grand réseau?

   La réponse: par rétropropagation. Les erreurs sont d'abord calculées au niveau des unités de sortie où la formule est assez simple (basée sur la différence entre la cible et les valeurs prédites), puis propagées à travers le réseau de manière intelligente, nous permettant de mettre à jour efficacement nos poids pendant l'entraînement et (espérons-le) atteindre un minimum.

Couche cachée

La couche cachée présente un intérêt particulier. Par le théorème d'approximation universelle , un réseau de couche cachée unique avec un nombre fini de neurones peut être formé pour approcher une fonction arbitrairement aléatoire. En d'autres termes, une seule couche cachée est suffisamment puissante pour apprendre tout fonction. Cela dit, nous apprenons souvent mieux dans la pratique avec plusieurs couches cachées (c'est-à-dire des filets plus profonds).

La couche masquée est l'endroit où le réseau stocke sa représentation abstraite interne des données d'entraînement.

La couche cachée est l'endroit où le réseau stocke sa représentation abstraite interne des données d'entraînement, de la même manière qu'un cerveau humain (analogie grandement simplifiée) a une représentation interne du monde réel. Dans la suite du didacticiel, nous examinerons différentes façons de jouer avec le calque masqué.

Un exemple de réseau

Vous pouvez voir un simple réseau de neurones à action directe (couche 4-2-3) qui classe les IRIS ensemble de données implémenté en Java Ici à travers le testMLPSigmoidBP méthode. L'ensemble de données contient trois classes de plantes d'iris avec des caractéristiques telles que la longueur des sépales, la longueur des pétales, etc. Le réseau est fourni 50 échantillons par classe. Les entités sont fixées aux unités d'entrée, tandis que chaque unité de sortie correspond à une seule classe de l'ensemble de données: «1/0/0» indique que la plante est de classe Setosa, «0/1/0» indique Versicolour et « 0/0/1 ”indique Virginica). L'erreur de classification est de 2/150 (c'est-à-dire qu'elle classe mal 2 échantillons sur 150).

Le problème des grands réseaux

Un réseau neuronal peut avoir plus d'une couche cachée: dans ce cas, les couches supérieures «construisent» de nouvelles abstractions au-dessus des couches précédentes. Et comme nous l'avons mentionné précédemment, vous pouvez souvent mieux apprendre dans la pratique avec de plus grands réseaux.

Cependant, l'augmentation du nombre de couches masquées entraîne deux problèmes connus:

1. Dégradés disparus : à mesure que nous ajoutons de plus en plus de couches cachées, la rétropropagation devient de moins en moins utile pour transmettre des informations aux couches inférieures. En effet, au fur et à mesure que l'information est renvoyée, les gradients commencent à disparaître et deviennent petits par rapport aux poids des réseaux.
2. Surapprentissage : peut-être le problème central de l'apprentissage automatique. En bref, le surajustement décrit le phénomène d'ajustement des données d'entraînement aussi de près, peut-être avec des hypothèses aussi complexe. Dans un tel cas, votre apprenant finit par ajuster très bien les données de formation, mais se comportera beaucoup, beaucoup plus mal sur des exemples réels.

Examinons quelques algorithmes d'apprentissage en profondeur pour résoudre ces problèmes.

Auto-encodeurs

La plupart des cours d'introduction à l'apprentissage automatique ont tendance à s'arrêter avec des réseaux de neurones à action directe. Mais l’espace des réseaux possibles est beaucoup plus riche - continuons donc.

Un auto-encodeur est généralement un réseau de neurones à rétroaction qui vise à apprendre une représentation (encodage) compressée et distribuée d'un ensemble de données.

Conceptuellement, le réseau est formé pour «recréer» l'entrée, c'est-à-dire que l'entrée et les données cibles sont les mêmes. En d'autres termes: vous essayez de produire la même chose que vous avez entrée, mais compressée d'une manière ou d'une autre. C'est une approche déroutante, alors regardons un exemple.

Compression de l'entrée: images en niveaux de gris

Supposons que les données d'apprentissage se composent d'images en niveaux de gris 28x28 et que la valeur de chaque pixel est fixée à un neurone de la couche d'entrée (c'est-à-dire que la couche d'entrée aura 784 neurones). Ensuite, la couche de sortie aurait le même nombre d'unités (784) que la couche d'entrée et la valeur cible pour chaque unité de sortie serait la valeur d'échelle de gris d'un pixel de l'image.

L'intuition derrière cette architecture est que le réseau n'apprendra pas de «mappage» entre les données d'apprentissage et ses étiquettes, mais apprendra plutôt le structure interne et les caractéristiques des données elles-mêmes. (Pour cette raison, la couche cachée est également appelée détecteur de caractéristiques .) Habituellement, le nombre d'unités cachées est plus petit que les couches d'entrée / sortie, ce qui oblige le réseau à apprendre uniquement les caractéristiques les plus importantes et permet une réduction de dimensionnalité.

Nous voulons quelques petits nœuds au milieu pour apprendre les données à un niveau conceptuel, produisant une représentation compacte.

En effet, nous voulons que quelques petits nœuds au milieu apprennent vraiment les données à un niveau conceptuel, produisant une représentation compacte qui d'une certaine manière capture les caractéristiques de base de notre entrée.

Maladie grippale

Pour une démonstration plus approfondie des auto-encodeurs, examinons une autre application.

Dans ce cas, nous utiliserons un ensemble de données simple constitué des symptômes de la grippe (crédit à ceci article de blog pour l'idée). Si vous êtes intéressé, vous trouverez le code de cet exemple dans le testAEBackpropagation méthode .

Voici comment l'ensemble de données se décompose:

• Il existe six fonctionnalités d'entrée binaire.
• Les trois premiers sont des symptômes de la maladie. Par exemple, 1 0 0 0 0 0 indique que ce patient a une température élevée, tandis que 0 1 0 0 0 0 indique une toux, 1 1 0 0 0 0 indique une toux et haute température, etc.
• Les trois dernières caractéristiques sont des symptômes «contre»; lorsqu'un patient en a un, il est moins probable qu’il soit malade. Par exemple, 0 0 0 1 0 0 indique que ce patient a un vaccin contre la grippe. Il est possible de combiner les deux ensembles de fonctionnalités: 0 1 0 1 0 0 indique un patient vacciné avec une toux, et ainsi de suite.

Nous considérerons un patient comme malade quand il a au moins deux des trois premiers traits et en bonne santé s'il a au moins deux des trois seconds (avec rupture des liens en faveur des patients sains), par exemple:

• 111000, 101000, 110000, 011000, 011100 = malade
• 000111, 001110, 000101, 000011, 000110 = sain

Nous allons entraîner un encodeur automatique (utilisant la rétropropagation) avec six unités d'entrée et six unités de sortie, mais seulement deux unités cachées .

Après plusieurs centaines d'itérations, nous observons que lorsque chacun des échantillons «malades» est présenté au réseau d'apprentissage automatique, l'une des deux unités cachées (la même unité pour chaque échantillon «malade») présente toujours une valeur d'activation plus élevée que le autre. Au contraire, lorsqu'un échantillon «sain» est présenté, l'autre unité cachée a une activation plus élevée.

Revenir à l'apprentissage automatique

Essentiellement, nos deux unités cachées ont appris une représentation compacte de l'ensemble de données sur les symptômes de la grippe. Pour voir comment cela se rapporte à l'apprentissage, nous revenons au problème du surajustement. En entraînant notre réseau pour apprendre une représentation compacte des données, nous privilégions une représentation plus simple plutôt qu'une hypothèse très complexe qui suradapte les données d'apprentissage.

D'une certaine manière, en privilégiant ces représentations plus simples, nous essayons d'apprendre les données dans un sens plus vrai.

Machines Boltzmann restreintes

La prochaine étape logique consiste à examiner un Machines Boltzmann restreintes (RBM), à réseau neuronal stochastique génératif qui peut apprendre une distribution de probabilité sur son ensemble d'entrées .

Les RBM sont composés d'une couche cachée, visible et biaisée. Contrairement aux réseaux anticipés, les connexions entre les couches visibles et cachées sont non dirigées (les valeurs peuvent être propagées dans les directions visible-caché et caché-visible) et entièrement connectées (chaque unité d'une couche donnée est connectée à chaque unité de la suivante - si nous permettions à n'importe quelle unité de n'importe quelle couche de se connecter à n'importe quelle autre couche, alors nous aurions un Boltzmann (plutôt qu'un restreint Boltzmann ) machine).

design de communication vs design graphique

Le RBM standard a des unités binaires cachées et visibles: c'est-à-dire que l'activation de l'unité est 0 ou 1 sous un Distribution de Bernoulli , mais il existe des variantes avec d'autres non-linéarités .

Alors que les chercheurs connaissent les GAR depuis un certain temps maintenant, l'introduction récente de la divergence contrastive L'algorithme d'entraînement non supervisé a renouvelé son intérêt.

Divergence contrastée

L'algorithme de divergence contrastive en une seule étape (CD-1) fonctionne comme ceci:

1. Phase positive :
   • Un échantillon d'entrée v est fixé à la couche d'entrée.
   • v se propage vers la couche cachée de la même manière que les réseaux à anticipation. Le résultat des activations de calques masqués est h .
2. Phase négative :
   • Propager h retour à la couche visible avec résultat v » (les connexions entre les couches visibles et cachées ne sont pas dirigées et permettent ainsi un mouvement dans les deux sens).
   • Propager le nouveau v » retour au calque caché avec le résultat des activations h » .

3. Mise à jour du poids :

   

   Où à est le taux d'apprentissage et v , v » , h , h » , et dans sont des vecteurs.

L'intuition derrière l'algorithme est que la phase positive ( h donné v ) reflète la représentation interne du réseau du monde réel Les données. Pendant ce temps, la phase négative représente une tentative de recréer les données sur la base de cette représentation interne ( v » donné h ). L'objectif principal est de données générées être le plus proche possible du monde réel et cela se reflète dans la formule de mise à jour du poids.

En d'autres termes, le réseau a une certaine perception de la façon dont les données d'entrée peuvent être représentées, il essaie donc de reproduire les données sur la base de cette perception. Si sa reproduction n’est pas assez proche de la réalité, il effectue un ajustement et essaie à nouveau.

Revenir à la grippe

Pour démontrer la divergence contrastive, nous utiliserons le même ensemble de données sur les symptômes qu'auparavant. Le réseau de test est un RBM avec six unités visibles et deux unités cachées. Nous formerons le réseau en utilisant une divergence contrastive avec les symptômes v serré sur la couche visible. Pendant le test, les symptômes sont à nouveau présentés à la couche visible; puis, les données sont propagées vers la couche masquée. Les unités cachées représentent l'état malade / sain, une architecture très similaire à l'auto-encodeur (propageant les données du visible vers la couche cachée).

Après plusieurs centaines d'itérations, nous pouvons observer le même résultat qu'avec les auto-encodeurs: l'une des unités cachées a une valeur d'activation plus élevée lorsque l'un des échantillons «malades» est présenté, tandis que l'autre est toujours plus active pour les échantillons «sains».

Vous pouvez voir cet exemple en action dans le testContrastiveDivergence méthode .

Réseaux profonds

Nous avons maintenant démontré que les couches cachées des auto-encodeurs et des RBM agissent comme des détecteurs de caractéristiques efficaces; mais il est rare que nous puissions utiliser ces fonctionnalités directement. En fait, l'ensemble de données ci-dessus est plus une exception qu'une règle. Au lieu de cela, nous devons trouver un moyen d'utiliser ces fonctionnalités détectées indirectement.

Heureusement, cela a été découvert que ces structures peuvent être empilé former Profond réseaux. Ces réseaux peuvent être formés avec gourmandise, une couche à la fois, pour aider à surmonter les gradient de fuite et surapprentissage problèmes liés à la rétropropagation classique.

Les structures résultantes sont souvent assez puissantes, produisant des résultats impressionnants. Prenons, par exemple, le célèbre Google Papier «chat» dans lequel ils utilisent un type spécial d'autoencodeurs profonds pour «apprendre» la détection des visages humains et chats basée sur sans étiquette Les données.

Regardons de plus près.

Auto-encodeurs empilés

Comme son nom l'indique, ce réseau se compose de plusieurs auto-encodeurs empilés.

La couche cachée de l'autoencoder t agit comme une couche d'entrée pour l'autoencodeur t + 1 . La couche d'entrée du premier autoencodeur est la couche d'entrée pour l'ensemble du réseau. La procédure de formation gourmande par couche fonctionne comme ceci:

1. Entraînez le premier autoencodeur ( t = 1 , ou les connexions rouges dans la figure ci-dessus, mais avec une couche de sortie supplémentaire) individuellement en utilisant la méthode de rétropropagation avec toutes les données d'apprentissage disponibles.
2. Former le deuxième autoencodeur t = 2 (connexions vertes). Puisque la couche d'entrée pour t = 2 est la couche cachée de t = 1 nous ne sommes plus intéressés par la couche de sortie de t = 1 et nous le supprimons du réseau. L'entraînement commence par fixer un échantillon d'entrée à la couche d'entrée de t = 1 , qui se propage vers la couche de sortie de t = 2 . Ensuite, les poids (entrée cachée et sortie cachée) de t = 2 sont mis à jour à l'aide de la rétropropagation. t = 2 utilise tous les exemples d'apprentissage, comme t = 1 .
3. Répétez la procédure précédente pour toutes les couches (c'est-à-dire, supprimez la couche de sortie de l'autoencodeur précédent, remplacez-la par un autre autoencodeur et entraînez-vous avec une propagation arrière).
4. Les étapes 1 à 3 sont appelées pré-formation et laissez les poids correctement initialisés. Cependant, il n'y a pas de mappage entre les données d'entrée et les étiquettes de sortie. Par exemple, si le réseau est formé pour reconnaître des images de chiffres manuscrits, il n’est toujours pas possible de mapper les unités du dernier détecteur d’entités (c’est-à-dire la couche masquée du dernier codeur automatique) au type de chiffre de l’image. Dans ce cas, la solution la plus courante consiste à ajouter une ou plusieurs couches entièrement connectées à la dernière couche (connexions bleues). L'ensemble du réseau peut maintenant être vu comme un perceptron multicouche et est formé à l'aide de la rétropropagation (cette étape est également appelée réglage fin ).

Les encodeurs automatiques empilés consistent donc à fournir une méthode de pré-formation efficace pour initialiser les poids d'un réseau, vous laissant ainsi un perceptron complexe et multicouche prêt à être entraîné (ou affiner ).

les entreprises peuvent atteindre une croissance principalement en

Réseaux de croyances profondes

Comme pour les auto-encodeurs, nous pouvons également empiler des machines Boltzmann pour créer une classe appelée réseaux de croyances profondes (DBN) .

Dans ce cas, la couche cachée de RBM t agit comme une couche visible pour RBM t + 1 . La couche d'entrée du premier RBM est la couche d'entrée pour l'ensemble du réseau, et la pré-formation gourmande par couche fonctionne comme ceci:

1. Former le premier RBM t = 1 en utilisant la divergence contrastive avec tous les échantillons d'apprentissage.
2. Former le deuxième RBM t = 2 . Puisque la couche visible pour t = 2 est la couche cachée de t = 1 , l'entraînement commence par serrer l'échantillon d'entrée sur la couche visible de t = 1 , qui se propage vers la couche cachée de t = 1 . Ces données servent ensuite à initier la formation de divergence contrastive pour t = 2 .
3. Répétez la procédure précédente pour toutes les couches.
4. Semblable aux autoencodeurs empilés, après la pré-formation, le réseau peut être étendu en connectant une ou plusieurs couches entièrement connectées à la couche cachée RBM finale. Cela forme un perceptron multicouche qui peut alors être affiné en utilisant la rétropropagation.

Cette procédure s'apparente à celle des auto-encodeurs empilés, mais avec les auto-encodeurs remplacés par des RBM et la rétropropagation remplacée par l'algorithme de divergence contrastive.

(Remarque: pour en savoir plus sur la construction et la formation d'autoencodeurs empilés ou de réseaux de croyances profondes, consultez l'exemple de code Ici .)

Réseaux convolutifs

En guise d'architecture finale d'apprentissage en profondeur, jetons un coup d'œil aux réseaux convolutifs, une classe particulièrement intéressante et spéciale de réseaux à réaction qui sont très bien adaptés à la reconnaissance d'images.

Image via DeepLearning.net

Avant de regarder la structure réelle des réseaux convolutifs, nous définissons d'abord une image filtre , ou une région carrée avec des poids associés. Un filtre est appliqué sur toute une image d'entrée et vous appliquerez souvent plusieurs filtres. Par exemple, vous pouvez appliquer quatre filtres 6x6 à une image d'entrée donnée. Ensuite, le pixel de sortie avec les coordonnées 1,1 est la somme pondérée d'un carré 6x6 de pixels d'entrée avec le coin supérieur gauche 1,1 et les poids du filtre (qui est également un carré 6x6). Le pixel de sortie 2,1 est le résultat d'un carré d'entrée avec le coin supérieur gauche 2,1 et ainsi de suite.

Avec cela couvert, ces réseaux sont définis par les propriétés suivantes:

• Couches convolutives appliquer un certain nombre de filtres à l'entrée. Par exemple, la première couche convolutive de l'image pourrait avoir quatre filtres 6x6. Le résultat d'un filtre appliqué sur l'image est appelé carte des caractéristiques (FM) et le nombre de cartes d'entités est égal au nombre de filtres. Si la couche précédente est également convolutive, les filtres sont appliqués sur tous ses FM avec des poids différents, de sorte que chaque entrée FM est connectée à chaque FM de sortie. L'intuition derrière les poids partagés sur l'image est que les caractéristiques seront détectées quel que soit leur emplacement, tandis que la multiplicité des filtres permet à chacun d'entre eux de détecter différents ensembles de caractéristiques.
• Sous-échantillonnage des couches réduire la taille de l'entrée. Par exemple, si l'entrée se compose d'une image 32x32 et que le calque a une région de sous-échantillonnage de 2x2, la valeur de sortie serait une image 16x16, ce qui signifie que 4 pixels (chaque carré 2x2) de l'image d'entrée sont combinés en une seule sortie pixel. Il existe plusieurs façons de sous-échantillonner, mais les plus populaires sont mise en commun maximale , mise en commun moyenne , et mise en commun stochastique .
• La dernière couche de sous-échantillonnage (ou de convolution) est généralement connectée à une ou plusieurs couches entièrement connectées, la dernière représentant les données cibles.
• L'entraînement est effectué à l'aide d'une rétropropagation modifiée qui prend en compte les couches de sous-échantillonnage et met à jour les poids de filtre convolutif en fonction de toutes les valeurs auxquelles ce filtre est appliqué.

Vous pouvez voir plusieurs exemples de réseaux convolutifs entraînés (avec rétropropagation) sur le MNIST ensemble de données (images en niveaux de gris de lettres manuscrites) Ici , en particulier dans le testLeNet * méthodes (je recommanderais testLeNetTiny2 car il atteint un faible taux d'erreur d'environ 2% en un laps de temps relativement court). Il existe également une belle visualisation JavaScript d'un réseau similaire Ici .

la mise en oeuvre

Maintenant que nous avons couvert les variantes de réseau de neurones les plus courantes, j'ai pensé écrire un peu sur les défis posés lors de la mise en œuvre de ces structures d'apprentissage en profondeur.

De manière générale, mon objectif en créant un Bibliothèque de Deep Learning était (et est toujours) de construire un cadre basé sur un réseau de neurones qui satisfait aux critères suivants:

• Une architecture commune capable de représenter divers modèles (toutes les variantes sur les réseaux de neurones que nous avons vues ci-dessus, par exemple).
• La capacité à utiliser divers algorithmes d'apprentissage (rétro-propagation, divergence contrastive, etc.).
• Performance décente.

Pour répondre à ces exigences, j'ai adopté une approche à plusieurs niveaux (ou modulaire) de la conception du logiciel.

Structure

Commençons par les bases:

• NeuralNetworkImpl est la classe de base pour tous les modèles de réseaux neuronaux.
• Chaque réseau contient un ensemble de couches .
• Chaque couche a une liste de Connexions , où une connexion est un lien entre deux couches de sorte que le réseau est un graphe acyclique dirigé.

Cette structure est suffisamment agile pour être utilisée pour les réseaux classiques à feedforward, ainsi que pour RBM et des architectures plus complexes comme ImageNet .

Cela permet également à une couche de faire partie de plus d'un réseau. Par exemple, les calques d'un Réseau de croyance profonde sont également des couches dans leurs RBM correspondants.

De plus, cette architecture permet à un DBN d'être considéré comme une liste de RBM empilés pendant la phase de pré-formation et un réseau anticipé pendant la phase de réglage fin, ce qui est à la fois intuitivement agréable et pratique pour le programme.

Propagation des données

Le module suivant s'occupe de propager les données à travers le réseau, un processus en deux étapes:

1. Déterminez l'ordre des couches. Par exemple, pour obtenir les résultats d'un perceptron multicouche, les données sont «bloquées» sur la couche d'entrée (c'est donc la première couche à calculer) et propagées jusqu'à la couche de sortie. Afin de mettre à jour les pondérations lors de la rétropropagation, l'erreur de sortie doit être propagée à travers chaque couche dans le premier ordre, en commençant par la couche de sortie. Ceci est réalisé en utilisant diverses implémentations de LayerOrderStrategy , qui tire parti de la structure graphique du réseau, en utilisant différentes méthodes de parcours de graphe. Quelques exemples incluent le stratégie de largeur d’abord et le ciblage d'une couche spécifique . L'ordre est en fait déterminé par les connexions entre les couches, de sorte que les stratégies renvoient une liste ordonnée de connexions.
2. Calculez la valeur d'activation. Chaque couche a un associé ConnectionCalculator qui prend sa liste de connexions (de l'étape précédente) et des valeurs d'entrée (d'autres couches) et calcule l'activation résultante. Par exemple, dans un réseau à anticipation sigmoïdale simple, la couche masquée ConnectionCalculator prend les valeurs des couches d'entrée et de biais (qui sont, respectivement, les données d'entrée et un tableau de 1s ) et les poids entre les unités (dans le cas de couches entièrement connectées, les poids sont en fait stockés dans un Entièrement connecté connexion en tant que Matrice ), calcule la somme pondérée et alimente le résultat dans la fonction sigmoïde. Les calculateurs de connexion implémentent une variété de fonctions de transfert (par exemple, somme pondérée, convolutive) et d'activation (par exemple, logistique et tanh pour perceptron multicouche, binaire pour RBM). La plupart d'entre eux peuvent être exécutés sur un GPU en utilisant Aparapi et utilisable avec une formation mini-batch.

Calcul GPU avec Aparapi

Comme je l'ai mentionné précédemment, l'une des raisons pour lesquelles les réseaux de neurones ont fait une résurgence ces dernières années est que leurs méthodes d'entraînement sont très propices au parallélisme, ce qui vous permet d'accélérer considérablement l'entraînement avec l'utilisation d'un GPGPU. Dans ce cas, j'ai choisi de travailler avec le Aparapi bibliothèque pour ajouter la prise en charge du GPU.

Aparapi impose des restrictions importantes sur les calculateurs de connexion:

• Seuls les tableaux (et variables) unidimensionnels de types de données primitifs sont autorisés.
• Seules les méthodes membres de l'Aparapi Noyau La classe elle-même peut être appelée à partir du code exécutable du GPU.

En tant que tel, la plupart des données (poids, tableaux d'entrée et de sortie) sont stockées dans Matrice instances, qui utilisent des tableaux flottants unidimensionnels en interne. Toutes les calculatrices de connexion Aparapi utilisent soit AparapiWeightedSum (pour les couches entièrement connectées et les fonctions d'entrée de somme pondérée), AparapiSubsampling2D (pour les couches de sous-échantillonnage), ou AparapiConv2D (pour les couches convolutives). Certaines de ces limitations peuvent être surmontées avec l'introduction de Architecture système hétérogène . Aparapi permet également d'exécuter le même code sur le CPU et le GPU.

Formation

La formation module implémente divers algorithmes de formation. Il s'appuie sur les deux modules précédents. Par exemple, RetourPropagationFormateur (tous les formateurs utilisent le Entraîneur classe de base) utilise un calculateur de couches à anticipation pour la phase d'anticipation et un calculateur spécial de largeur de première couche pour propager l'erreur et mettre à jour les poids.

Mes derniers travaux portent sur le support Java 8 et quelques autres améliorations, seront bientôt fusionnés dans Maître .

Conclusion

Le but de ce tutoriel d'apprentissage en profondeur Java était de vous donner une brève introduction au domaine des algorithmes d'apprentissage profond, en commençant par l'unité de composition la plus basique (le perceptron) et en progressant à travers diverses architectures efficaces et populaires, comme celle du Boltzmann restreint. machine.

Les idées derrière les réseaux de neurones existent depuis longtemps; mais aujourd'hui, vous ne pouvez pas entrer dans la communauté du machine learning sans avoir entendu parler des réseaux profonds ou d'une autre approche du deep learning. Le battage médiatique ne doit pas être confondu avec la justification, mais avec les progrès de l'informatique GPGPU et les progrès impressionnants réalisés par des chercheurs comme Geoffrey Hinton, Yoshua Bengio, Yann LeCun et Andrew Ng, le domaine est certainement très prometteur. Il n'y a pas de meilleur moment pour se familiariser et s'impliquer comme le présent.

Annexe: Ressources

Si vous souhaitez en savoir plus, j'ai trouvé les ressources suivantes très utiles pendant mon travail:

• DeepLearning.net : un portail pour tout ce qui concerne l'apprentissage en profondeur. Il a du beau tutoriels , bibliothèque de logiciels et un grand Liste de lecture .
• Un actif Communauté Google+ .
• Deux très bons cours: Apprentissage automatique et Réseaux de neurones pour l'apprentissage automatique , tous deux proposés sur Coursera.
• La Tutoriel sur les réseaux de neurones de Stanford .

En relation: Schooling Flappy Bird: un didacticiel d'apprentissage par renforcement