EfficientNet

Fonctions :

• EfficientNetB0()

  La fonction EfficientNetB0() permet de charger l'architecture du modèle EfficientNetB0, un réseau de neurones convolutif pré-entraîné ou non. EfficientNet est connu pour ses performances exceptionnelles et son efficacité dans l'utilisation des ressources, avec une architecture optimisée qui offre un bon compromis entre précision et performance.

  Importation :

  from tensorflow.keras.applications import EfficientNetB0

  Attributs :

  Paramètre	Type	Valeur par défaut	Description
  include_top	bool	True	Inclut ou non la couche de classification finale (Dense). Si False, le modèle retourne des caractéristiques, pas une classification finale.
  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. Par défaut, `(224, 224, 3)` pour les images RGB.
  pooling	str ou None	None	Si `include_top=False`, spécifie le type de pooling appliqué à la sortie avant la couche Dense finale. Peut être 'avg' ou 'max'.
  classes	int	1000	Nombre de classes pour la classification finale si `include_top=True`.
  classifier_activation	str ou None	'softmax'	Fonction d’activation pour la couche de classification. Utilisé 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 import EfficientNetB0
  from tensorflow.keras.applications.efficientnet import preprocess_input, decode_predictions
  from tensorflow.keras.preprocessing import image
  import urllib.request
  
  # Charger le modèle EfficientNetB0 pré-entraîné
  model = EfficientNetB0(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 EfficientNetB0 (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 EfficientNetB0
  
  # 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 la modélisation, la gestion des données et l’affichage. 
  - Import du modèle EfficientNetB0 pré-entraîné, des fonctions de pré-traitement et décodage des prédictions spécifiques à EfficientNet. 
  - Import des utilitaires Keras pour le chargement et la manipulation d’images. 
  - Import de `urllib.request` pour télécharger une image depuis une URL. 
  
  2. Chargement du modèle EfficientNetB0 pré-entraîné
   
  - Chargement du modèle EfficientNetB0 avec les poids appris sur ImageNet (`weights='imagenet'`). 
  - Ce modèle est conçu pour faire de la classification d’images sur 1000 classes 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 et redimensionnement de l’image à la taille 224×224 pixels, conforme aux exigences du modèle. - Conversion de l’image en tableau numérique avec ajout d’une dimension batch. 
  - Application du pré-traitement spécifique EfficientNetB0 (`preprocess_input`) pour normaliser les pixels comme attendu par le modèle. 
  
  4. Prédiction avec le modèle
   
  - Passage de l’image pré-traitée dans le modèle pour obtenir la prédiction des probabilités sur les différentes classes. 
  
  5. Décodage et affichage des résultats
   
  - Conversion des scores bruts en noms de classes lisibles avec `decode_predictions`. 
  - Affichage des trois classes les plus probables avec leur pourcentage de confiance. 
  
  6. Affichage de l’image d’entrée
   
  - Visualisation de l’image originale pour contextualiser la classification faite par le modèle.