Introduction au deep learning et aux réseaux de mémoire à long terme

Bien que les prédictions soient toujours controversées, Gartner affirme qu'il y a 8,4 milliards d'appareils IoT connectés en 2017 (sans les smartphones) et que selon certains analystes, il y en aura 50 milliards d'ici 2020. Même s'il est surestimé, le nombre d'appareils IoT dépassera bientôt le nombre d'humains sur la planète. Et devinez quoi, tous ces appareils génèrent en permanence des données ; des données inutiles à moins de pouvoir les analyser.

Un système cognitif fournit un ensemble technologique tel que l'intelligence artificielle (IA), le traitement du langage naturel, le machine learning et le machine learning avancé pour faciliter l'analyse de toutes ces données. Les systèmes cognitifs peuvent étudier et interagir naturellement avec les humains pour recueillir des informations à partir de données et les aider à prendre de meilleures décisions. L’informatique cognitive n’est pas seulement l’interaction homme-ordinateur, mais il s’agit d’un machine learning avancé basé sur de puissants algorithmes (modèles) et des capacités de traitement de données presque illimitées.

Pour comprendre un système cognitif utilisant des capteurs IoT et une analyse d'apprentissage approfondi, vous devez d'abord comprendre le passage du machine learning avancé aux réseaux de neurones. Dans ce tutoriel, j'essaie de vous aider à faire ce saut. Plus tard, je présenterai trois tutoriels différents sur la détection des anomalies sur des données de séries chronologiques sur Apache Spark en utilisant les frameworks Deeplearning4j, ApacheSystemML et TensorFlow (TensorSpark) pour vous aider à développer des solutions cognitives en utilisant le deep learning.

Si un système cognitif est basé sur des modèles, vous devez d'abord examiner ce qu'est un modèle d'apprentissage automatique. C'est un modèle statistique (boîte noire) qui, contrairement à un modèle physique (boîte blanche), a été formé avec des données pour apprendre un modèle caché.

Consultez le tableau 1. Il contient des données historiques sur différents paramètres, des observations mesurées sur un pipeline de fabrication et un résultat binaire.

Dans cet exemple hautement artificiel, les chiffres parlent d'eux-mêmes. Comme vous pouvez le deviner, une température élevée et une vibration élevée ont conduit à une pièce défectueuse. La cause principale de cette situation pourrait être le résultat d'un roulement cassé dans une machine.

Dans cet exemple, un algorithme d'apprentissage automatique (supervisé) est capable de prendre en compte toutes ces données (et bien plus encore) pour apprendre et prédire les erreurs à partir de données pures. Le composant produit par un tel algorithme est appelé modèle d'apprentissage automatique.

Un type spécial d'algorithme d'apprentissage automatique est un réseau de neurones. Il est très adaptable aux données et il est capable d’étudier toute fonction mathématique cachée entre les données et le résultat. Le seul problème avec les réseaux de neurones est la quantité énorme de ressources et de données informatiques dont ils ont besoin pour bien fonctionner. Alors, pourquoi est-ce que je parle des réseaux de neurones ? Nous vivons dans un monde IoT avec des quantités énormes de données disponibles et également (presque) une puissance de calcul illimitée disponible en utilisant le cloud. Cette situation rend les réseaux de neurones particulièrement intéressants pour le traitement des données IoT.

Les réseaux de neurones sont inspirés du cerveau humain, tout comme les réseaux de deep learning. La principale différence entre un réseau de neurones et le deep learning est l'ajout de plusieurs couches de neurones. L’exemple le plus évident qui démontre la manière dont le deep learning est plus performant que le machine learning est la reconnaissance d’images. Chaque système à la fine pointe de la technologie utilise un type particulier de réseau de neurones du deep learning (appelé réseau de neurones de convolution) pour effectuer ses tâches.

Par exemple, les algorithmes de reconnaissance d'images basés sur l'apprentissage approfondi sont capables de distinguer les parties saines des pièces défectueuses dans un pipeline de fabrication. J'appellerais cela intelligence machine et elle est disponible comme dans le service de reconnaissance IBM Watson. Pour cet exemple particulier, la machine peut accomplir la même tâche avec la même précision qu'un humain. Le seul avantage de la machine est qu’elle ne dort jamais, n’est jamais malade et ne se blesse jamais. Et, si vous avez besoin de doubler le débit, il vous suffit de doubler la quantité de matériels ou de ressources cloud. Toutefois, l’application d’une analyse des causes fondamentales de la défaillance des pièces reste toujours du domaine des experts humains. Cependant, ce scénario est celui où les solutions cognitives appliquent l'apprentissage profond.

En fait, un service de reconnaissance visuelle retourne beaucoup plus d'informations qu'un simple résultat binaire de « sain » ou « défectueux ». Tout comme un humain, le service détecte les structures et les régions dans les images qui s'écartent de la norme. Maintenant, si vous deviez corréler toutes les données de capteurs sonores et vibratoires avec toutes les données de reconnaissance visuelle, je suis sûr qu'un tel système pourrait détecter les causes profondes des pannes aussi bien, voire mieux, que les humains.

Si les capteurs IoT connectés à un courtier de messages (comme la plateforme IBM Watson IoT basée sur MQTT) constituent le système nerveux central des solutions cognitives, alors l'apprentissage approfondi est le cerveau. Et, pour comprendre l'apprentissage approfondi, vous avez besoin d'une compréhension de base de la régression, des perceptrons, des réseaux de neurones biologiques et artificiels et des couches cachées.

III-A. Commencez par une régression linéaire et logistique▲

Une tonne de littérature scientifique existe sur la régression, alors je vais essayer de vous donner une explication courte adaptée aux développeurs. Considérons le tableau 2. Il est identique au tableau 1, sauf qu'ici, j'ai transformé le résultat en une représentation binaire.

Numéro de pièce	Max Temp. 1	Min Temp. 1	Max Vibration 1	Résultat
100	35	35	12	1
101	46	35	21	1
130	56	46	3412	0

Il est assez facile d'écrire un programme pour faire la classification.

 

Sélectionnez

1.
2.
3.
4.
5.

def predict (datapoint):
  if datapoint.MaxVibration1 > 100 : 
    return 0 
  else : 
    return 1

Certaines règles de ce modèle de boîte blanche ont été créées à partir de votre connaissance du système physique sous-jacent (ou d'un expert du domaine examinant les données). L'idée du machine learning est que les machines apprennent ces règles à partir de données. Et la manière dont cet apprentissage est fait consiste à utiliser un squelette et un algorithme d'optimisation pour combler les parties manquantes du squelette. Je vais utiliser un tel squelette (régression linéaire) :

 

Sélectionnez

def predict (dp) : 
  return a + b * dp.MaxTemp1 + c * dp.MinTemp1 + d * dp.MaxVibration1

Comme vous pouvez le voir, si je choisis la valeur 0 pour les paramètres b et c, la valeur 1 pour a et -0,0002930832 pour d (soit -1/3412), je suis assez proche de mon résultat requis. Et la bonne nouvelle est que les paramètres a, b, c et d peuvent être obtenus à partir d’un algorithme. Le résultat : l'apprentissage automatique !

Vous remarquerez peut-être que les résultats ne sont pas exactement 1 ou 0, car la régression linéaire est un modèle continu (qui tente de prédire les valeurs de type float). Mais ce que je veux, c'est un classificateur binaire. Permettez-moi de transformer cet algorithme en un modèle de régression logistique en ajoutant simplement une fonction d'assistance appelée sigmoid.

 

Sélectionnez

import math 
def sigmoid (x): 
  return 1 / (1 + math.exp( - x)) 
def predict (dp): 
  return sigmoid(a + b * dp.MaxTemp1 + c * dp.MinTemp1 + d * dp.MaxVibration1)

La fonction sigmoid ne fait rien d'autre que d'écraser une plage allant de moins l'infini à plus l'infini dans une plage de 0 à 1. La seule chose que je dois faire est de définir un seuil, par exemple des valeurs <0.5 à 0 et > 0.5 à 1 .

Vous avez maintenant maîtrisé le réseau de neurones le plus simple : un perceptron. Il est similaire à un modèle de régression logistique - avec quelques différences négligeables. Mais le terme « réseaux de neurones » semble beaucoup plus intéressant, n'est-ce pas ? Regardez le perceptron de la figure 2.

J'ai notre entrée au modèle x_1 à x_n et aux paramètres du modèle w_1 à w_n. Et puis je résume et traite avec une fonction d'activation (par exemple, sigmoid). Si j'écris ce modèle un peu différemment, cela ressemble à ceci :

out(x_1,x_2,…,x_n) = activation_function(w_0+w_1*x_1+w_2*x_2+…+w_n*x_n)

Et si je remplace activation_function par sigmoid, je reviens à la régression logistique. La seule chose est que … cela ressemble un peu plus à la structure d'un cerveau. Mais à quoi ressemble le cerveau humain ?

Et parce que c'est amusant (du moins pour moi), regardez la figure d'une synapse biologique ( figure 4) reliant les neurones (biochimiquement) ensemble. Cette figure représente l'ensemble des valeurs de w_n dans le perceptron.

Si vous reliez plusieurs neurones ensemble, vous obtiendrez un cerveau ou un réseau neuronal artificiel, comme indiqué dans la figure 5.

IV-A. La différence est dans la couche cachée▲

La plus grande différence entre ce réseau artificiel et le perceptron est la couche cachée. Que signifie tout cela ? Est-ce utile ? Peut-être. Au moins dans le cerveau humain, les couches cachées semblent être utiles, car nous en avons des centaines. Dans cet exemple de réseau neuronal prédictif de la figure 6, vous pouvez voir que les modèles sont empilés.

Vous ne pouvez pas le voir ? Regardez comment ce modèle ressemblerait à un langage de programmation. Mais avant de faire cela, laissez-moi vous dire un secret. ; un secret que les mathématiciens utilisent pour faire fuir tout le monde. Mais c'est totalement simple. Je parle de la multiplication de vecteurs. Alors, qu’est-ce qu’un vecteur ? Juste une liste de chiffres, rien d'autre. Les programmeurs peuvent l'appeler un tableau. Et la multiplication sur les vecteurs est définie légèrement différemment. Elle dit si vous avez un vecteur x = (x_1, x_2…, x_n) et un autre vecteur w = (w_1, w_2,…, w_n) et si vous les multipliez x * w, le résultat est une valeur unique:

 

Sélectionnez

w_1*x_1+w_2*x_2+…+w_n*x_n

Ce modèle vous semble-t-il familier ? Sinon, regardez à nouveau la régression linéaire. Je peux obtenir un seul neurone en calculant le sigmoid (x * w). Et comme Python ne prend pas en charge la multiplication de vecteurs par défaut, je peux utiliser une bibliothèque appelée numpy pour le faire. Je vais commencer à calculer un seul neurone :

 

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.

import numpy as np 
datapoint = {" MaxTemp1 ": 35 , " MinTemp1 ": 35 , " MaxVibration1 ": 12 } 
#randomly initialize weights
w_layer1 = np.random.rand(4)
def  neuron1 (dp): 
  x = np.array([ 1 ,dp[" MaxTemp1 "],dp[" MinTemp1 "],dp[" MaxVibration1 "]]) 
  return  sigmoid(x.dot(w_layer1)) 
print (neuron1 ( datapoint ) )

Si je veux calculer plusieurs neurones en même temps (par exemple, tous les neurones d'une couche), je peux utiliser cette fonction plusieurs fois. Mais les mathématiciens ont inventé une autre chose à vous confondre (au cas où vous auriez survécu à la multiplication des vecteurs) : la multiplication matricielle. Dans les réseaux de neurones, vous pouvez appliquer des calculs comme dans la régression linéaire à plusieurs reprises en parallèle, et vous pouvez écrire cela comme une multiplication matricielle sous cette forme.

Encore une fois, je suppose que notre entrée est dans le vecteur x = (x_1, x_2…, x_n). Mais maintenant, je veux calculer tous les neurones de la couche cachée en même temps. Au lieu de multiplier x avec un vecteur de poids w pour calculer un seul neurone, je multiplie x avec une matrice de poids.

w =

w_1_1, w_1_2,.., w_1_m

w_2_1, w_2_2,.., w_2_m

…

w_n_1, w_n_2,.., w_n_m

La multiplication matricielle définit w * x =

(w_1_1*x_1,  w_1_2*x_2,.., w_1_m*x_n,

w_2_1*x_1,  w_2_2*x_2,.., w_2_m*x_n,

…

 w_n_1*x_1,  w_n_2*x_2,.., w_n_m*x_n)

Mon résultat est un vecteur de valeurs à virgule flottante que je peux ensuite alimenter dans la couche suivante. Voici le même code en Python :

 

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.

import numpy as np 
#rendre la fonction sigmoïde applicable aux vecteurs au lieu des scalaires uniquement
def sigmoid (z): 
  s = 1.0 / ( 1.0 + np.exp(- 1.0 * z)) 
  return s 
datapoint = {" MaxTemp1 ": 35 , " MinTemp1 ": 35 , " MaxVibration1 ": 12 } 
#initialiser aléatoirement les poids, maintenant comme une matrice pour les quatre neurones de la couche cachée 
w_layer1 = np.random.rand(4,4)
def layer 1 (dp): 
  x = np.array([ 1 ,dp[" MaxTemp1 "],dp[" MinTemp1 "],dp[" MaxVibration1 "]]) 
  return sigmoid(x.dot(w_layer1)) 
print ( layer 1 ( datapoint ) )

Comme vous pouvez le voir, le fragment de code x.dot (w_layer1) ne change pas du tout. Mais en interne, une multiplication matricielle est appliquée à la place d'une multiplication vectorielle, car w_layer1 est désormais une matrice au lieu d'un vecteur. Enfin, je dois ajouter la couche de sortie et j'ai terminé :

 

Sélectionnez

w_layer2 = np.random.rand( 5 , 2 ) 

def layer2 (x): 
  x = np.concatenate(([ 1 ],x)) 
    return  sigmoid(x.dot(w_layer2)) 

print (layer2(layer1(datapoint)))

Bien entendu, la matrice de poids w n'est pas formée, mais seulement initialisée de manière aléatoire. La mise en place d'un réseau neuronal dépasse le cadre de ce tutoriel.

Remarque : ce réseau neuronal aléatoire génère deux nombres à virgule flottante. Ces nombres sont les probabilités d'un élément appartenant à une classe ou à l'autre. Encore une fois, comme le réseau neuronal n’est pas formé, ces chiffres n’ont aucun sens pour le moment. [ 0.97435552 0.89144977]

IV-B. Entrons dans la couche cachée▲

J'espère que vous êtes convaincus que les réseaux de neurones sont très puissants. Mais malheureusement, en ce qui concerne les données de séries chronologiques (et les données IoT sont principalement des données de séries chronologiques), les réseaux de type feed-forward ont un problème. Ces réseaux sont mauvais dans la reconnaissance des séquences, car ils ne contiennent pas de mémoire. Une solution à ce problème consiste à ajouter des boucles de rétroaction.

Ces boucles de rétroaction résolvent quelque peu le problème, car le réseau peut maintenant se rappeler. Mais cela ne fonctionne que sur des évènements temporellement proches. Si le réseau doit mémoriser des évènements plus distants, des cellules de mémoire doivent être ajoutées aux neurones pour obtenir un réseau de mémoire à long terme (LSTM), comme illustré à la Figure 8.

Quel est l'inconvénient d'un réseau LSTM ? Il nécessite beaucoup de données et de ressources informatiques pour atteindre de bonnes performances lors de l'utilisation de réseaux neuronaux. La bonne nouvelle est que les cartes à processeur graphique (GPU) actuelles ont la même puissance de calcul qu’un cluster de 16 000 cœurs en 2009. Et IBM est en train de lancer une puce neuromorphique en tant qu’offre du groupe IBM Watson avec la même puissance de calcul, mais ne consommant que 3 watts. Il y a donc de l'espoir pour de futures améliorations de performances et d’économies d'énergie.

Pourquoi je vous dis tout cela pour un scénario cognitif de l'IoT ? Parce qu'un réseau LSTM est en turing complet. Cela signifie qu'un réseau LSTM peut traiter n'importe quel algorithme qu'un ordinateur peut exécuter.
Et cela contraste avec la plupart des algorithmes d'apprentissage automatique à la fine pointe de la technologie qui sont utilisés pour les détections de séries chronologiques et les détections d'anomalies, qui sont les disciplines qui caractérisent l'IoT cognitif. Dans les applications IoT cognitives, vous devez soit prédire l'état futur du système pour prendre des mesures réglementaires à l'avance, soit vous voulez être averti si quelque chose est en panne.

Alors, quel est le problème avec les algorithmes de pointe ? Rien. Je dis que les LSTM fonctionnent généralement mieux que l'état de l'art ; parfois de manière significative, parfois un peu, et rarement pire (surtout si vous avez suffisamment de données pour former le système). Cela dépend de votre cas d'utilisation si le gain de précision justifie les coûts de calcul supplémentaires.

Je veux que vous commenciez à penser à ce cas d'utilisation de démonstration. Ce cas d'utilisation sera la base des didacticiels de suivi. Imaginez que vous voulez détecter les anomalies dans les données de capteur de vibrations (accéléromètre) qui mesurent un roulement. Vous attacheriez un capteur au roulement, comme illustré à la figure 9.

Un capteur d’accéléromètre enregistre les vibrations sur chacun des trois axes géométriques x, y et z. Il existe des capteurs plus sophistiqués qui prennent également en compte les mouvements de rotation, mais nous sommes d'accord avec ce modèle simple, car il se trouve dans tous les smartphones. Comme il est difficile de vous déplacer avec un tel système, je devrais implémenter un simulateur Node-RED pour générer des données en utilisant un modèle d'attraction physique de Lorenz. Je vais utiliser ces données générées dans les tutoriels pour détecter les anomalies, en prédisant essentiellement quand un roulement est sur le point de se briser. Vous pouvez lire le prochain tutoriel de cette série « Générer des données pour la détection des anomalies », pour voir comment j'ai créé ce simulateur de données de test.

Je peux basculer le générateur de données de test entre deux états : sain et défectueux. La figure 10 est un graphique de phase montrant les trois dimensions de vibration sur une série temporelle dans un état sain.

Avec le même tracé de phase que dans la figure 10, vous pouvez observer un léger changement lorsque vous modifiez légèrement les paramètres du modèle physique.

Si vous n'êtes pas familier avec les tracés de phase, voici un graphique d'exécution dans la figure 12 et la figure 13 pour les trois valeurs d'axe (à nouveau dans l'état sain et défectueux).

Vous pouvez clairement voir que sur l'état défectueux, il y a plus d'énergie et des fréquences supplémentaires. Ces données seraient suffisantes pour former un classificateur comme vous l’avez déjà appris. Mais nous pouvons faire mieux. Nous allons construire un système capable d’étudier le comportement normal des données, et après avoir vu de nouvelles données (inédites) (ou des séquences séquentielles), il émettra une alerte.
Un tel système est un autoencodeur basé sur LSTM, comme le montre la figure 16.

Ce système compresse la grande quantité de données via un goulot d'étranglement neurologique pour tenter de reconstituer les mêmes données qu'il a vues, il perd de grandes quantités de données non pertinentes. Un tel réseau neuronal apprend comment un système se comporte normalement et dès que de nouveaux modèles sont visibles, il est difficile de reconstruire les données et déclenche une alerte.

À ce stade, vous devez avoir une compréhension suffisante des réseaux neuronaux et de ce que l'application de concepts d'apprentissage approfondi à vos données peut faire pour vos données IoT dans votre système cognitif.
Dans la prochaine série de tutoriels, je me concentrerai sur l'utilisation de différentes technologies sur Apache Spark pour implémenter un tel système d'apprentissage approfondi et renforcer votre compréhension de l'impact qu'une telle technologie peut avoir sur vos systèmes. Je parlerai des solutions open source exécutées dans IBM Cloud telles que Deeplearning4j, Apache SystemML et TensorFlow (TensorSpark).

Developpez.com remercie IBM pour la mise à disposition de ce tutoriel. Les remerciements également à Laethy pour la traduction et Malick pour la relecture orthographique.