ResNet (Residual Networks)

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 :

  📋 Copy

  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.