Reconnaître des chiffres manuscrits à l'aide de réseaux de neurones convolutifs

L'ensemble de données MNIST est composé de chiffres manuscrits et comprend 60 000 échantillons d'apprentissage et 10 000 échantillons de test. Chaque échantillon est une image en niveaux de gris de 28 x 28 pixels représentant un nombre de 0 à 9.

Convolutional Neural Network (CNN) est un modèle utilisé pour la classification d'images dans l'apprentissage profond. Il extrait les caractéristiques de l'image via des couches convolutives et des couches de regroupement, et utilise des couches entièrement connectées pour la classification.

Ci-dessous, je vais vous présenter comment utiliser Python et TensorFlow pour implémenter un modèle CNN simple afin de classer l'ensemble de données MNIST.

Tout d'abord, nous devons importer les bibliothèques nécessaires et l'ensemble de données MNIST :

import tensorflow as tf
from tensorflow.keras.datasets import mnist

# 加载MNIST数据集
(x_train, y_train), (x_test, y_test) = mnist.load_data()

Ensuite, nous devons normaliser les données d'image et convertir les données d'étiquette dans un format d'encodage à chaud :

# 归一化图像数据
x_train = x_train / 255.0
x_test = x_test / 255.0

# 将标签数据转换为独热编码格式
y_train = tf.keras.utils.to_categorical(y_train, num_classes=10)
y_test = tf.keras.utils.to_categorical(y_test, num_classes=10)

Ensuite, nous définissons le Modèle CNN. Ce modèle comprend deux couches convolutives et deux couches de pooling, ainsi qu'une couche entièrement connectée. Nous utilisons la fonction d'activation ReLU et la fonction d'activation Softmax dans la dernière couche de classification. Le code est le suivant :

model = tf.keras.models.Sequential([
    # 第一个卷积层
    tf.keras.layers.Conv2D(filters=32, kernel_size=(3, 3), activation='relu', input_shape=(28, 28, 1)),
    tf.keras.layers.MaxPooling2D(pool_size=(2, 2)),
    # 第二个卷积层
    tf.keras.layers.Conv2D(filters=64, kernel_size=(3, 3), activation='relu'),
    tf.keras.layers.MaxPooling2D(pool_size=(2, 2)),
    # 将特征图展平
    tf.keras.layers.Flatten(),
    # 全连接层
    tf.keras.layers.Dense(units=128, activation='relu'),
    # 输出层
    tf.keras.layers.Dense(units=10, activation='softmax')
])

Ensuite, nous devons compiler le modèle et spécifier la fonction de perte, l'optimiseur et les métriques d'évaluation :

# 编译模型
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

Enfin, nous entraînons le modèle et le testons :

# 训练模型
model.fit(x_train.reshape(-1, 28, 28, 1), y_train, epochs=5, batch_size=32)

# 测试模型
score = model.evaluate(x_test.reshape(-1, 28, 28, 1), y_test, verbose=0)
print('Test loss:', score[0])
print('Test accuracy:', score[1])

Après avoir exécuté le code complet, nous pouvons voir le modèle. La précision du test est d'environ 99 %.

Pour résumer, les étapes pour utiliser les réseaux de neurones convolutifs pour classer l'ensemble de données MNIST sont les suivantes :

1. Chargez l'ensemble de données MNIST et effectuez le prétraitement, y compris la normalisation et l'encodage à chaud ; . Définir le modèle CNN, y compris la couche convolutive, la couche de pooling et la couche entièrement connectée, et spécifier la fonction d'activation

3. Compiler le modèle, spécifier la fonction de perte, l'optimiseur et l'indice d'évaluation ; modélisez-le et testez-le sur l’ensemble de test.

Ce qui précède est un exemple simple qui peut être modifié et optimisé en fonction de circonstances spécifiques.

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!