mirror of
https://forge.apps.education.fr/phroy/mes-scripts-de-ml.git
synced 2024-01-27 11:30:36 +01:00
Vision par ordinateur : réécriture du modèle RNA simple
This commit is contained in:
parent
255b1a6c60
commit
795b1f98c2
@ -1 +0,0 @@
|
||||
phroy@debian.1845707:1687544904
|
||||
@ -6,8 +6,8 @@ import tensorflow as tf
|
||||
from tensorflow import keras
|
||||
|
||||
###############################################################################
|
||||
# 01-digit_simple.py
|
||||
# @title: Vision par ordinateur - Reconnaissance de digit - Préparation des données
|
||||
# 01-digit-prepa_data.py
|
||||
# @title: Vision par ordinateur - Reconnaissance de digit - Analyse et préparation des données
|
||||
# @project: Mes scripts de ML
|
||||
# @lang: fr
|
||||
# @authors: Philippe Roy <philippe.roy@ac-grenoble.fr>
|
||||
@ -53,17 +53,10 @@ from tensorflow import keras
|
||||
t_debut = time.time()
|
||||
|
||||
# Init des plots
|
||||
# fig = plt.figure(layout="constrained", figsize=(15, 5))
|
||||
fig = plt.figure(layout="constrained", figsize=(20, 7))
|
||||
fig.suptitle("Vision par ordinateur - Reconnaissance de digit par réseaux de neurones simples")
|
||||
# subfigs = fig.subfigures(1, 3)
|
||||
# model_ax = subfigs[0].subplots(1, 1)
|
||||
# apts_ax = subfigs[1].subplots(1, 1)
|
||||
# img_ax = subfigs[2].subplots(8, 10)
|
||||
fig.suptitle(" Vision par ordinateur - Reconnaissance de digit - Analyse et préparation des données")
|
||||
img_ax = fig.subplots(10, 30)
|
||||
|
||||
|
||||
|
||||
###############################################################################
|
||||
# Observations
|
||||
###############################################################################
|
||||
|
||||
@ -53,16 +53,12 @@ from tensorflow import keras
|
||||
t_debut = time.time()
|
||||
|
||||
# Init des plots
|
||||
# fig = plt.figure(layout="constrained", figsize=(15, 5))
|
||||
fig = plt.figure(layout="constrained", figsize=(20, 7))
|
||||
fig = plt.figure(layout="constrained", figsize=(15, 5))
|
||||
fig.suptitle("Vision par ordinateur - Reconnaissance de digit par réseaux de neurones simples")
|
||||
# subfigs = fig.subfigures(1, 3)
|
||||
# model_ax = subfigs[0].subplots(1, 1)
|
||||
# apts_ax = subfigs[1].subplots(1, 1)
|
||||
# img_ax = subfigs[2].subplots(8, 10)
|
||||
img_ax = fig.subplots(10, 30)
|
||||
|
||||
|
||||
subfigs = fig.subfigures(1, 3)
|
||||
model_ax = subfigs[0].subplots(1, 1)
|
||||
apts_ax = subfigs[1].subplots(1, 1)
|
||||
img_ax = subfigs[2].subplots(8, 10)
|
||||
|
||||
###############################################################################
|
||||
# Observations
|
||||
@ -71,35 +67,32 @@ img_ax = fig.subplots(10, 30)
|
||||
# Observations d'apprentissage, de validation et de test
|
||||
|
||||
chiffre = keras.datasets.mnist # Jeu de données MNIST (digit)
|
||||
# train_filter = np.unique(Y_train, return_index=True)
|
||||
# X_train, Y_train = X_train[train_filter[1:]], Y_train[train_filter[1:]]
|
||||
(X, y), (X_test, y_test) = chiffre.load_data()
|
||||
X_train, y_train = X[5000:]/255.0 , y[5000:]
|
||||
X_valid, y_valid = X[:5000]/255.0 , y[:5000]
|
||||
classes = [0,1,2,3,4,5,6,7,8,9]
|
||||
|
||||
# ###############################################################################
|
||||
# # Phase d'apprentissage
|
||||
# ###############################################################################
|
||||
###############################################################################
|
||||
# Phase d'apprentissage
|
||||
###############################################################################
|
||||
|
||||
# n = 2 # 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)
|
||||
n = 50 # Nombre d'itérations (valeur par défaut : 50 , 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="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(100, activation="relu")) # Couche 2 : 100 nodes -> ajout
|
||||
# model.add(keras.layers.Dense(10, activation="softmax")) # Couche de sortie : 1 node par classe soit 10
|
||||
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(100, activation="relu")) # Couche 2 : 100 nodes -> ajout
|
||||
model.add(keras.layers.Dense(10, activation="softmax")) # Couche de sortie : 1 node par classe soit 10
|
||||
|
||||
# optimiseur=keras.optimizers.SGD(learning_rate= eta)
|
||||
# model.compile(loss=perte, optimizer=optimiseur, metrics=["accuracy"]) # Compilation du modèle
|
||||
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
|
||||
apts = model.fit(X_train, y_train, epochs=n, batch_size=lot, validation_data=(X_valid, y_valid)) # Entrainement
|
||||
|
||||
###############################################################################
|
||||
# Phase d'inférence
|
||||
@ -108,116 +101,47 @@ classes = [0,1,2,3,4,5,6,7,8,9]
|
||||
print ("\n")
|
||||
print ("Test sur les 80 images différentes sur un jeu de 10 000 images.")
|
||||
|
||||
# X_new = np.empty([80, 28, 28])
|
||||
# y_new_test = np.empty(80)
|
||||
# for i_new in range(80):
|
||||
# # print ("i_new ", i_new )
|
||||
|
||||
# # Boucle de remplissage
|
||||
# deja_present=True
|
||||
# while deja_present == True:
|
||||
# idx = np.random.randint(X_test.shape[0]) # Index aléatoire
|
||||
# # print ("idx ", idx )
|
||||
# X_idx = X_test[idx]
|
||||
|
||||
# # Comparaison de chaque images présentes avec image idx
|
||||
# deja_present_unitaire=[]
|
||||
# for i_img in range (80):
|
||||
# # print ("i_img ", i_img )
|
||||
# deja_present_unitaire.append(True)
|
||||
# for j in range (28):
|
||||
# for k in range (28):
|
||||
# if X_new[i_img][j][k] != X_idx[j][k]:
|
||||
# deja_present_unitaire[i_img]=False
|
||||
|
||||
# # Test sur l'ensemble des images
|
||||
# deja_present=False
|
||||
# for i_img in range (80):
|
||||
# if deja_present_unitaire[i_img]==True:
|
||||
# deja_present = True
|
||||
|
||||
# # Ajout de la nouvelle image idx
|
||||
# X_new[i_new]=X_test[idx]
|
||||
# y_new_test[i_new] = y_test[idx]
|
||||
# print ("ajout ", i_new, idx)
|
||||
|
||||
# FIXME : ne marche pas -> à faire à la main
|
||||
|
||||
# (X_train, Y_train), (X_test, Y_test) = tf.keras.datasets.mnist.load_data()
|
||||
# train_filter = np.unique(Y_train, return_index=True)
|
||||
# X_train, Y_train = X_train[train_filter[1:]], Y_train[train_filter[1:]]
|
||||
|
||||
X_new_unique = np.unique(X_test, axis=0, return_index=True)
|
||||
|
||||
# X_new = np.empty([80, 28, 28])
|
||||
# y_new_test = np.empty(80)
|
||||
# new_unique = random.sample(list(X_new_unique_i), 80)
|
||||
# for i in range(80):
|
||||
# X_new[i]=X_test[new_unique[i]]
|
||||
# y_new_test[i] = y_test[new_unique[i]]
|
||||
|
||||
# X_new_idx = np.empty(80)
|
||||
# for i in range(80):
|
||||
|
||||
# # Vérification que l'index aléatoire n'a pas été
|
||||
# idx_unique= False
|
||||
# while idx_unique ==False :
|
||||
# idx_unique= True
|
||||
# idx = np.random.randint(len(test_filter[1])) # Index aléatoire
|
||||
# for j in range (80):
|
||||
# if X_new_idx[j] == idx:
|
||||
# idx_unique= False
|
||||
|
||||
|
||||
# X_new[i]=X_test[idx]
|
||||
# y_new_test[i] = y_test[idx]
|
||||
|
||||
# y_new = np.argmax(model.predict(X_new), axis=-1)
|
||||
idx = np.random.randint(X_test.shape[0]-80) # Index aléatoire
|
||||
print ("\n")
|
||||
print ("Test sur les images de "+ str(idx) + " à "+ str(idx+80) + " sur un jeu de 10 000 images.")
|
||||
X_new = X_test[idx:idx+80]
|
||||
y_new = np.argmax(model.predict(X_new), axis=-1) # Prédictions
|
||||
y_new_test= y_test[idx:idx+80] # Cibles
|
||||
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
|
||||
# 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 (10):
|
||||
# for j in range (8):
|
||||
# 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")
|
||||
# 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
|
||||
k=0
|
||||
for i in range (10): # Ligne
|
||||
for j in range (30): # Colonne
|
||||
img_ax[i][j].imshow(X_test[k], cmap="binary", interpolation="nearest")
|
||||
img_ax[i][j].set_axis_off()
|
||||
img_ax[i][j].set_title(str(k)+" : "+str(y_test[k]), fontsize=10)
|
||||
k+=1
|
||||
for i in range (10):
|
||||
for j in range (8):
|
||||
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(y_new[i*2+j], fontsize=10)
|
||||
else:
|
||||
img_ax[j][i].set_title(y_new[i*2+j], fontsize=10, color="red")
|
||||
|
||||
plt.show()
|
||||
|
||||
|
||||
# Performances
|
||||
print ("Temps total : "+str(time.time()-t_debut))
|
||||
|
||||
@ -7,7 +7,7 @@ from tensorflow import keras
|
||||
|
||||
###############################################################################
|
||||
# 03-digit-cnn.py
|
||||
# @title: Vision par ordinateur -Reconnaissance de digit - Réseaux de neurones convolutifs
|
||||
# @title: Vision par ordinateur - Reconnaissance de digit - Réseaux de neurones convolutifs
|
||||
# @project: Mes scripts de ML
|
||||
# @lang: fr
|
||||
# @authors: Philippe Roy <philippe.roy@ac-grenoble.fr>
|
||||
|
||||
Loading…
Reference in New Issue
Block a user