Introduction :

Les réseaux de neurones artificiels, inspirés du cerveau humain, jouent un rôle central dans
l'intelligence artificielle moderne. Ce projet se plongera dans leur fonctionnement, leur conception.
Nous verrons dans ce projet en premier lieu les outils utilisés ainsi que certaines notions, et en second
lieu les résultats sous formes de graphe.

I. Présentation du projet :
Objectifs :
Dans ce projet on a comme objectif la réalisation d’une application pour prédire et modélisé les séries
temporelles par réseaux de neurones artificielles multicouches. Tout cela en se basant sur le système
dynamique simple, qui est l’application logistique :
xn+1 = Axn(1-xn) = f(xn)
Langage :
Python : est un langage de programmation interprété, multi paradigme et multiplateformes. Il
favorise la programmation impérative structurée, fonctionnelle et orientée objet.
Matplotlib est une bibliothèque Python open source permettant de créer des visualisations de
données.

II. Réalisation de l’application et résultats:

A- L’architecture du modèle :
Dans le modèle fourni, on utilise une architecture de réseau de neurones relativement simple,
adaptée à la tâche de prédire les valeurs de xn+1 à partir de l'équation logistique. Voici les détails de
l'architecture :

1. Couche d'entrée :
- Une seule unité.
- La fonction d'activation n'est pas spécifiée ici, ce qui signifie qu'il s'agit d'une couche dense (fully
connected) avec une activation linéaire par défaut.

2. Couche cachée :
- Une couche cachée avec 64 neurones.
- La fonction d'activation utilisée est ReLU (Rectified Linear Unit), ce qui permet d'introduire une
non-linéarité dans le modèle.
3. Couche de sortie :
- Une seule unité de sortie.
- La fonction d'activation n'est pas spécifiée ici, ce qui signifie qu'il s'agit également d'une couche
dense avec une activation linéaire par défaut.

4. Compilation du modèle :
- La fonction de perte (loss) est définie comme étant la Mean Squared Error (MSE), ce qui est
couramment utilisé pour les problèmes de régression.
- L'optimiseur est défini comme "adam", qui est une méthode d'optimisation couramment utilisée.
L'architecture du modèle est relativement simple, avec une seule couche cachée contenant 64
neurones. Cette architecture a été choisie à titre d'exemple pour illustrer le processus d'apprentissage
d'un modèle de séries temporelles. Dans la pratique, le choix de l'architecture dépendra de la
complexité du problème de séries temporelles et des performances qu’on souhaite atteindre.

B- Extrait de code :
L’application logistique :

xn+1 = Axn(1-xn) = f(xn)

En prenant A = 2 et la valeur initiale x0 = 0.1 et en générant les 500 premières valeurs de xn.
import numpy as np
import tensorflow as tf
from tensorflow import keras
import matplotlib.pyplot as plt

# Fonction pour générer les données xn à partir de l'équation logistique

def generate_data(A, x0, num_steps):
data = [x0]
for _ in range(num_steps):
x_next = A * data[-1] * (1 - data[-1])
data.append(x_next)
return np.array(data[:-1]), np.array(data[1:]) # xn en entrée, xn+1 en sortie

# Paramètres
A = 2
x0 = 0.1
num_steps = 1000
epochs = 100
batch_size = 32

# Génération des données

x_data, y_data = generate_data(A, x0, num_steps)

# Création de l'architecture du modèle

model = keras.Sequential([
keras.layers.Dense(64, activation='relu', input_shape=(1,)),
keras.layers.Dense(1)
])

# Compilation du modèle
model.compile(optimizer='adam', loss='mean_squared_error')

# Entraînement du modèle
history = model.fit(x_data, y_data, epochs=epochs, batch_size=batch_size)

# Génération des 500 premières valeurs de xn à partir du modèle

num_generated_steps = 500
sequence_xn = [x0]

for _ in range(num_generated_steps):
xn = sequence_xn[-1]
xn_plus_1 = model.predict(np.array([xn]))[0][0]
sequence_xn.append(xn_plus_1)

# Affichage des 500 premières valeurs de xn

plt.plot(sequence_xn)
plt.title('500 premières valeurs de xn générées par le modèle')
plt.xlabel('Étape')
plt.ylabel('Valeur')
plt.show()

Extrait de code pour La prédiction des valeurs 3 pas, 10 pas, et 20 :

import numpy as np
import tensorflow as tf
from tensorflow import keras
import matplotlib.pyplot as plt
import tkinter as tk
from tkinter import ttk

# Fonction pour générer les données d'entraînement à partir de l'équation logistique

def generate_data(A, x0, num_steps):
data_x = [x0]
data_y = []

for _ in range(num_steps):
xn = data_x[-1]
xn_plus_1 = A * xn * (1 - xn)
data_x.append(xn_plus_1)
data_y.append(xn_plus_1)
 return np.array(data_x[:-1]), np.array(data_y)

# Interface utilisateur pour entrer les paramètres

A = float(input("Entrez la valeur de A (paramètre de non-linéarité) : "))
x0 = float(input("Entrez la valeur de x0 (valeur initiale) : "))
num_steps = int(input("Entrez le nombre d'étapes pour générer les données
d'entraînement : "))

# Générer les données d'entraînement

x_train, y_train = generate_data(A, x0, num_steps)

# Créer un modèle de réseau de neurones

model = keras.Sequential([
keras.layers.Dense(64, activation='relu', input_shape=(1,)),
keras.layers.Dense(1)
])

# Compilation du modèle
model.compile(optimizer='adam', loss='mean_squared_error')

# Entraînement du modèle
model.fit(x_train, y_train, epochs=100, batch_size=32, verbose=0)

# Utiliser la dernière valeur d'entraînement comme point de départ

initial_value = x_train[-1]

# Prédire 30 valeurs à partir du modèle

num_predictions = 30
predictions = []
expected_values = []

for _ in range(num_predictions):
# Prédire la prochaine valeur à partir du modèle
next_value = model.predict(np.array([initial_value]))[0][0]

# Ajouter la valeur prédite à la liste des prédictions

predictions.append(next_value)

# Générer la valeur attendue à partir de l'équation logistique

expected_value = A * initial_value * (1 - initial_value)
expected_values.append(expected_value)

# Mettre à jour la valeur initiale avec la valeur prédite

initial_value = next_value

# Créer une séquence de temps pour les prédictions

time_steps = np.arange(num_steps, num_steps + num_predictions)
# Afficher les prédictions, les données réelles et les valeurs attendues dans un
graphique
plt.figure(figsize=(10, 6))
plt.plot(x_train, label='Données réelles', linestyle='--', marker='o')
plt.plot(time_steps, predictions, label='Prédictions', linestyle='--', marker='x')
plt.plot(time_steps, expected_values, label='Valeurs attendues', linestyle='--',
marker='s')
plt.title('Prédictions vs. Données réelles vs. Valeurs attendues')
plt.xlabel('Étape')
plt.ylabel('Valeur')
plt.legend()
plt.show()

# Créer une fenêtre graphique pour afficher le tableau

root = tk.Tk()
root.title("Tableau des valeurs prédites et des valeurs attendues")

# Créer un tableau Tkinter

table = ttk.Treeview(root, columns=("Étape", "Prédictions", "Valeurs attendues"))
table.heading("#1", text="Étape")
table.heading("#2", text="Prédictions")
table.heading("#3", text="Valeurs attendues")

# Remplir le tableau avec les données

for i in range(num_predictions):
table.insert("", "end", values=(time_steps[i], predictions[i], expected_values[i]))

table.pack()

root.mainloop()
 C- Résultats :
Graphique des 500 premières valeurs de Xn générées

Figure 1 : les 500 premières valeurs de Xn générés

Apprentissage du modèle :

Figure 2 : Apprentissage du modèle

Ce qui se passe dans la partie prédiction
- Le code générera des données d'entraînement en utilisant l'équation logistique xn+1 = Axn(1-xn) avec
les paramètres spécifiés (A, x0, num_steps). Ces données seront utilisées pour l'apprentissage du
modèle.
- Un modèle de réseau de neurones sera créé avec une architecture spécifiée, comprenant une couche
d'entrée, une couche cachée et une couche de sortie.
- Le modèle sera compilé en spécifiant la fonction de perte (MSE) et l'optimiseur (Adam).
- Le modèle sera entraîné avec les données d'entraînement générées. Pendant l'entraînement, les
poids du modèle seront ajustés itérativement pour minimiser la perte.
- Une fois l'entraînement terminé (après le nombre d'époques spécifié), le modèle sera capable de
prédire les valeurs xn+1 à partir des valeurs xn en utilisant la fonction apprise.
Cependant, dans ce cas particulier, le modèle aura appris à approximer l'équation logistique xn+1 =
Axn(1-xn) avec les paramètres que vous avez spécifiés (A, x0). Vous pourrez utiliser le modèle pour
prédire les valeurs futures de la séquence xn+1, mais il ne vous donnera pas directement l'équation
elle-même, car l'équation est déjà connue.
Prédiction à un pas (10 valeurs prédites pour 10 valeurs existantes) :

Figure 3 : Prédiction à un pas

Prédiction à 3 pas, 10 pas et 30 pas
A = 2 et la valeur initiale x0 = 0.3
Nombre d’étape d’entrainement : 11

Figure 4 : Prédiction à 3 pas

 Figure 5 : Tableau des valeurs prédites et des valeurs attendues 3 pas

Avec Nombre d’étape d’entrainement : 25

Figure 6 : Prédiction à 10 pas

Avec nombre d’étape d’entrainement 75 et valeur initiale x0 = 0.3

Figure 7 : Prédiction à 20 pas

Conclusion :
En conclusion, l’application de réseaux de neurones dans la logistique ouvre la voie à une gestion
plus efficace des opérations, à des prévisions plus précises et à des économies de coûts significatives.
Leur capacité d’apprentissage automatique et d’adaptation en fait des outils indispensables pour
relever les défis complexes de l’intelligence artificielle. A mesure que la technologie continue
d’évoluer, il est clair que les réseaux de neurones joueront un rôle de premier plan dans la
modernisation.