A Guide du débutant des keras: reconnaissance des chiffres en 30 minutes

Cet article détaille la construction d'un modèle Keras pour la reconnaissance des chiffres manuscrits à l'aide d'un réseau neuronal convolutionnel (CNN) et de l'ensemble de données MNIST. Reformons-le pour la clarté et l'amélioration du flux.

Construire un reconnaissance de chiffres manuscrits avec keras

Ce tutoriel montre la création d'un modèle pour reconnaître les chiffres manuscrits à l'aide de la bibliothèque Keras de Python, une API de haut niveau qui simplifie la construction et la formation de réseaux de neurones. Nous tirons parti de la puissance des réseaux de neurones convolutionnels (CNNS) et de l'ensemble de données MNIST largement utilisé.

Comprendre l'approche

Notre modèle utilise un CNN, une architecture particulièrement efficace pour la classification des images. Contrairement aux réseaux de neurones traditionnels, le CNNS traite les données dans un réseau 3D (coordonnées et couleur X), ce qui les rend idéales pour les données d'image. L'ensemble de données MNIST, contenant 60 000 formation et 10 000 exemples de tests de chiffres manuscrits, fournit les données étiquetées nécessaires pour la formation.

Réseaux de neurones artificiels (ANN) et CNNS

Ann est un modèle mathématique transformant les données d'entrée en sortie à travers des couches cachées, chaque couche représentant une probabilité. La formation consiste à ajuster les poids et les biais en fonction des erreurs, permettant au réseau d'apprendre les modèles.

CNNS offre un avantage significatif pour le traitement d'image. Leur structure de réseau 3D signifie que chaque nœud de couche caché se connecte à une petite région d'entrée, augmentant considérablement l'efficacité par rapport aux ANN traditionnels. Les couches CNN clés comprennent des couches convolutionnelles (extraction de caractéristiques), des couches de pool (réduction des caractéristiques), des couches d'aplatissement (réduction de la dimensionnalité) et une couche de classification finale.

Travailler avec l'ensemble de données MNIST

L'ensemble de données MNIST est facilement disponible dans Keras. Nous chargeons les données de formation et de test en utilisant mnist.load_data(). Visualiser des chiffres d'échantillons aide à comprendre la structure des données:

from keras.datasets import mnist
import matplotlib.pyplot as plt

(x_train, y_train), (x_test, y_test) = mnist.load_data()
image_index = 35
plt.imshow(x_train[image_index], cmap='Greys')
plt.show()

Les ensembles de formation et de test ont des dimensions (60000, 28, 28) et (10000, 28, 28) respectivement, indiquant des images de 28x28 pixels.

Prétraitement des données

Avant la création du modèle, les données doivent être prétraitées:

1. Reshaper: Les images sont remodelées au format (m x n x 1) en utilisant .reshape().
2. normalisation: Les valeurs de pixels (0-255) sont normalisées à 0-1 en divisant par 255.
3. codage à un hot: La variable dépendante (y_train, y_test) est convertie en matrice de classe binaire en utilisant to_categorical() pour la compatibilité avec la sortie du modèle.

from keras.datasets import mnist
import matplotlib.pyplot as plt

(x_train, y_train), (x_test, y_test) = mnist.load_data()
image_index = 35
plt.imshow(x_train[image_index], cmap='Greys')
plt.show()

Conception et formation du modèle

Notre modèle CNN est construit séquentiellement:

1. Couches convolutionnelles: Extraire les fonctionnalités des images d'entrée.
2. Couche de mise en commun: réduit la dimensionnalité et le coût de calcul.
3. Couche de dépôt: Empêche le sur-ajustement.
4. Couche d'aplatissement: convertit la sortie multidimensionnelle en un tableau 1D.
5. Couches denses: Effectuer la classification finale.

img_rows, img_cols = 28, 28
x_train = x_train.reshape(x_train.shape[0], img_rows, img_cols, 1) / 255
x_test = x_test.reshape(x_test.shape[0], img_rows, img_cols, 1) / 255
y_train = to_categorical(y_train, num_classes=10)
y_test = to_categorical(y_test, num_classes=10)

Le modèle est compilé en utilisant sparse_categorical_crossentropy perte (pour les étiquettes entières), l'optimiseur ADAM et la précision comme métrique. La formation est effectuée à l'aide de .fit(), spécifiant les époques et la taille du lot. Le modèle qualifié est enregistré pour une utilisation ultérieure.

from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten, Conv2D, MaxPooling2D

model = Sequential([
    Conv2D(32, (3, 3), activation='relu', input_shape=(img_rows, img_cols, 1)),
    Conv2D(64, (3, 3), activation='relu'),
    MaxPooling2D((2, 2)),
    Dropout(0.25),
    Flatten(),
    Dense(128, activation='relu'),
    Dropout(0.5),
    Dense(10, activation='softmax') # 10 output classes (digits 0-9)
])

Test avec une image personnalisée

Pour tester le modèle, nous chargeons une image de chiffre manuscrite personnalisée, le préparez-le (converti en niveaux de gris, remodelage, normalisation), chargez le modèle enregistré et utilisez .predict() pour obtenir la classification.

model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
model.fit(x_train, y_train, batch_size=128, epochs=10, validation_data=(x_test, y_test))
model.save("test_model.h5")

Conclusion

Ce tutoriel fournit une compréhension fondamentale de la construction d'un modèle de reconnaissance de chiffres manuscrits à l'aide de keras et de CNN. Tout en atteignant une précision élevée (par exemple, & gt; 99%), d'autres améliorations sont possibles grâce à un réglage des paramètres du modèle, à l'augmentation des données et à l'exploration des architectures CNN plus avancées. Les FAQ fournies offrent des informations supplémentaires sur les concepts impliqués.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!