Le réseau de neurones le plus simple avec TensorFlow

Précédent Sommaire Suivant

Cette page présente le réseau de neurones le plus simple que l'on puisse faire avec TensorFlow. Cette exemple montre comment créer et comprendre votre premier réseau de neurones.

La suite de cette page a été réalisée avec les versions suivantes :

Ubuntu LTS 18.04
Linux 4.15.0-88-generic
Python 3.6.9
Numpy 1.18.1
Matplotlib 2.1.1
TensorFlow 2.1.0

Vous pouvez essayer l'exemple en ligne sur Google Colaboratory.

Définition du problème

Le but de cet exemple simpliste est d'approximer la fonction affine définie par cette équation:

$$ y = a.x + b = 0.6x + 2 $$

Les points bleus représente un échantillon de notre jeu d'apprentissage, la ligne rouge est l'approximation faite par le réseau de neurones artificiels :

Code source

Vous trouverez ci-dessous le code source complet de cet exemple. Chaque ligne est expliquée dans la section suivante. Cet exemple peut aussi être exécuté en ligne sur Google Colaboratory

import numpy as np
import matplotlib.pyplot as plt
from tensorflow import keras

# Parameters (y = a*x + b)
a=0.6
b=2

# Create noisy data
x_data = np.linspace(-10, 10, num=100000)
y_data = a * x_data + b + np.random.normal(size=100000)

# Create the model 
model = keras.Sequential()
model.add(keras.layers.Dense(units = 1, activation = 'linear', input_shape=[1]))
model.compile(loss='mse', optimizer="adam")

# Display the model (only 2 parameters to optimize)
model.summary()

# Learn
model.fit( x_data, y_data, epochs=5, verbose=1 )

# Predict (compute) the output 
y_predicted = model.predict(x_data)

# Display the result
plt.scatter(x_data[::500], y_data[::500])
plt.plot(x_data, y_predicted, 'r', linewidth=4)
plt.grid()
plt.show()

Explications

Commençons par importer les bibliothèques nécessaires :

numpy pour les tableaux et les matrices
matplotlib pour afficher les graphiques
Keras de la bibliothèque TensorFlow pour le réseau de neurones

import numpy as np
import matplotlib.pyplot as plt
from tensorflow import keras

Ensuite, créons le jeu de données pour l'apprentissage. x_data est composé de 100000 points, et un bruit normal est ajouté sur l'axe des ordonnées pour haque point :

# Parameters (y = a*x + b)
a=0.6
b=2

# Create noisy data
x_data = np.linspace(-10, 10, num=100000)
y_data = a * x_data + b + np.random.normal(size=100000)

Voici un échantillon du jeu de données utilisé pour l'apprentissage :

Une fois les données construites, nous pouvons créer notre réseau. Dans TensorFlow le réseau est classiquement appelé un modèle :

# Create the model 
model = keras.Sequential()
model.add(keras.layers.Dense(units = 1, activation = 'linear', input_shape=[1]))
model.compile(loss='mse', optimizer="adam")

# Display the model (only 2 parameters to optimize)
model.summary()

Analyson ce code. En premier, nous créons un modèle séquentiel. Le modèle Sequential est une pile linéaire de couches (un réseau classique). Keras est le coeur permettant de construire des réseaux de neurones. Nous ajoutons une couche complétement connectée à notre modèle (Dense) avec :

une unité ou un neurone (units = 1)
la fonction de transfert est ninéaire (activation = 'linear')
le réseau n'a qu'une entrée (input_shape=[1])

Le modèle est compilé avec les paramètre d'optimisation suivants:

L'algorithme d'optimisation est Adam (optimizer="adam"), plus d'info sur cette page
Loss est la perte ou l'erreur calculée sur la base des moindres carrés (loss='mse'). Plus d'informations sur les metriques ici

Une fois le modèle créé, entraînons notre réseau :

x_data est l'entrée
y_data est la sortie désirée
epochs=5 signifie que notre réseaux sera entrainé 5 fois sur notre jeu de données
verbose=1 affiche la progression dans la console

# Learn
model.fit( x_data, y_data, epochs=5, verbose=1)

La ligne ci-dessus devrait afficher quelque chose comme :

Train on 100000 samples
Epoch 1/5
100000/100000 [==============================] - 4s 40us/sample - loss: 34.6061
Epoch 2/5
100000/100000 [==============================] - 4s 35us/sample - loss: 1.0512
Epoch 3/5
100000/100000 [==============================] - 3s 26us/sample - loss: 1.0080
Epoch 4/5
100000/100000 [==============================] - 3s 29us/sample - loss: 1.0080
Epoch 5/5
100000/100000 [==============================] - 3s 28us/sample - loss: 1.0082

Lorsque l'apprentissage est terminé, nous pouvons prédire l'approximation:

# Predict (compute) the output 
y_predicted = model.predict(x_data)

# Display the result
plt.scatter(x_data[::500], y_data[::500])
plt.plot(x_data, y_predicted, 'r', linewidth=4)
plt.grid()
plt.show()

Voici les résultats :

Regardons notre réseau de plus près et affichons les valeurs des poids du réseau :

>>> print( model.trainable_variables )
[<tf.Variable 'dense_6/kernel:0' shape=(1, 1) dtype=float32, numpy=array([[0.5970049]], dtype=float32)>, <tf.Variable 'dense_6/bias:0' shape=(1,) dtype=float32, numpy=array([1.9903255], dtype=float32)>]

Nos poids sont 0.5970049 et 1.9903255, presque 0.6 et 2, nos paramètres initiaux !

Téléchargements

Vous pouvez tester cet exemple en ligne sur Google Colaboratory

linear-regression.py : source code Python
linear-regression.ipynb : source code pour Jupyter Notebook

Précédent Sommaire Suivant

Voir aussi

Dernière mise à jour : 14/03/2020