Mise en place du portage vers Keras de TensorFlow Playground

This commit is contained in:
Philippe Roy 2023-06-27 12:57:24 +02:00
parent b8d35d1419
commit fd7daadac8
6 changed files with 682 additions and 16 deletions

View File

@ -1,3 +1,4 @@
import time import time
import numpy as np import numpy as np
import sklearn import sklearn
@ -76,14 +77,14 @@ X_new = np.c_[np.ones((2, 1)), x1_new] # Matrice des observations, avec x0=1
# Phase d'apprentissage par descente de gradient stochastique # Phase d'apprentissage par descente de gradient stochastique
# - theta : vecteur paramètres du modèle # - theta : vecteur paramètres du modèle
# - gradient : gradient du coût en fonction de theta # - gradient : gradient du coût en fonction de theta
# - eta : taux d'appentissage ici dégressif par échéancier d'apprentissage (ech_app) # - eta : taux d'appentissage ici dégressif par échéancier d'apprentissage (apts_ech)
# n_epoq = 50 # Nombre d'époques # n_epoq = 50 # Nombre d'époques
n_epoq = 2 # Nombre d'époques (hyperparamètre) n_epoq = 2 # Nombre d'époques (hyperparamètre)
# Rédéfinition du taux d'apprentissage à partir de l'échéancier d'apprentissage # Rédéfinition du taux d'apprentissage à partir de l'échéancier d'apprentissage
t0, t1 = 5, 50 # Facteurs de l'échéancier d'apprentissage (hyperparamètres) t0, t1 = 5, 50 # Facteurs de l'échéancier d'apprentissage (hyperparamètres)
def ech_app (t): def apts_ech (t):
return t0 / (t + t1) return t0 / (t + t1)
# Calcul du coût (Mean Square Error (MSE), Root Mean Square Error (RMSE)) # Calcul du coût (Mean Square Error (MSE), Root Mean Square Error (RMSE))
@ -107,7 +108,7 @@ for epoq in range (n_epoq):
xi = X[idx : idx+1] xi = X[idx : idx+1]
yi = y[idx : idx+1] yi = y[idx : idx+1]
gradients = 2/1 * xi.T.dot(xi.dot(theta) - yi) gradients = 2/1 * xi.T.dot(xi.dot(theta) - yi)
eta = ech_app (epoq * m + i) eta = apts_ech (epoq * m + i)
eta_list.append(eta) eta_list.append(eta)
theta = theta - eta * gradients theta = theta - eta * gradients
theta0.append(theta[0]) theta0.append(theta[0])

View File

@ -44,7 +44,7 @@ t_debut = time.time()
fig = plt.figure(figsize=(15, 5)) fig = plt.figure(figsize=(15, 5))
fig.suptitle("Régression polynomiale") fig.suptitle("Régression polynomiale")
donnees_ax = fig.add_subplot(121) # Observations : x1 et cibles : y donnees_ax = fig.add_subplot(121) # Observations : x1 et cibles : y
app_ax = fig.add_subplot(122) # Courbes d'apprentissage apts_ax = fig.add_subplot(122) # Courbes d'apprentissage
############################################################################### ###############################################################################
# Observations # Observations
@ -145,22 +145,22 @@ donnees_ax.legend()
donnees_ax.set(xlim=(-3, 3), ylim=(0, 10)) donnees_ax.set(xlim=(-3, 3), ylim=(0, 10))
# Plot des courbes d'apprentissage # Plot des courbes d'apprentissage
app_ax.set_title("Courbes d'apprentissage") apts_ax.set_title("Courbes d'apprentissage")
app_ax.plot(np.sqrt(train_errors_1), 'g:', label="Entrainement - degré 1") apts_ax.plot(np.sqrt(train_errors_1), 'g:', label="Entrainement - degré 1")
app_ax.plot(np.sqrt(val_errors_1), 'g-', label="Validation - degré 1") apts_ax.plot(np.sqrt(val_errors_1), 'g-', label="Validation - degré 1")
app_ax.plot(np.sqrt(train_errors_2), 'r:', label="Entrainement - degré 2") apts_ax.plot(np.sqrt(train_errors_2), 'r:', label="Entrainement - degré 2")
app_ax.plot(np.sqrt(val_errors_2), 'r-', label="Validation - degré 2") apts_ax.plot(np.sqrt(val_errors_2), 'r-', label="Validation - degré 2")
app_ax.plot(np.sqrt(train_errors_30), 'k:', label="Entrainement - degré 30") apts_ax.plot(np.sqrt(train_errors_30), 'k:', label="Entrainement - degré 30")
app_ax.plot(np.sqrt(val_errors_30), 'k-', label="Validation - degré 30") apts_ax.plot(np.sqrt(val_errors_30), 'k-', label="Validation - degré 30")
app_ax.set_xlabel("Taille du lot d'entrainement") apts_ax.set_xlabel("Taille du lot d'entrainement")
app_ax.set_ylabel("RMSE") apts_ax.set_ylabel("RMSE")
app_ax.set(xlim=(0, 80), ylim=(0, 10)) apts_ax.set(xlim=(0, 80), ylim=(0, 10))
# app_ax.set(xlim=(0, 80), ylim=(0, 3)) # apts_ax.set(xlim=(0, 80), ylim=(0, 3))
app_ax.legend() apts_ax.legend()
plt.show() plt.show()

View File

@ -0,0 +1,160 @@
import os, time
import numpy as np
import matplotlib.pyplot as plt
import tensorflow as tf
from tensorflow import keras
###############################################################################
# 03-keras-tf_playground-cercle.py
# @title: Introduction aux réseaux de neurones - Portage de TensorFlow Playground vers Keras - Points en cercle
# @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 du temps
t_debut = time.time()
# Init des plots
fig = plt.figure(figsize=(15, 5))
fig.suptitle("Réseaux de neurones avec Keras - Classificateur : points en cercle")
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 d'apprentissage, de validation et de test
vetement = keras.datasets.fashion_mnist # Jeu de données Fashion MNIST
(X, y), (X_test, y_test) = vetement.load_data()
X_train, y_train = X[5000:]/255.0 , y[5000:]
X_valid, y_valid = X[:5000]/255.0 , y[:5000]
classes = ["Tshirt", "Pantalon", "Pull", "Robe", "Manteau", "Sandale", "Chemise", "Basket", "Sac", "Bottine"]
###############################################################################
# Phase d'apprentissage
###############################################################################
n = 30 # 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)
keras.backend.clear_session()
# np.random.seed(42)
# tf.random.set_seed(42)
model = keras.models.Sequential() # Modèle de reseau de neurones
model.add(keras.layers.Flatten(input_shape=[28, 28])) # Couche d'entrée : mise à plat des données d'entrée -> 1 node / pixel soit 784 (28x28)
model.add(keras.layers.Dense(300, activation="relu")) # Couche 1 : 300 nodes
# model.add(keras.layers.Dense(300, activation="relu")) # Couche 2 : 300 nodes -> passage de 100 à 300
# model.add(keras.layers.Dense(300, activation="relu")) # Couche 3 : 300 nodes -> ajout
model.add(keras.layers.Dense(100, activation="relu")) # Couche 4 : 100 nodes -> ajout
model.add(keras.layers.Dense(10, activation="softmax")) # Couche de sortie : 1 node par classe soit 10
# model.compile(loss="sparse_categorical_crossentropy", optimizer="sgd", metrics=["accuracy"])
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, validation_data=(X_valid, y_valid)) # 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'], 'b-', 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()
# Prédictions
for i in range (8):
for j in range (4):
img_ax[j][i].imshow(X_new[i*2+j], cmap="binary", interpolation="nearest")
img_ax[j][i].set_axis_off()
if y_new[i*2+j] == y_new_test[i*2+j]:
img_ax[j][i].set_title(classes[y_new[i*2+j]], fontsize=10)
else:
img_ax[j][i].set_title(classes[y_new[i*2+j]], fontsize=10, color="red")
plt.show()
# Performances
print ("Temps total : "+str(time.time()-t_debut))

View File

@ -0,0 +1,171 @@
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 d'apprentisage
m = 1000 # Nombre d'observations
bg = 1 # Quantité du bruit gaussien
x1 = 10*np.random.rand(m, 1) # Liste des observations x1
x2 = 10*np.random.rand(m, 1) # Liste des observations x1
# y = 4 + 3*x1 + bg * np.random.rand(m, 1) # Liste des cibles y
# X = np.c_[np.ones((m, 1)), x1] # Matrice des observations, avec x0=1
plt.plot(x1, x2, 'b.', label="Observations")
# Nouvelles observations
# x1_new=np.array([[0], [2]])
# X_new = np.c_[np.ones((2, 1)), x1_new] # Matrice des observations, avec x0=1
# # Observations d'apprentissage, de validation et de test
# vetement = keras.datasets.fashion_mnist # Jeu de données Fashion MNIST
# (X, y), (X_test, y_test) = vetement.load_data()
# X_train, y_train = X[5000:]/255.0 , y[5000:]
# X_valid, y_valid = X[:5000]/255.0 , y[:5000]
# classes = ["Tshirt", "Pantalon", "Pull", "Robe", "Manteau", "Sandale", "Chemise", "Basket", "Sac", "Bottine"]
###############################################################################
# Phase d'apprentissage
###############################################################################
n = 30 # 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)
keras.backend.clear_session()
# model = keras.models.Sequential() # Modèle de reseau de neurones
# model.add(keras.layers.Flatten(input_shape=[28, 28])) # Couche d'entrée : mise à plat des données d'entrée -> 1 node / pixel soit 784 (28x28)
# model.add(keras.layers.Dense(300, activation="relu")) # Couche 1 : 300 nodes
# # model.add(keras.layers.Dense(300, activation="relu")) # Couche 2 : 300 nodes -> passage de 100 à 300
# # model.add(keras.layers.Dense(300, activation="relu")) # Couche 3 : 300 nodes -> ajout
# model.add(keras.layers.Dense(100, activation="relu")) # Couche 4 : 100 nodes -> ajout
# model.add(keras.layers.Dense(10, activation="softmax")) # Couche de sortie : 1 node par classe soit 10
# # model.compile(loss="sparse_categorical_crossentropy", optimizer="sgd", metrics=["accuracy"])
# 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, validation_data=(X_valid, y_valid)) # 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'], 'b-', 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))

View File

@ -0,0 +1,167 @@
import os, time
import numpy as np
import matplotlib.pyplot as plt
import tensorflow as tf
from tensorflow import keras
###############################################################################
# 05-keras-tf_playground-gauss.py
# @title: Introduction aux réseaux de neurones - Portage de TensorFlow Playground vers Keras - Points en gaussienne
# @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(layout="constrained", figsize=(15, 5))
fig.suptitle("Réseaux de neurones avec Keras - Classificateur d'images")
subfigs = fig.subfigures(1, 3)
model_ax = subfigs[0].subplots(1, 1)
apts_ax = subfigs[1].subplots(1, 1)
img_ax = subfigs[2].subplots(4, 8)
###############################################################################
# Observations
###############################################################################
# Observations d'apprentissage, de validation et de test
vetement = keras.datasets.fashion_mnist # Jeu de données Fashion MNIST
(X, y), (X_test, y_test) = vetement.load_data()
X_train, y_train = X[5000:]/255.0 , y[5000:]
X_valid, y_valid = X[:5000]/255.0 , y[:5000]
classes = ["Tshirt", "Pantalon", "Pull", "Robe", "Manteau", "Sandale", "Chemise", "Basket", "Sac", "Bottine"]
###############################################################################
# Phase d'apprentissage
###############################################################################
n = 30 # 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)
keras.backend.clear_session()
# np.random.seed(42)
# tf.random.set_seed(42)
model = keras.models.Sequential() # Modèle de reseau de neurones
model.add(keras.layers.Flatten(input_shape=[28, 28])) # Couche d'entrée : mise à plat des données d'entrée -> 1 node / pixel soit 784 (28x28)
model.add(keras.layers.Dense(300, activation="relu")) # Couche 1 : 300 nodes
# model.add(keras.layers.Dense(300, activation="relu")) # Couche 2 : 300 nodes -> passage de 100 à 300
# model.add(keras.layers.Dense(300, activation="relu")) # Couche 3 : 300 nodes -> ajout
model.add(keras.layers.Dense(100, activation="relu")) # Couche 4 : 100 nodes -> ajout
model.add(keras.layers.Dense(10, activation="softmax")) # Couche de sortie : 1 node par classe soit 10
# model.compile(loss="sparse_categorical_crossentropy", optimizer="sgd", metrics=["accuracy"])
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, validation_data=(X_valid, y_valid)) # 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'], 'b-', 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()
# Prédictions
for i in range (8):
for j in range (4):
img_ax[j][i].imshow(X_new[i*2+j], cmap="binary", interpolation="nearest")
img_ax[j][i].set_axis_off()
if y_new[i*2+j] == y_new_test[i*2+j]:
img_ax[j][i].set_title(classes[y_new[i*2+j]], fontsize=10)
else:
img_ax[j][i].set_title(classes[y_new[i*2+j]], fontsize=10, color="red")
plt.show()
# Performances
print ("Temps total : "+str(time.time()-t_debut))

View File

@ -0,0 +1,167 @@
import os, time
import numpy as np
import matplotlib.pyplot as plt
import tensorflow as tf
from tensorflow import keras
###############################################################################
# 06-keras-tf_playground-spiral.py
# @title: Introduction aux réseaux de neurones - Portage de TensorFlow Playground vers Keras - Points en spirale
# @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(layout="constrained", figsize=(15, 5))
fig.suptitle("Réseaux de neurones avec Keras - Classificateur d'images")
subfigs = fig.subfigures(1, 3)
model_ax = subfigs[0].subplots(1, 1)
apts_ax = subfigs[1].subplots(1, 1)
img_ax = subfigs[2].subplots(4, 8)
###############################################################################
# Observations
###############################################################################
# Observations d'apprentissage, de validation et de test
vetement = keras.datasets.fashion_mnist # Jeu de données Fashion MNIST
(X, y), (X_test, y_test) = vetement.load_data()
X_train, y_train = X[5000:]/255.0 , y[5000:]
X_valid, y_valid = X[:5000]/255.0 , y[:5000]
classes = ["Tshirt", "Pantalon", "Pull", "Robe", "Manteau", "Sandale", "Chemise", "Basket", "Sac", "Bottine"]
###############################################################################
# Phase d'apprentissage
###############################################################################
n = 30 # 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)
keras.backend.clear_session()
# np.random.seed(42)
# tf.random.set_seed(42)
model = keras.models.Sequential() # Modèle de reseau de neurones
model.add(keras.layers.Flatten(input_shape=[28, 28])) # Couche d'entrée : mise à plat des données d'entrée -> 1 node / pixel soit 784 (28x28)
model.add(keras.layers.Dense(300, activation="relu")) # Couche 1 : 300 nodes
# model.add(keras.layers.Dense(300, activation="relu")) # Couche 2 : 300 nodes -> passage de 100 à 300
# model.add(keras.layers.Dense(300, activation="relu")) # Couche 3 : 300 nodes -> ajout
model.add(keras.layers.Dense(100, activation="relu")) # Couche 4 : 100 nodes -> ajout
model.add(keras.layers.Dense(10, activation="softmax")) # Couche de sortie : 1 node par classe soit 10
# model.compile(loss="sparse_categorical_crossentropy", optimizer="sgd", metrics=["accuracy"])
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, validation_data=(X_valid, y_valid)) # 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'], 'b-', 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()
# Prédictions
for i in range (8):
for j in range (4):
img_ax[j][i].imshow(X_new[i*2+j], cmap="binary", interpolation="nearest")
img_ax[j][i].set_axis_off()
if y_new[i*2+j] == y_new_test[i*2+j]:
img_ax[j][i].set_title(classes[y_new[i*2+j]], fontsize=10)
else:
img_ax[j][i].set_title(classes[y_new[i*2+j]], fontsize=10, color="red")
plt.show()
# Performances
print ("Temps total : "+str(time.time()-t_debut))