Exemple de classification d'images en Python

Python est un langage de programmation largement utilisé et très populaire en vision par ordinateur et en traitement d'images. Dans cet article, nous explorerons des exemples de classification d'images en Python. La classification d'images est une tâche fondamentale en vision par ordinateur qui consiste à identifier des objets ou des scènes dans des images. Cet article expliquera comment utiliser le framework d'apprentissage profond Keras en Python pour implémenter la formation et la prédiction de modèles de classification d'images.

Préparation

Avant de procéder à la classification des images, nous devons installer les logiciels nécessaires. Vous trouverez ci-dessous la liste des packages nécessaires :

• Python 3.x
• Keras
• TensorFlow
• NumPy
• Pillow

Vous pouvez utiliser l'outil pip pour installer les packages ci-dessus. Exécutez la commande suivante dans la ligne de commande pour installer les packages logiciels nécessaires :

pip install keras
pip install tensorflow
pip install numpy
pip install Pillow

Dataset

Avant de procéder à la classification d'images, nous avons besoin d'un ensemble de données. Un ensemble de données fait référence à un ensemble d'images annotées utilisées pour entraîner et tester des modèles de classification d'images. Dans cet exemple, nous utiliserons l'ensemble de données MNIST. L'ensemble de données MNIST contient des images de chiffres manuscrits et constitue un ensemble de données largement utilisé pour tester les performances des algorithmes de classification d'images.

L'ensemble de données MNIST contient 60 000 images d'entraînement et 10 000 images de test, chaque image mesure 28 x 28 pixels. Les images ont été étiquetées avec l'un des 10 chiffres de 0 à 9.

Dans Keras, vous pouvez utiliser le code suivant pour télécharger l'ensemble de données MNIST :

from keras.datasets import mnist

(train_images, train_labels), (test_images, test_labels) = mnist.load_data()

Construire le modèle

Avant de construire le modèle de classification d'images, nous devons définir l'architecture du modèle. Dans cet exemple, nous utiliserons un modèle de réseau neuronal convolutif (CNN). Le modèle CNN est un modèle d'apprentissage profond qui fonctionne bien en matière de classification d'images.

Keras offre un moyen simple de créer des modèles CNN. Voici le code d'un exemple de modèle CNN :

from keras import layers
from keras import models

model = models.Sequential()

model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)))
model.add(layers.MaxPooling2D((2, 2)))

model.add(layers.Conv2D(64, (3, 3), activation='relu'))
model.add(layers.MaxPooling2D((2, 2)))

model.add(layers.Flatten())

model.add(layers.Dense(64, activation='relu'))
model.add(layers.Dense(10, activation='softmax'))

model.summary()

Dans le code ci-dessus, nous définissons un modèle CNN contenant deux couches convolutives et deux couches de pooling maximum. Le modèle comprend également deux couches denses, chacune utilisant la fonction d'activation ReLU.

Entraîner le modèle

Après avoir défini le modèle, nous devons entraîner le modèle. Pendant la formation, le modèle apprend à mapper les images d'entrée aux catégories numériques correctes.

Dans Keras, le code suivant peut être utilisé pour compiler et entraîner le modèle :

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

train_images = train_images.reshape((60000, 28, 28, 1))
train_images = train_images.astype('float32') / 255

test_images = test_images.reshape((10000, 28, 28, 1))
test_images = test_images.astype('float32') / 255

from keras.utils import to_categorical

train_labels = to_categorical(train_labels)
test_labels = to_categorical(test_labels)

model.fit(train_images, train_labels, epochs=5, batch_size=64)

Dans le code ci-dessus, nous prétraitons d'abord l'image puis compilons le modèle avec l'optimiseur comme "rmsprop" et la fonction de perte comme cross- modèle d'entropie. Nous utilisons ensuite les images et les étiquettes d'entraînement pour entraîner le modèle. A la fin de chaque époque, nous testons le modèle à l'aide d'images et d'étiquettes tests.

Tester le modèle

Une fois la formation du modèle terminée, nous pouvons utiliser l'ensemble de données de test pour tester l'exactitude du modèle. Le modèle peut être testé en utilisant le code suivant :

test_loss, test_acc = model.evaluate(test_images, test_labels)
print('test_acc:', test_acc)

Ensuite, nous pouvons faire des prédictions en utilisant le code suivant :

predictions = model.predict(test_images)

import numpy as np

print(np.argmax(predictions[0]))

Dans le code ci-dessus, nous prédisons la première image de l'ensemble d'images de test, puis utilisons Numpy pour trouver le maximum valeur d'index et imprimer les résultats de la prédiction.

Conclusion

Dans cet article, nous avons présenté comment utiliser le framework d'apprentissage profond Keras en Python pour implémenter la formation et la prédiction de modèles de classification d'images. Nous utilisons l'ensemble de données MNIST pour les tests et le modèle CNN pour la formation. Enfin, nous testons la précision du modèle en effectuant des prédictions sur un ensemble d'images de test. Cet exemple peut être utilisé comme exemple d'introduction à l'apprentissage profond et à la vision par ordinateur, permettant aux débutants de comprendre comment utiliser Python pour implémenter des tâches de classification d'images.

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!