FriconiX
Des milliers de pictogrammes gratuits dessinés avec amour !

Régression non linéaire avec un réseau de neurones

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.

Définition du problème

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 :

Code source

Chaque ligne est expliquée dans la section suivante. Cet exemple peut aussi être exécuté en ligne sur Google Colaboratory

Explications

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

import numpy as np
import matplotlib.pyplot as plt
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 :

Jeu de données sous forme de nuage de points à approximer

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:

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

# 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 :

Resultat de la régression linéaire avec le réseau de neurones

Source code

Vous pouvez tester cet exemple en ligne sur Google Colaboratory

Voir aussi


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