2019

ARTIFICIAL NEURAL NETWORK

Samuel AGNINDE
Ecole Hassania des Travaux Publics
21/06/2019
 ARTIFICIAL NEURAL NETWORK

Qu'est-ce que l'apprentissage automatique?

L'apprentissage automatique est un domaine de l'informatique. C'est une application d'intelligence
artificielle (IA) qui donne à la machine la possibilité d'apprendre et de s'améliorer automatiquement
à partir de l'expérience sans être explicitement programmée. L'apprentissage automatique se
concentre sur l'amélioration progressive des programmes informatiques pouvant accéder aux
données et les utiliser pour apprendre par eux-mêmes. L'apprentissage automatique vise
principalement à permettre aux ordinateurs d'apprendre automatiquement sans intervention
humaine ni assistance.

Définition
L'apprentissage automatique est une technique de modélisation impliquant des données. Cette
définition peut être trop courte pour que les débutants comprennent parfaitement le sens de
l'apprentissage par machine. Laissez-nous élaborer la définition. L’apprentissage automatique est
une technique qui définit le « modèle » à partir d’une vaste collection de « données ».

Qu’est-ce que l'apprentissage, le training et le modèle?

Le terme « apprentissage » fait référence à la capacité de la machine à analyser les données et à
préparer un modèle pour elle-même sans aucune intervention humaine. Nous appelons cela «
apprendre » car ici, la machine s’entraîne pour trouver la meilleure solution à certains problèmes et
produit le « modèle ». Ce « modèle » peut être utilisé ultérieurement pour résoudre des problèmes
similaires. Cela signifie que la machine a appris à résoudre certains types de problèmes en analysant
des données. C’est pourquoi nous appelons ce processus « apprentissage ». Lorsque les données
sont utilisées pour entraîner la machine, nous les appelons « données de training ». La figure
suivante illustre l'apprentissage automatique du contexte que nous venons de décrire.

1
Types de machine learning

Qu’est-ce que le deep learning ?

L'apprentissage en profondeur est une extension du réseau de neurones. Lorsque nous utilisons un
réseau neurone multicouche, cela s'appelle un réseau de neurones profonds (DNN). Et lorsque DNN
est utilisé pour former le réseau de neurones, nous l’appelons Deep Learning. Donc le Deep Learning
est une technique d’apprentissage automatique qui utilise un réseau de neurones multicouches. La
figure suivante illustre le concept d'apprentissage en profondeur.

2
L'apprentissage en profondeur (Depp Learning) a été appliqué avec succès dans de nombreux
contextes d'apprentissage supervisé. Les réseaux de neurones traditionnels sont appliqués à des fins
de publicité en ligne. Les réseaux de neurones convolutifs (CNN) sont parfaits pour le marquage de
photos et les réseaux de neurones récurrents (RNN) sont utilisés pour la reconnaissance de la parole
ou la traduction automatique.

Apprentissage supervisé
Essentiellement, une stratégie impliquant un enseignant plus intelligent que le réseau lui-même.
Par exemple, prenons l’exemple de reconnaissance faciale. L'enseignant montre au réseau une
multitude de visages et il connaît déjà le nom associé à chaque visage. Le réseau fait ses
suppositions, puis l'enseignant fournit au réseau les réponses. Le réseau peut ensuite comparer ses
réponses aux réponses « correctes » connues et procéder à des ajustements en fonction de ses
erreurs. Notre premier réseau de neurones dans la section suivante suivra ce modèle.

Apprentissage non supervisé

Obligatoire lorsqu'il n'existe pas d'exemple de jeu de données avec des réponses connues. Imaginez
que vous cherchiez un motif caché dans un ensemble de données. Une application de ceci est le
clustering, c’est-à-dire la division d’un ensemble d’éléments en groupes selon un schéma inconnu.
Nous n’examinerons aucun exemple d’apprentissage non supervisé dans ce chapitre, car cette
stratégie est moins pertinente.

Apprentissage par renforcement

Une stratégie basée sur l'observation. Pensez à une petite souris qui traverse un labyrinthe. S'il
tourne à gauche, il obtient un morceau de fromage; s'il tourne à droite, il reçoit un petit choc. (Ne
vous inquiétez pas, il ne s’agit que d’une souris factice.) Vraisemblablement, la souris apprendra avec
le temps à tourner à gauche. Son réseau de neurones prend une décision avec un résultat (tourner à
gauche ou à droite) et observe son environnement (miam ou ouch). Si l'observation est négative, le
réseau peut ajuster ses pondérations afin de prendre une décision différente la prochaine fois.
L'apprentissage par renforcement est courant en robotique. À l'instant t, le robot effectue une tâche
et observe les résultats. Est-ce qu'il s'est écrasé contre un mur ou est tombé d'une table? Ou est-ce
indemne? Nous étudierons l’apprentissage par renforcement dans le contexte de nos véhicules de
direction simulés.

Processus global
Gardons à l’esprit la démarche globale du machine Learning :

1. Donner une entrée au modèle.

2. Propager cette entrée à travers le réseau de neurones jusqu’à récupérer la sortie.

3. Une fois la sortie obtenue, nous pouvons la comparer à la sortie voulue et donc calculer
une erreur.

4. On ajuste les paramètres du modèle pour diminuer l’erreur précédemment calculée. Pour
cela on soustrait à chaque paramètre la dérivée de l’erreur par rapport à lui-même (gradient
descendant).

5. On recommence à l’étape 1.

3
L’étape la plus importante est la 4ième. Nous voulons être capable de créer autant de couches que
l’on veut, de n’importe quel type, et d’utiliser n’importe quelle fonction d’activation. Seulement, en
changeant l’architecture du réseau de neurones, on change également la formule littérale du calcul
de la dérivée de l’erreur par rapport aux paramètres.

Ce que la couche doit faire

Passe avant — forward propagation

Nous pouvons dès lors préciser une propriété importante : la sortie d’une couche est l’entrée de la
couche suivante :

Cette partie est ce qu’on appelle la passe avant (forward propagation) : on propage
l’entrée X (image, son, texte, etc.) dans le réseau de neurones jusqu’à obtenir la sortie Y. Puis, on
observe une erreur E qu’il faut maintenant diminuer.

Passe arrière — backward propagation

Supposons que l’on donne à une couche la dérivée de l’erreur par rapport à sa sortie (∂E/∂Y), alors
elle doit être capable de donner la dérivée de l’erreur par rapport à son entrée (∂E/∂X).

4
il existe un paramètre supplémentaire dans backward_propagation, c’est le Learning rate. Ce
paramètre est un optimiseur qui apparait dans la méthode la descente de gradient. Voici à quoi
ressemble en général le réseau :

Fully Connected Layer

Définissons et implémentons maintenant le premier type de couche: Fully Connected Layer ou FC
Layer. Les couches FC sont les couches les plus élémentaires car tous les neurones d’entrée sont
connectés à tous les neurones de sortie.

5
Forward Propagation
La valeur de chaque neurone de sortie peut être calculée comme suit :

Fonction d’activation
Les fonctions de seuillage présentent généralement trois intervalles :

 en dessous du seuil, le neurone est non-actif (souvent dans ce cas, sa sortie vaut 0 ou -1) ;
 aux alentours du seuil, une phase de transition ;
 au-dessus du seuil, le neurone est actif (souvent dans ce cas, sa sortie vaut 1).

Des exemples classiques de fonctions d’activation sont :

La fonction sigmoïde.

La fonction tangente hyperbolique.

6
La fonction de Heaviside.

Apprentissage

Programme
Classe Layer
La classe abstraite Layer, dont les autres couches hériteront, contient les caractéristiques communes
à toutes les couches : une entrée, une sortie, une fonction qui fait la passe avant, et une pour la
passe arrière.

class Layer:

def __init__(self):

self.input = None

self.output = None

# computes the output Y of a layer for a given input X

def forward_propagation(self, input):

raise NotImplementedError

# computes dE/dX for a given dE/dY (and update parameters if any)

def backward_propagation(self, output_error, learning_rate):

raise NotImplementedErrorclass Layer:

def __init__(self):

self.input = None

self.output = None

# computes the output Y of a layer for a given input X

def forward_propagation(self, input):

raise NotImplementedError

7
 # computes dE/dX for a given dE/dY (and update parameters if any)

def backward_propagation(self, output_error, learning_rate):

raise NotImplementedError

Coder la couche FC
from layer import Layer

import numpy as np

# inherit from base class Layer

class FCLayer(Layer):

# input_size = number of input neurons

# output_size = number of output neurons

def __init__(self, input_size, output_size):

self.weights = np.random.rand(input_size, output_size) - 0.5

self.bias = np.random.rand(1, output_size) - 0.5

# returns output for a given input

def forward_propagation(self, input_data):

self.input = input_data

self.output = np.dot(self.input, self.weights) + self.bias

return self.output

# computes dE/dW, dE/dB for a given output_error=dE/dY. Returns input_error=dE/dX.

def backward_propagation(self, output_error, learning_rate):

input_error = np.dot(output_error, self.weights.T)

weights_error = np.dot(self.input.T, output_error)

# dBias = output_error

# update parameters

self.weights -= learning_rate * weights_error

self.bias -= learning_rate * output_error

return input_error

8
Couche d’activation
from layer import Layer

# inherit from base class Layer

class ActivationLayer(Layer):

def __init__(self, activation, activation_prime):

self.activation = activation

self.activation_prime = activation_prime

# returns the activated input

def forward_propagation(self, input_data):

self.input = input_data

self.output = self.activation(self.input)

return self.output

# Returns input_error=dE/dX for a given output_error=dE/dY.

# learning_rate is not used because there is no "learnable" parameters.

def backward_propagation(self, output_error, learning_rate):

return self.activation_prime(self.input) * output_error

Fonction d’activation
import numpy as np

# activation function and its derivative

def tanh(x):

return np.tanh(x);

def tanh_prime(x):

return 1-np.tanh(x)**2;

Fonction perte :
import numpy as np

# loss function and its derivative

def mse(y_true, y_pred):

9
 return np.mean(np.power(y_true-y_pred, 2));

def mse_prime(y_true, y_pred):

return 2*(y_pred-y_true)/y_true.size;

Regroupons tout en un programme final :

import numpy as np

import xlrd

from network import Network

from fc_layer import FCLayer

from activation_layer import ActivationLayer

from activations import tanh, tanh_prime

from losses import mse, mse_prime

# Give the location of the file

loc =(r'C:\Users\O\Desktop\BASE\TRAINING.xlsx')

loc1 =(r'C:\Users\O\Desktop\BASE\OUTPUT.xlsx')

# To open Workbook

wb = xlrd.open_workbook(loc)

wb1 = xlrd.open_workbook(loc1)

sheet = wb.sheet_by_index(0)

sheet1 = wb1.sheet_by_index(0)

x=[]

x_train=[]

10
for i in range(70):

x.append(sheet.row_values(i))

x_train.append(x)

x=[]

z=[]

y_train=[]

for i in range(70):

z.append(sheet1.row_values(i))

y_train.append(z)

z=[]

#print(y_train)

# training data

x_train = np.array(x_train)

y_train = np.array(y_train)

# network

net = Network()

net.add(FCLayer(312,313))

net.add(ActivationLayer(tanh, tanh_prime))

net.add(FCLayer(313, 1))

net.add(ActivationLayer(tanh, tanh_prime))

# train

net.use(mse, mse_prime)

net.fit(x_train, y_train, epochs=10, learning_rate=0.1)

# test

m=[]

11
x_test=[]

m.append(sheet.row_values(50))

x_test.append(m)

x_test = np.array(x_test)

out = net.predict(x_test)

print(out)

Le XOR :
import numpy as np

from network import Network

from fc_layer import FCLayer

from activation_layer import ActivationLayer

from activations import tanh, tanh_prime

from losses import mse, mse_prime

# training data

x_train = np.array([[[0,0]], [[0,1]], [[1,0]], [[1,1]]])

y_train = np.array([[[0]], [[1]], [[1]], [[0]]])

# network

net = Network()

net.add(FCLayer(2, 3))

net.add(ActivationLayer(tanh, tanh_prime))

net.add(FCLayer(3, 1))

net.add(ActivationLayer(tanh, tanh_prime))

# train

net.use(mse, mse_prime)

net.fit(x_train, y_train, epochs=1000, learning_rate=0.1)

12
# test

x_test = np.array([[[1,0]])

out = net.predict(x_test)

print(out)

Conclusion :
Les réseaux de neurones sont utilisés dans plusieurs domaines notamment :

 Datamining : ils servent à prédire, à identifier et classifier les données.

 Finance et gestion : outil d’aide à la décision
 Robotique : apprentissage de robot autonome

Les réseaux de neurones sont puissants : on peut presque toujours baisser l’erreur en augmentant le
nombre d’itérations (epoch) et |ou en diminuant le Learning rate.

13