Introduction aux données d’image

10 minutes

Dans la vision par ordinateur, nous résolvons normalement l’un des problèmes suivants :

La classification d’images est la tâche la plus simple, lorsque nous devons classer une image en une des nombreuses catégories prédéfinies, par exemple, distinguer un chat d’un chien sur une photo ou reconnaître un chiffre manuscrit.
La détection d’objets est une tâche un peu plus difficile, dans laquelle nous devons rechercher des objets connus sur l’image et les localiser, autrement dit, renvoyer le cadre englobant pour chacun des objets reconnus.
La segmentation est similaire à la détection d’objets, mais au lieu de donner une zone englobante, nous devons retourner une carte exacte de pixels décrivant chacun des objets reconnus.

Image montrant comment la détection d’objets vision par ordinateur peut être effectuée avec des chats, des chiens et des canards.

Image de CS231n Stanford Course

Images en tant que tenseurs

Vision par ordinateur fonctionne avec des images. Comme vous le savez probablement, les images se composent de pixels, de sorte qu’elles peuvent être considérées comme une collection rectangulaire (tableau) de pixels.

Dans la première partie de ce module, nous allons traiter la reconnaissance manuscrite des chiffres. Nous allons utiliser le jeu de données MNIST, qui se compose d’images en niveaux de gris de chiffres manuscrits, de 28x28 pixels. Chaque image peut être représentée sous la forme d’un tableau de 28 x 28, et les éléments de ce tableau indiquent l’intensité du pixel correspondant , soit à l’échelle de la plage 0 à 1 (auquel cas les nombres à virgule flottante sont utilisés), soit 0 à 255 (entiers). Une bibliothèque Python populaire appelée numpy est souvent utilisée avec des tâches de vision par ordinateur, car elle vous permet d’utiliser efficacement des tableaux multidimensionnels.

Pour gérer les images de couleur, nous avons besoin d’un moyen de représenter les couleurs. Dans la plupart des cas, nous représentons chaque pixel par 3 valeurs d’intensité, correspondant aux composants Rouge (R), Vert (G) et Bleu (B). Cet encodage de couleur est appelé RVB, et par conséquent, l’image de couleur de la taille W×H sera représentée sous la forme d’un tableau de taille H×W×3 (parfois l’ordre des composants peut être différent, mais l’idée est la même). Dans la représentation matricielle, la hauteur (nombre de lignes) est antérieure à la largeur (nombre de colonnes), qui est l’opposé de la convention d’image commune de W×H.

Les tableaux multidimensionnels sont également appelés tenseurs. L’utilisation de tenseurs pour représenter des images présente également un avantage, car nous pouvons utiliser une dimension supplémentaire pour stocker une séquence d’images. Par exemple, pour représenter un fragment vidéo composé de 200 images avec une dimension de 800x600 (largeur × hauteur), nous pouvons utiliser le tenseur de taille 200x600x800x3. N’oubliez pas que les dimensions de tenseur utilisent l’ordre H×W (row-major), et non la convention W×H couramment vue dans les éditeurs d’images. L'ordre ici est cadres × hauteur (600) × largeur (800) × canaux. Cet ordre est appelé channels_last « valeur par défaut » dans TensorFlow ; d’autres infrastructures placent les canaux avant la hauteur et la largeur (channels_first).

import tensorflow as tf
import keras
import matplotlib.pyplot as plt
import numpy as np

# Prints the installed TensorFlow version
print(tf.__version__)

Nous allons utiliser le framework Keras pour nos expériences. Tout au long de ce module, nous utilisons import keras (le style d’importation Keras 3 autonome), qui nécessite TensorFlow 2.16 ou version ultérieure (ou une installation autonome via pip install keras>=3.0). Si vous utilisez une version TensorFlow 2.x plus ancienne, remplacez import keras par from tensorflow import keras.

(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()

# Output: (60000, 28, 28) (60000,)
print(x_train.shape, y_train.shape)
# Output: (10000, 28, 28) (10000,)
print(x_test.shape, y_test.shape)

Visualiser le jeu de données de chiffres

Maintenant que nous avons téléchargé le jeu de données, nous pouvons visualiser certains des chiffres :

fig, ax = plt.subplots(1, 7)
for i in range(7):
    ax[i].imshow(x_train[i])
    ax[i].set_title(y_train[i])
    ax[i].axis('off')
# Displays a row of seven handwritten digit images with their labels

Structure du jeu de données

Nous avons au total 60 000 images d’entraînement et 10 000 images de test, et chaque image a une taille de 28×28 pixels :

print('Training samples:', len(x_train))
print('Test samples:', len(x_test))
print('Tensor size:', x_train[0].shape)
print('First 10 digits are:', y_train[:10])
print('Type of data is ', type(x_train))
# Output:
# Training samples: 60000
# Test samples: 10000
# Tensor size: (28, 28)
# First 10 digits are: [5 0 4 1 9 2 1 3 1 4]
# Type of data is  <class 'numpy.ndarray'>

Comme vous pouvez le voir, le type de données est un numpy array. Chaque intensité de pixel est représentée par une valeur entière comprise entre 0 et 255 :

print('Min intensity value: ', x_train.min())
print('Max intensity value: ', x_train.max())
# Output:
# Min intensity value:  0
# Max intensity value:  255

La raison pour laquelle il est compris entre 0 et 255 est parce que chaque pixel est représenté par un entier 8 bits. Dans de nombreux cas, en particulier lorsque vous travaillez avec des réseaux neuronaux, il est plus pratique de mettre à l’échelle toutes les valeurs à la plage [0, 1] en divisant par 255. Ce processus est appelé normalisation :

x_train = x_train.astype(np.float32) / 255.0
x_test = x_test.astype(np.float32) / 255.0
# Pixel values are now floating point numbers in the range [0, 1]

Maintenant, nous avons les données, et nous sommes prêts à commencer à former notre premier réseau neuronal !

Commentaires

Cette page a-t-elle été utile ?

Introduction aux données d’image

Vérifiez vos connaissances

Commentaires