mirror of
https://forge.apps.education.fr/phroy/mes-scripts-de-ml.git
synced 2024-01-27 11:30:36 +01:00
182 lines
6.9 KiB
Python
182 lines
6.9 KiB
Python
import os, time
|
|
import numpy as np
|
|
import matplotlib.pyplot as plt
|
|
|
|
import tensorflow as tf
|
|
from tensorflow import keras
|
|
|
|
###############################################################################
|
|
# 04-keras-tf_playground-xor.py
|
|
# @title: Introduction aux réseaux de neurones - Portage de TensorFlow Playground vers Keras - Points en XOR
|
|
# @project: Mes scripts de ML
|
|
# @lang: fr
|
|
# @authors: Philippe Roy <philippe.roy@ac-grenoble.fr>
|
|
# @copyright: Copyright (C) 2023 Philippe Roy
|
|
# @license: GNU GPL
|
|
###############################################################################
|
|
|
|
###
|
|
# TensorFlow Playground :
|
|
# - Site internet : https://playground.tensorflow.org
|
|
# - Dépôt git : https://github.com/tensorflow/playground
|
|
###
|
|
|
|
###
|
|
# Installation :
|
|
# - pip3 install tensorflow
|
|
# - pip3 install keras
|
|
# - pip3 install pydot
|
|
# - pip3 install graphviz
|
|
###
|
|
|
|
###
|
|
# Commandes NumPy :
|
|
# - np.array : créer un tableau à partir d'une liste de listes
|
|
# - np.c_ : concatène les colonnes des tableaux
|
|
# - np.linspace : créer un tableau 1D de la valeur de début à la valeur de fin avec n valeurs
|
|
# - np.meshgrid : créer un tableau 2D avec l'ensemble des combinaisons allant des deux valeurs de début aux deux valeurs de fin
|
|
# - .reshape : reformater la tableau avec le nombre de lignes et le nombre de colonnes
|
|
###
|
|
|
|
###
|
|
# Commandes Keras :
|
|
# - keras.models.Sequential() : créer un modèle où les couches de neurones sont reliées séquentiellement (modèle simple)
|
|
# - keras.layers.Flatten : ajout d'une couche de formatage de mise à plat
|
|
# - keras.layers.Dense : ajout d'une couche de neurones
|
|
# - keras.backend.clear_session() : reset de la session
|
|
# - .compile : compilation du modèle
|
|
# - .fit : entrainement du modèle
|
|
# - .predict : prédiction du modèle
|
|
# - keras.utils.plot_model : créer le diagramme d'un modèle
|
|
###
|
|
|
|
###############################################################################
|
|
# Initialisation
|
|
###############################################################################
|
|
|
|
# Init de Tensorflow + Keras
|
|
|
|
# tf.__version__
|
|
# keras.__version__
|
|
# tf.config.list_physical_devices('GPU')
|
|
|
|
# Init du temps
|
|
t_debut = time.time()
|
|
|
|
# Init des plots
|
|
fig = plt.figure(figsize=(15, 5))
|
|
fig.suptitle("Réseaux de neurones avec Keras - Classificateur : XOR")
|
|
model_ax = fig.add_subplot(131) # Modèle
|
|
apts_ax = fig.add_subplot(132) # Courbes d'apprentissage
|
|
donnees_ax = fig.add_subplot(133) # Observations : x1,x2 et cibles : y
|
|
|
|
###############################################################################
|
|
# Observations
|
|
###############################################################################
|
|
|
|
# Observations
|
|
m = 1000 # Nombre d'observations
|
|
bg = 1 # Quantité du bruit gaussien
|
|
x1 = np.random.uniform(-5,5, m) # Liste des observations x1
|
|
x2 = np.random.uniform(-5,5, m) # Liste des observations x2
|
|
y = np.empty(m) # Liste des observations cible (XOR)
|
|
marge = 0.15
|
|
for i in range (m):
|
|
if x1[i]>= 0 and x1[i] < marge: x1[i] += marge
|
|
if x1[i]<0 and x1[i] > -marge: x1[i] -= marge
|
|
if x2[i]>= 0 and x2[i] < marge: x2[i] += marge
|
|
if x2[i]<0 and x2[i] > -marge: x2[i] -= marge
|
|
if x1[i]*x2[i]<0:
|
|
y[i]=0
|
|
else:
|
|
y[i]=1
|
|
|
|
# Split en observations d'entrainement et observations de test
|
|
test_size=0.1 # Ratio du lot de test
|
|
m_train = int(np.round(m*(1-test_size)))
|
|
x1_train, x2_train, y_train = x1[:m_train], x2[:m_train], y[:m_train] # Jeu d'entrainement
|
|
x1_test, x2_test, y_test = x1[m_train:], x2[m_train:], y[m_train:] # Jeu de test
|
|
X_train = np.c_[x1_train, x2_train]
|
|
X_test = np.c_[x1_test, x2_test]
|
|
|
|
# Plots
|
|
donnees_ax.plot(x1_train[y_train==1], x2_train[y_train==1], ".", color="tab:blue")
|
|
donnees_ax.plot(x1_train[y_train==0], x2_train[y_train==0], "." , color="tab:orange")
|
|
donnees_ax.plot(x1_test[y_test==1], x2_test[y_test==1], "o", markerfacecolor='tab:blue', color="black")
|
|
donnees_ax.plot(x1_test[y_test==0], x2_test[y_test==0], "o", markerfacecolor='tab:orange', color="black")
|
|
|
|
###############################################################################
|
|
# Phase d'apprentissage
|
|
###############################################################################
|
|
|
|
n = 1000 # Nombre d'itérations (valeur par défaut : 30 , hyperparamètre)
|
|
eta = 0.01 # Taux d'appentissage (valeur par défaut dans Keras : 0.01, hyperparamètre)
|
|
lot=32 # Taille de lot (valeur par défaut dans Keras: 32 , hyperparamètre)
|
|
|
|
# perte="sparse_categorical_crossentropy" # Type de perte (hyperparamètre)
|
|
# perte="mse" # Type de perte (hyperparamètre)
|
|
perte='mean_absolute_error'
|
|
|
|
keras.backend.clear_session()
|
|
model = keras.models.Sequential() # Modèle de reseau de neurones
|
|
# model.add(keras.layers.Flatten(input_shape=[1, 1])) # Couche d'entrée
|
|
model.add(keras.layers.Dense(4, input_dim=2, activation="relu")) # Couche 1 : 4 nodes
|
|
model.add(keras.layers.Dense(4, activation="relu")) # Couche 2 : 4 nodes
|
|
model.add(keras.layers.Dense(1, activation="relu")) # Couche de sortie : 1 node par classe
|
|
|
|
optimiseur=keras.optimizers.SGD(learning_rate= eta)
|
|
model.compile(loss=perte, optimizer=optimiseur, metrics=["accuracy"]) # Compilation du modèle
|
|
|
|
apts = model.fit(X_train, y_train, epochs=n, batch_size=lot) # Entrainement
|
|
|
|
###############################################################################
|
|
# Phase d'inférence
|
|
###############################################################################
|
|
|
|
# X_new=[]
|
|
# y_new=[]
|
|
# for i in range(8):
|
|
# idx = np.random.randint(X_test.shape[0]) # Index aléatoire
|
|
# X_new.append(X_test[idx:idx+1]/255.0)
|
|
# y_new.append(y_test[idx:idx+1])
|
|
|
|
# idx = np.random.randint(X_test.shape[0]-32) # Index aléatoire
|
|
# print ("\n")
|
|
# print ("Test sur les images de "+ str(idx) + " à "+ str(idx+32) + " sur un jeu de 10 000 images.")
|
|
# X_new = X_test[idx:idx+32]
|
|
# y_new = np.argmax(model.predict(X_new), axis=-1)
|
|
# y_new_test= y_test[idx:idx+32]
|
|
# print ("\n")
|
|
|
|
###############################################################################
|
|
# Résultats
|
|
###############################################################################
|
|
|
|
# Modèle
|
|
model_ax.set_title("Modèle")
|
|
keras.utils.plot_model(model, "model.png", show_shapes=True)
|
|
model_img=plt.imread("model.png")
|
|
model_ax.imshow(model_img)
|
|
model_ax.set_axis_off()
|
|
os.remove("model.png") # Supression du fichier temporaire
|
|
|
|
# Courbes d'apprentissage
|
|
apts_ax.set_title("Courbes d'apprentissage")
|
|
apts_ax.plot(apts.epoch, apts.history['loss'], 'r-', label="Perte - entrainement")
|
|
# apts_ax.plot(apts.epoch, apts.history['val_loss'], 'r-', label="Perte - validation")
|
|
apts_ax.plot(apts.epoch, apts.history['accuracy'], 'b-', label="Précision - entrainement")
|
|
# apts_ax.plot(apts.epoch, apts.history['val_accuracy'], 'r:', label="Précision - validation")
|
|
apts_ax.set(ylim=(0, 1))
|
|
apts_ax.set_xlabel("Époque")
|
|
apts_ax.legend()
|
|
|
|
# Plot des données
|
|
donnees_ax.set_title("Données")
|
|
donnees_ax.set_xlabel(r'$x_1$')
|
|
donnees_ax.set_ylabel(r'$x_2$', rotation=0)
|
|
# donnees_ax.legend()
|
|
plt.show()
|
|
|
|
# Performances
|
|
print ("Temps total : "+str(time.time()-t_debut))
|