Cette page présente un exemple d'approximation d'une courbe à l'aide d'un réseau de neurones. Cet exemple montre et détaille comment résoudre un problème de régression non linéaire avec TensorFlow.
La suite de cette page a été réalisée avec les versions suivantes :
Vous pouvez essayer l'exemple en ligne sur Google Colaboratory.
Le but de cet exemple est d'approximer une fonction non linéaire donnée par l'équation suivante :
$$ y = 0.1.x.\cos(x) $$
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 artificiel :
Chaque ligne est expliquée dans la section suivante. Cet exemple peut aussi être exécuté en ligne sur Google Colaboratory
Commençons par importer les bibliothèques nécessaires :
import numpy as np
import matplotlib.pyplot as plt
from tensorflow import keras
from google.colab import files
import tensorflow as tf
import math
Ensuite, créons le jeu de données pour l'apprentissage. x_data
est composé de 1000 points,
et un bruit normal est ajouté sur l'axe des ordonnées pour haque point :
# Create noisy data
x_data = np.linspace(-10, 10, num=1000)
y_data = 0.1*x_data*np.cos(x_data) + 0.1*np.random.normal(size=1000)
print('Data created successfully')
Voici le jeu de données utilisé pour l'apprentissage :
Lorsque notre jeu de données est prêt, nous pouvons créer le réseau :
RELU n'est probablement pas le meilleur choix pour cette application, mais ça fonctionne quand même correctement. ELU devrait produire une courbe moins dicontinue.
# Create the model
model = keras.Sequential()
model.add(keras.layers.Dense(units = 1, activation = 'linear', input_shape=[1]))
model.add(keras.layers.Dense(units = 64, activation = 'relu'))
model.add(keras.layers.Dense(units = 64, activation = 'relu'))
model.add(keras.layers.Dense(units = 1, activation = 'linear'))
model.compile(loss='mse', optimizer="adam")
# Display the model
model.summary()
Le modèle est compilé avec les paramètre d'optimisation suivants:
optimizer="adam"
), plus d'info sur cette pageloss='mse'
). Plus d'informations sur les metriques iciUne fois le modèle créé, entraînons notre réseau :
x_data
est l'entréey_data
est la sortie désiréeepochs=5
signifie que notre réseaux sera entrainé 5 fois sur notre jeu de donnéesverbose=1
affiche la progression dans la console# Training
model.fit( x_data, y_data, epochs=100, verbose=1)
La ligne ci-dessus devrait afficher quelque chose comme (loss doit diminuer au fil de l'apprentissage) :
Train on 1000 samples
Epoch 1/100
1000/1000 [==============================] - 0s 321us/sample - loss: 0.2125
Epoch 2/100
1000/1000 [==============================] - 0s 49us/sample - loss: 0.1914
Epoch 3/100
1000/1000 [==============================] - 0s 50us/sample - loss: 0.1932
Epoch 4/100
1000/1000 [==============================] - 0s 60us/sample - loss: 0.1922
...
Epoch 97/100
1000/1000 [==============================] - 0s 59us/sample - loss: 0.0180
Epoch 98/100
1000/1000 [==============================] - 0s 53us/sample - loss: 0.0188
Epoch 99/100
1000/1000 [==============================] - 0s 54us/sample - loss: 0.0161
Epoch 100/100
1000/1000 [==============================] - 0s 55us/sample - loss: 0.0147
Lorsque l'apprentissage est terminé, nous pouvons prédire l'approximation :
# Compute the output
y_predicted = model.predict(x_data)
# Display the result
plt.scatter(x_data[::1], y_data[::1])
plt.plot(x_data, y_predicted, 'r', linewidth=4)
plt.grid()
plt.show()
Voici le résultat :
Vous pouvez tester cet exemple en ligne sur Google Colaboratory