Analyse d’Image Médicale

Fonctions :

• Analyse d’Image Médicale (exemple)

  L’analyse d’image médicale utilise des techniques de traitement d’image et d’apprentissage profond pour détecter, segmenter ou classifier des anomalies dans des images médicales comme des radiographies, IRM ou scanners. Cette méthode peut aider au diagnostic en automatisant la détection des structures anatomiques ou pathologies.

  Exemple de code :

  📋 Copy

  import tensorflow as tf
  from datasets import load_dataset
  import numpy as np
  import matplotlib.pyplot as plt
  
  # 3. Charger le dataset Chest X‑Ray Pneumonia
  dataset = load_dataset("hf-vision/chest-xray-pneumonia")  # public, pas besoin de token :contentReference[oaicite:0]{index=0}
  
  # 4. Inspecter un exemple
  example = dataset['train'][0]
  img = example['image']
  label = example['label']  # 0 = NORMAL, 1 = PNEUMONIA
  plt.imshow(img.convert("L"), cmap="gray")
  plt.title(f"Label: {'PNEUMONIA' if label==1 else 'NORMAL'}")
  plt.axis(False)
  plt.show()
  
  # 5. Prétraitement : resize + normalisation
  IMG_SIZE = (180, 180)
  def preprocess(batch):
      imgs = [np.array(x.resize(IMG_SIZE).convert("RGB"))/255.0 for x in batch['image']]
      labels = batch['label']
      return {"image": np.stack(imgs), "label": np.array(labels)}
  
  ds_train = dataset["train"].map(preprocess, batched=True)
  ds_test = dataset["test"].map(preprocess, batched=True)
  
  # Convertir en tf.data.Dataset
  X_train, y_train = ds_train["image"], ds_train["label"]
  X_test, y_test = ds_test["image"], ds_test["label"]
  
  train_ds = tf.data.Dataset.from_tensor_slices((X_train, y_train)).shuffle(1000).batch(32).prefetch(tf.data.AUTOTUNE)
  test_ds = tf.data.Dataset.from_tensor_slices((X_test, y_test)).batch(32).prefetch(tf.data.AUTOTUNE)
  
  # 6. Modèle CNN simple
  model = tf.keras.Sequential([
      tf.keras.layers.Conv2D(32,3,activation="relu",input_shape=(180,180,3)),
      tf.keras.layers.MaxPooling2D(),
      tf.keras.layers.Conv2D(64,3,activation="relu"),
      tf.keras.layers.MaxPooling2D(),
      tf.keras.layers.Flatten(),
      tf.keras.layers.Dense(128, activation="relu"),
      tf.keras.layers.Dense(1, activation="sigmoid")
  ])
  model.compile(optimizer="adam", loss="binary_crossentropy", metrics=["accuracy"])
  
  # 7. Entraînement
  model.fit(train_ds, epochs=3, validation_data=test_ds)
  
  # 8. Évaluation
  loss, acc = model.evaluate(test_ds)
  print(f"\n✅ Test Accuracy: {acc:.2%}")
  
  # 9. Prédiction visuelle
  for X_batch, y_batch in test_ds.take(1):
      preds = model.predict(X_batch)
      for img, true, pred in zip(X_batch[:5], y_batch[:5], preds[:5]):
          plt.imshow(img.numpy())
          plt.title(f"Vrai: {'PNEUMONIA' if int(true)==1 else 'NORMAL'} / Prédit: {'PNEU' if pred>0.5 else 'NOR'} ({pred:.2f})")
          plt.axis(False)
          plt.show()

  

  Explication du code :

  1. Importation des bibliothèques

  - `tensorflow` : création, entraînement et évaluation du modèle CNN. - `datasets` : chargement du dataset Hugging Face `chest-xray-pneumonia`. - `numpy` : traitement des tableaux d’images. - `matplotlib.pyplot` : visualisation des images.

  2. Chargement du dataset Chest X‑Ray Pneumonia

  - Dataset public Hugging Face : `hf-vision/chest-xray-pneumonia`. - Deux classes : - `0` = NORMAL (poumons sains) - `1` = PNEUMONIA (poumons infectés)

  3. Affichage d’un exemple

  - Sélection du premier exemple du jeu d’entraînement. - Affichage de l’image en niveaux de gris. - Titre indiquant la classe réelle : NORMAL ou PNEUMONIA.

  4. Prétraitement des données

  - **Redimensionnement** des images à (180, 180). - **Conversion RGB** (3 canaux). - **Normalisation** des pixels entre 0 et 1 (`/255`). - Application du prétraitement par lot via `map(batched=True)`.

  5. Conversion en `tf.data.Dataset`

  - Création de `train_ds` et `test_ds` à partir des tableaux NumPy. - **Shuffle**, **batching** (32 images), et **préchargement automatique** (prefetch) pour une exécution efficace.

  6. Définition du modèle CNN

  - Architecture simple avec : - 2 couches `Conv2D` + `MaxPooling2D` - `Flatten` pour passer aux couches denses - `Dense(128)` puis `Dense(1, activation='sigmoid')` pour classification binaire - Compilation avec `adam`, `binary_crossentropy` et précision (`accuracy`).

  7. Entraînement du modèle

  - Entraînement pendant 3 époques (`epochs=3`). - Validation sur le jeu de test.

  8. Évaluation finale

  - Évaluation du modèle sur le jeu de test. - Affichage de la précision finale sous forme de pourcentage.

  9. Prédictions visuelles

  - Prédictions sur un lot de test. - Affichage des 5 premières images avec : - Classe réelle (Vrai) - Classe prédite (Prédit) - Score de prédiction (`sigmoid`, entre 0 et 1) - Visualisation des résultats pour interprétation visuelle.