Dans ce notebook, nous allons voir, étape par étape, comment entrainer un model pour reconnaitre des chiffres manuscrits. Pour cela nous devons :
Commençons donc par importer les bibliothèques nécessaires :
import tensorflow as tf
import keras
import numpy as np
import matplotlib
import matplotlib.pyplot as plt
Puis nous allons charger les données du dataset.
from keras.datasets import mnist
Les concepteurs de mnist ont bien fait les choses : ils ont prévu une méthode permettant de découper les données en train et test.
(X_train, y_train), (X_test, y_test) = mnist.load_data()
On peut commencer par quelques manipulations de base pour explorer les données qu'on vient de charger :
print('X_train shape: ',X_train.shape)
print('Y_train shape: ',y_train.shape)
On voit que X_train contient 60k d'exemples. Cheque exemple est une image 28 x 28. y_train contient 60k étiquettes. On peut le voir en faisant comme suit :
from matplotlib import pyplot as plt
plt.imshow(X_train[1000])
plt.show()
print(y_train[1000])
Maintenant que nous avons vu à quoi ressemble notre dataset, on peut commencer à utiliser les réseaux de neurones pour reconnaître les chiffres manuscrits.
Pour le moment, nous avons vu les réseaux de neurones "simples" et pas d'architectures avancées. Nous allons donc devoir "applatir" les données en entrée de notre réseau. En effet, les données arrivent sous forme d'images 28 x 28. Nous allons donc transformer chaque image en un vecteur de taille 28 x 28 = 784 :
num_pixels = X_train.shape[1] * X_train.shape[2]
X_train = X_train.reshape(X_train.shape[0], num_pixels)
X_test = X_test.reshape(X_test.shape[0], num_pixels)
y_train = y_train.reshape(y_train.shape[0], 1)
y_test = y_test.reshape(y_test.shape[0], 1)
print(X_train.shape)
Patience encore, nous allons faire quelques transformations supplémetaires sur les données pour changer le type de donnéese et les normer :
X_train = X_train.astype('float32')
X_test = X_test.astype('float32')
y_train = y_train.astype('float32')
y_test = y_test.astype('float32')
X_train = X_train / 255
X_test = X_test / 255
Nos données sont à présent prètes pour être utilisées pour l'entrainement d'un réseau de neurones :
On commence donc par importer les différents éléments de la bibliothèque keras nécessaires à ce qu'on souhaite faire.
from keras.models import Sequential #Il s'agit du modèle des réseaux orientés.
#Les données sont passées, après transformation, d'une couche à la suivante.
from keras.layers import Dense #Pour pouvoir ajouter une couche complètement connéectée
from keras.optimizers import sgd #Pour charger un algorithme d'ptimisation. Pour le moment,
#nous allons utiliser le sgd : stochastic gradient descent.
On transforme les deux classes en vecteurs en utilisant la technique "one-hot encoding"
y_train = keras.utils.to_categorical(y_train)
y_test = keras.utils.to_categorical(y_test)
On peut à présent écrire la fonction définissant notre réseau :
num_classes = y_train.shape[1]
def neural_network():
model = Sequential()
model.add(Dense(num_pixels, input_dim=num_pixels, kernel_initializer='normal', activation='relu'))
#model.add(Dropout(.5))
model.add(Dense(num_classes, kernel_initializer='normal', activation='softmax'))
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
return model
... instantier le modèle, afficher sa description :
model = neural_network()
model.summary()
... l'entraîner et le tester :
model.fit(X_train, y_train, validation_data=(X_test, y_test), epochs=1, batch_size=100)#98.36%
scores = model.evaluate(X_test, y_test)
print("Neural network accuracy: %.2f%%" % (scores[1]*100))
y_prob = model.predict(X_test)
y_pred = [np.argmax(y_prob[i]) for i in range(len(y_prob))]
y_test_o = [np.argmax(y_test[i]) for i in range(len(y_prob))]
#print(y_pred)
#print(y_test_o)
from sklearn import metrics
mc = metrics.confusion_matrix(y_test_o, y_pred)
print(mc)
acc = np.sum(np.diag(mc))/np.sum(mc)
print('{:2.2%}'.format(acc))
En introduisant le dropout :
def neural_network_with_do():
model = Sequential()
model.add(Dense(num_pixels, input_dim=num_pixels, kernel_initializer='normal', activation='relu'))
model.add(Dropout(.5))
model.add(Dense(num_classes, kernel_initializer='normal', activation='softmax'))
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
return model
model = neural_network()
model.summary()
model.fit(X_train, y_train, validation_data=(X_test, y_test), epochs=1, batch_size=100)#98.36%
scores = model.evaluate(X_test, y_test)
print("Neural network accuracy: %.2f%%" % (scores[1]*100))