Deep Learning avec Keras - Préparation des données

Avant de transmettre les données à notre réseau, elles doivent être converties au format requis par le réseau. C'est ce qu'on appelle la préparation des données pour le réseau. Il consiste généralement à convertir une entrée multidimensionnelle en un vecteur à une seule dimension et à normaliser les points de données.

Remodeler le vecteur d'entrée

Les images de notre ensemble de données sont constituées de 28 x 28 pixels. Cela doit être converti en un vecteur unidimensionnel de taille 28 * 28 = 784 pour le nourrir dans notre réseau. Nous le faisons en appelant lereshape méthode sur le vecteur.

X_train = X_train.reshape(60000, 784)
X_test = X_test.reshape(10000, 784)

Désormais, notre vecteur d'apprentissage sera composé de 60000 points de données, chacun étant constitué d'un vecteur de dimension unique de taille 784. De même, notre vecteur de test sera composé de 10000 points de données d'un vecteur monodimensionnel de taille 784.

Normalisation des données

Les données que le vecteur d'entrée contient actuellement ont une valeur discrète entre 0 et 255 - les niveaux d'échelle de gris. La normalisation de ces valeurs de pixels entre 0 et 1 aide à accélérer la formation. Comme nous allons utiliser la descente de gradient stochastique, la normalisation des données aidera également à réduire le risque de rester coincé dans les optima locaux.

Pour normaliser les données, nous les représentons en tant que type float et les divisons par 255 comme indiqué dans l'extrait de code suivant -

X_train = X_train.astype('float32')
X_test = X_test.astype('float32')
X_train /= 255
X_test /= 255

Voyons maintenant à quoi ressemblent les données normalisées.

Examen des données normalisées

Pour afficher les données normalisées, nous appellerons la fonction d'histogramme comme indiqué ici -

plot.hist(X_train[0])
plot.title("Digit: {}".format(y_train[0]))

Ici, nous traçons l'histogramme du premier élément du X_trainvecteur. Nous imprimons également le chiffre représenté par ce point de données. La sortie de l'exécution du code ci-dessus est affichée ici -

Vous remarquerez une densité épaisse de points ayant une valeur proche de zéro. Ce sont les points noirs de l'image, qui constituent évidemment la partie principale de l'image. Le reste des points d'échelle de gris, qui sont proches de la couleur blanche, représentent le chiffre. Vous pouvez vérifier la distribution des pixels pour un autre chiffre. Le code ci-dessous imprime l'histogramme d'un chiffre à l'index de 2 dans l'ensemble de données d'apprentissage.

plot.hist(X_train[2])
plot.title("Digit: {}".format(y_train[2])

La sortie de l'exécution du code ci-dessus est indiquée ci-dessous -

En comparant les deux chiffres ci-dessus, vous remarquerez que la distribution des pixels blancs dans deux images diffère indiquant une représentation d'un chiffre différent - «5» et «4» dans les deux images ci-dessus.

Ensuite, nous examinerons la distribution des données dans notre ensemble de données d'entraînement complet.

Examen de la distribution des données

Avant d'entraîner notre modèle d'apprentissage automatique sur notre ensemble de données, nous devons connaître la distribution des chiffres uniques dans notre ensemble de données. Nos images représentent 10 chiffres distincts allant de 0 à 9. Nous aimerions connaître le nombre de chiffres 0, 1, etc., dans notre jeu de données. Nous pouvons obtenir ces informations en utilisant leunique méthode de Numpy.

Utilisez la commande suivante pour imprimer le nombre de valeurs uniques et le nombre d'occurrences de chacune

print(np.unique(y_train, return_counts=True))

Lorsque vous exécutez la commande ci-dessus, vous verrez la sortie suivante -

(array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=uint8), array([5923, 6742, 5958, 6131, 5842, 5421, 5918, 6265, 5851, 5949]))

Il montre qu'il existe 10 valeurs distinctes - 0 à 9. Il y a 5923 occurrences du chiffre 0, 6742 occurrences du chiffre 1, et ainsi de suite. La capture d'écran de la sortie est affichée ici -

Comme dernière étape de la préparation des données, nous devons encoder nos données.

Codage des données

Nous avons dix catégories dans notre ensemble de données. Nous allons donc encoder notre sortie dans ces dix catégories en utilisant un encodage one-hot. Nous utilisons la méthode to_categorial des utilitaires Numpy pour effectuer l'encodage. Une fois les données de sortie codées, chaque point de données serait converti en un vecteur dimensionnel unique de taille 10. Par exemple, le chiffre 5 sera désormais représenté par [0,0,0,0,0,1,0,0,0 , 0].

Encodez les données en utilisant le morceau de code suivant -

n_classes = 10
Y_train = np_utils.to_categorical(y_train, n_classes)

Vous pouvez vérifier le résultat du codage en imprimant les 5 premiers éléments du vecteur Y_train catégorisé.

Utilisez le code suivant pour imprimer les 5 premiers vecteurs -

for i in range(5):
   print (Y_train[i])

Vous verrez la sortie suivante -

[0. 0. 0. 0. 0. 1. 0. 0. 0. 0.]
[1. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
[0. 0. 0. 0. 1. 0. 0. 0. 0. 0.]
[0. 1. 0. 0. 0. 0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0. 0. 0. 0. 0. 1.]

Le premier élément représente le chiffre 5, le second le chiffre 0, et ainsi de suite.

Enfin, vous devrez également catégoriser les données de test, ce qui est fait à l'aide de l'instruction suivante -

Y_test = np_utils.to_categorical(y_test, n_classes)

À ce stade, vos données sont entièrement préparées pour alimenter le réseau.

Ensuite, vient la partie la plus importante et c'est la formation de notre modèle de réseau.