TP1 : Mise en place d’un réseau de neurones convolutifs
L’objectif de ce TP est de construire de réseau de neurones convolutif capable de
prédire à partir d’une image s’il s’agit d’un chien ou d’un chat
1. Description de la base de données
La base d’image « dataset » contient 3 dossiers :
- « training_set » : contenant les images de chiens et de chats pour la phase
d’apprentissage. On dispose de 4000 images chiens et 4000 images de chats
- « test_set » dédiés à la phase de test (1000 images de chiens et 1000 de chats)
- « single_prediction » : dossier contenant des images pour la validation
2. Présentation de Outils Python pour le CNN
Pour construire un ANN nous allons importer les modules suivants :
# Importing libraries
from [Link] import Sequential
from [Link] import Conv2D
from [Link] import MaxPooling2D
from [Link] import Flatten
from [Link] import Dense
Les classes et méthodes suivantes seront utilisées :
- Sequential() : Cette méthode permet d’initialiser un réseaux de neurones
- [Link].Conv2D(filters, kernel_size, strides=(1,
1), activation=None, input_shape = None
kernel_initializer='uniform')
: Elle permet d’appliquer la couche de convolution sur les données :
filters: correspond au nombre de feature maps que l’on souhaiterait
avoir en sortie de la convolution
kernel_size: (hauteur, largeur) du filtre
strides: pas de la fenètre
activation : fonction d’activation
input_shape : dimension de l’image
- MaxPooling2D(pool_size = None) : Elle permet de réaliser la couche
de Pooling
- Flatten() : cette méthode permet de réaliser l’étape de Flatening
3. Réalisation du réseau CNN
3.1. Création du réseau
Le code ci-dessous illustre le réseau CNN que nous souhaiterons créer
# Initialising the CNN
classifier = Sequential()
# Step 1 - Convolution
[Link](Conv2D(filter=32, kernel_size=(3, 3), input_shape = (64, 64, 3),
activation = 'relu'))
# Step 2 - Pooling
[Link](MaxPooling2D(pool_size = (2, 2)))
# Adding a second convolutional layer
[Link](Conv2D(32, (3, 3), activation = 'relu'))
[Link](MaxPooling2D(pool_size = (2, 2)))
# Step 3 - Flattening
[Link](Flatten())
# Step 4 - Full connection
[Link](Dense(units = 128, activation = 'relu'))
[Link](Dense(units = 1, activation = 'sigmoid'))
# Compiling the CNN
[Link](optimizer = 'adam', loss = 'binary_crossentropy', metrics =
['accuracy'])
3.2. Pré-traitement des images
Le code ci-dessous présente les étapes de construction de l’ANN
from [Link] import ImageDataGenerator
train_datagen = ImageDataGenerator(rescale = 1./255,
shear_range = 0.2,
zoom_range = 0.2,
horizontal_flip = True)
test_datagen = ImageDataGenerator(rescale = 1./255)
training_set = train_datagen.flow_from_directory('dataset/training_set',
target_size = (64, 64),
batch_size = 32,
class_mode = 'binary')
test_set = test_datagen.flow_from_directory('dataset/test_set',
target_size = (64, 64),
batch_size = 32,
class_mode = 'binary')
Pour lancer la phase d’apprentissage, il suffira d’exécuter le code suivant :
classifier.fit_generator(training_set,
steps_per_epoch = 8000/32,
epochs = 150,
validation_data = test_set,
validation_steps = 2000)
3.3. Application du modèle sur de nouveau jeux de données
Une fois le modèle obtenu, nous allons l’appliquer sur de nouvelles données. La
fonction ci-dessous prend en paramètre le chemin du fichier puis lui applique le
modèle
from [Link] import image
def predict(img_file):
test_image = image.load_img(img_file, target_size = (64, 64))
test_image = image.img_to_array(test_image)
test_image = np.expand_dims(test_image, axis = 0)
result = [Link](test_image)
#training_set.class_indices
if result[0][0] == 1:
return 'chien'
return 'chat'
Tester le modèle sur les images se trouvant dans le dossier « single_prediction ».
Il est tout à fait possible d’améliorer les performances du modèle en rajoutant
notamment des couches de convolution et de pooling et de nouvelles couches cachées.
En s’inspirant du modèle d’AlexNet, créer un nouveau réseau CNN