ResNet (Residual Networks)

Les ResNet, ou réseaux résiduels, sont des architectures de réseaux de neurones convolutionnels conçues pour faciliter l’entraînement de réseaux très profonds. L’objectif est de résoudre le problème de dégradation des performances que l’on observe lorsque la profondeur du réseau augmente.

Le principe repose sur l’utilisation de blocs résiduels, où l’entrée d’un bloc est ajoutée à sa sortie via une connexion de type « skip connection » ou « shortcut ». Cette structure permet au réseau d’apprendre des fonctionnements résiduels (différences par rapport à l’identité) plutôt que d’apprendre directement la transformation complète, ce qui facilite la convergence et réduit le risque de vanishing gradient.

Les ResNet sont utilisés dans la classification d’images, la détection d’objets, la segmentation et d’autres tâches de vision par ordinateur, notamment lorsqu’il est nécessaire de construire des réseaux très profonds avec plusieurs dizaines ou centaines de couches.

En résumé, les ResNet permettent de construire des réseaux profonds efficaces en utilisant des blocs résiduels qui facilitent l’apprentissage et améliorent les performances sur des tâches complexes de vision par ordinateur.

Fonctions :

ResNet50()

La fonction ResNet50() permet de charger l'architecture du modèle de réseau de neurones convolutif ResNet-50 (Residual Network à 50 couches), pré-entraîné ou non. Ce modèle est couramment utilisé pour les tâches de classification d'images. Il est disponible dans le module tensorflow.keras.applications.

Importation :

from tensorflow.keras.applications import ResNet50

Attributs :

Paramètre	Type	Valeur par défaut	Description
include_top	bool	True	Inclut ou non la couche de classification finale (Dense). Mettre à False pour un usage en feature extractor.
weights	str ou None	'imagenet'	Charge les poids pré-entraînés sur ImageNet. Mettre à None pour un modèle non entraîné.
input_tensor	Keras tensor	None	Tenseur Keras à utiliser comme entrée du modèle.
input_shape	tuple	None	Forme de l’entrée, utile si include_top=False. Ex: (224, 224, 3).
pooling	str ou None	None	Mode de pooling à appliquer si include_top=False. 'avg' ou 'max'.
classes	int	1000	Nombre de classes de sortie si include_top=True.
classifier_activation	str ou None	'softmax'	Fonction d’activation de la couche de classification. Utilisée si include_top=True.

Exemple de code :

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
from tensorflow.keras.applications.resnet50 import ResNet50, preprocess_input, decode_predictions
from tensorflow.keras.preprocessing import image
import urllib.request

# Charger le modèle ResNet50 pré-entraîné
model = ResNet50(weights='imagenet')

# URL d'une image d'exemple
img_url = "https://upload.wikimedia.org/wikipedia/commons/2/26/YellowLabradorLooking_new.jpg"

# Télécharger l'image
img_path = "dog.jpg"
urllib.request.urlretrieve(img_url, img_path)

# Charger l'image et la préparer pour ResNet50 (224x224 pixels)
img = image.load_img(img_path, target_size=(224, 224))
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)  # normalisation spécifique ResNet50

# Faire la prédiction
preds = model.predict(x)

# Décoder les prédictions en noms de classes lisibles
print('Top 3 prédictions :')
for pred in decode_predictions(preds, top=3)[0]:
    print(f"{pred[1]} : {pred[2]*100:.2f}%")

# Afficher l'image
plt.imshow(img)
plt.axis('off')
plt.show()

Explication du code :

1. Importation des bibliothèques nécessaires

- Import de TensorFlow, NumPy et Matplotlib pour le deep learning, le traitement des données et l’affichage. - Import des modules Keras spécifiques à ResNet50 : modèle pré-entraîné, fonctions de pré-traitement et de décodage des prédictions. - Import de `urllib.request` pour télécharger une image depuis une URL.

2. Chargement du modèle ResNet50 pré-entraîné

- Chargement du modèle ResNet50 avec les poids entraînés sur ImageNet (`weights='imagenet'`). - Ce modèle est prêt à faire de la classification d’images sur 1000 catégories différentes.

3. Téléchargement et préparation de l’image

- Téléchargement de l’image depuis une URL publique et sauvegarde locale sous le nom `"dog.jpg"`. - Chargement de l’image en mémoire et redimensionnement à la taille attendue par ResNet50 : 224×224 pixels. - Conversion de l’image en tableau numérique avec une dimension supplémentaire pour le batch. - Application du pré-traitement spécifique de ResNet50 (`preprocess_input`) pour normaliser les pixels selon ce que le modèle attend.

4. Prédiction avec le modèle

- Passage de l’image pré-traitée dans le modèle pour obtenir les probabilités associées aux différentes classes ImageNet.

5. Décodage et affichage des résultats

- Conversion des probabilités en noms de classes lisibles via `decode_predictions`. - Affichage des trois classes les plus probables avec leur pourcentage de confiance.

6. Affichage de l’image d’entrée

- Affichage de l’image originale pour visualiser ce qui a été classifié par le modèle.