Exemple d'algorithme de réseau neuronal convolutif en Python

Convolutional Neural Network (CNN) est un algorithme de réseau neuronal largement utilisé dans la reconnaissance d'images, la reconnaissance vocale, le traitement du langage naturel et d'autres domaines. Il s'appuie sur la structure des neurones biologiques, traite la structure spatiale bidimensionnelle des données d'entrée et adopte une méthode de partage de poids dans la couche de convolution et la couche de pooling, ce qui réduit considérablement le nombre de paramètres à optimiser, améliorant ainsi Capacité de généralisation et efficacité du modèle.

Python est un langage de programmation largement utilisé dans les domaines du calcul scientifique, du machine learning et du deep learning. Il présente les avantages d'être simple et facile à utiliser, open source et gratuit, et riche en bibliothèques tierces. par de plus en plus de chercheurs et d'ingénieurs en développement d'outils. En Python, nous pouvons utiliser une variété de frameworks d'apprentissage en profondeur pour implémenter des algorithmes de réseaux neuronaux convolutifs, notamment Keras, TensorFlow, PyTorch, etc.

Ci-dessous, nous utiliserons un exemple pour présenter comment utiliser le framework Keras pour implémenter l'algorithme de réseau neuronal convolutif en Python.

Introduction à l'ensemble de données

Cet exemple utilise l'ensemble de données CIFAR-10, qui contient 60 000 images couleur 32x32 dans 10 catégories, et le nombre d'images dans chaque catégorie est de 6 000. Ces images sont divisées en un ensemble d’apprentissage et un ensemble de test, avec 50 000 images dans l’ensemble d’apprentissage et 10 000 images dans l’ensemble de test.

En Python, nous pouvons utiliser la fonction cifar10.load_data fournie par la bibliothèque Keras pour charger l'ensemble de données CIFAR-10, comme indiqué ci-dessous :

from keras.datasets import cifar10

(x_train, y_train), (x_test, y_test) = cifar10.load_data()

Où, x_train et x_test sont les données d'image de l'ensemble d'entraînement et de l'ensemble de test respectivement, y_train et y_test sont respectivement les étiquettes de l'ensemble d'entraînement et de l'ensemble de test.

Construction du modèle

Le modèle de réseau neuronal convolutif utilisé dans cet exemple contient plusieurs couches convolutives, des couches de regroupement et des couches entièrement connectées. La structure spécifique est la suivante :

1. Couche d'entrée : la taille de l'image d'entrée est de 32x32x3, où. 3 signifie RVB trois canaux.
2. Couche convolutive 1 : utilisez 32 noyaux de convolution de taille 3x3, la foulée est de 1 et la fonction d'activation est ReLU.
3. Couche convolutive 2 : utilisez 64 noyaux de convolution de taille 3x3, la foulée est de 1 et la fonction d'activation est ReLU.
4. Couche de pooling 1 : Utilisez un noyau de pooling de taille 2x2 avec une foulée de 2.
5. Couche convolutive 3 : utilisez 128 noyaux de convolution de taille 3x3, la foulée est de 1 et la fonction d'activation est ReLU.
6. Couche de pooling 2 : Utilisez un noyau de pooling de taille 2x2 avec une foulée de 2.
7. Couche 1 entièrement connectée : contient 128 neurones et la fonction d'activation est ReLU.
8. Couche 2 entièrement connectée : contient 10 neurones, correspondant à 10 catégories, et la fonction d'activation est Softmax.

En Python, nous pouvons construire le modèle couche par couche grâce à la classe Sequential fournie par la bibliothèque Keras, comme indiqué ci-dessous :

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

model = Sequential()
model.add(Conv2D(filters=32, kernel_size=(3, 3), strides=(1, 1), activation='relu', input_shape=(32, 32, 3)))
model.add(Conv2D(filters=64, kernel_size=(3, 3), strides=(1, 1), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2)))
model.add(Conv2D(filters=128, kernel_size=(3, 3), strides=(1, 1), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2)))
model.add(Flatten())
model.add(Dense(units=128, activation='relu'))
model.add(Dense(units=10, activation='softmax'))

model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

Parmi elles, la classe Conv2D représente la couche de convolution, la classe MaxPooling2D représente la couche de pooling, et la classe Flatten représente le multidimensionnel. L'entrée est unidimensionnelle et la classe Dense représente une couche entièrement connectée. La fonction model.compile permet de compiler le modèle et de spécifier l'algorithme d'optimisation, la fonction de perte, l'index d'évaluation, etc.

Formation et évaluation du modèle

Une fois le modèle construit, nous pouvons utiliser les données de l'ensemble de formation pour entraîner le modèle. En Python, nous pouvons utiliser la fonction fit pour implémenter la formation de modèles, comme indiqué ci-dessous :

from keras.utils import np_utils

y_train = np_utils.to_categorical(y_train, 10)
y_test = np_utils.to_categorical(y_test, 10)

model.fit(x_train, y_train, epochs=10, batch_size=64, validation_data=(x_test, y_test))

Parmi elles, la fonction np_utils.to_categorical est utilisée pour convertir les étiquettes en encodage à chaud. La fonction d'ajustement est utilisée pour entraîner le modèle, en spécifiant le nombre de cycles de formation, la taille du lot, les données de l'ensemble de validation, etc. Une fois la formation terminée, nous pouvons utiliser la fonction d'évaluation pour évaluer le modèle, comme indiqué ci-dessous :

loss, accuracy = model.evaluate(x_test, y_test)

Dans cet exemple, après 10 cycles de formation, la précision du modèle sur l'ensemble de test est de 0,7318.

Résumé

Cet article présente un exemple d'utilisation du framework Keras pour implémenter l'algorithme de réseau neuronal convolutionnel en Python. En utilisant l'ensemble de données CIFAR-10 et des structures de modèles spécifiques, nous pouvons apprendre à créer, entraîner et évaluer des réseaux de neurones convolutifs en Python. De plus, les performances du modèle peuvent être encore améliorées en ajustant la structure et les paramètres du modèle.

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!