Apprentissage semi-supervisé: Biomédecine et santé

Fonctions :

• Biomédecine et santé (exemple)

  La biomédecine et la santé utilisent des technologies avancées pour améliorer le diagnostic, le traitement et la prévention des maladies. Par exemple, l’analyse d’images médicales par intelligence artificielle permet de détecter automatiquement des anomalies comme les tumeurs dans les scanners, aidant ainsi les médecins à poser un diagnostic plus rapide et précis. Demander à ChatGPT

  Exemple de code :

  📋 Copy

  import tensorflow as tf
  import numpy as np
  
  # Simulation de données biomédicales (features cliniques)
  n_features = 30
  n_labeled = 300    # peu de données étiquetées
  n_unlabeled = 2700 # beaucoup de données non étiquetées
  n_val = 500        # données de validation
  
  def generate_data(n, labeled=True):
      X = np.random.normal(loc=0, scale=1, size=(n, n_features)).astype(np.float32)
      if labeled:
          # Labels binaires simulés (0 = sain, 1 = malade)
          y = np.random.randint(0, 2, size=(n, 1)).astype(np.float32)
          return X, y
      else:
          return X
  
  # Création des données
  X_labeled, y_labeled = generate_data(n_labeled)
  X_unlabeled = generate_data(n_unlabeled, labeled=False)
  X_val, y_val = generate_data(n_val)
  
  # Modèle simple dense
  model = tf.keras.Sequential([
      tf.keras.layers.Dense(64, activation='relu', input_shape=(n_features,)),
      tf.keras.layers.Dense(32, activation='relu'),
      tf.keras.layers.Dense(1)  # sortie logits
  ])
  
  optimizer = tf.keras.optimizers.Adam()
  loss_fn = tf.keras.losses.BinaryCrossentropy(from_logits=True)
  batch_size = 64
  consistency_weight = 1.0
  epochs = 15
  
  # Augmentation simple : ajout de bruit gaussien sur les données non étiquetées
  def augment_data(x):
      noise = tf.random.normal(shape=tf.shape(x), mean=0.0, stddev=0.05)
      return x + noise
  
  # Création des datasets TensorFlow
  labeled_ds = tf.data.Dataset.from_tensor_slices((X_labeled, y_labeled)).shuffle(n_labeled).batch(batch_size).repeat()
  unlabeled_ds = tf.data.Dataset.from_tensor_slices(X_unlabeled).shuffle(n_unlabeled).batch(batch_size).repeat()
  val_ds = tf.data.Dataset.from_tensor_slices((X_val, y_val)).batch(batch_size)
  
  labeled_iter = iter(labeled_ds)
  unlabeled_iter = iter(unlabeled_ds)
  
  for epoch in range(epochs):
      print(f"Epoch {epoch+1}/{epochs}")
      total_loss = 0
      steps_per_epoch = n_labeled // batch_size
  
      for step in range(steps_per_epoch):
          x_lab, y_lab = next(labeled_iter)
          x_unlab = next(unlabeled_iter)
          x_unlab_aug = augment_data(x_unlab)
  
          with tf.GradientTape() as tape:
              # Supervision classique
              logits_lab = model(x_lab, training=True)
              loss_sup = loss_fn(y_lab, logits_lab)
  
              # Régularisation de consistance sur non-étiquetées
              logits_unlab = model(x_unlab, training=True)
              logits_unlab_aug = model(x_unlab_aug, training=True)
              prob = tf.sigmoid(logits_unlab)
              prob_aug = tf.sigmoid(logits_unlab_aug)
              loss_consistency = tf.reduce_mean(tf.square(prob - prob_aug))
  
              loss = loss_sup + consistency_weight * loss_consistency
  
          grads = tape.gradient(loss, model.trainable_variables)
          optimizer.apply_gradients(zip(grads, model.trainable_variables))
          total_loss += loss.numpy()
  
      print(f"Loss moyenne: {total_loss/steps_per_epoch:.4f}")
  
  # Évaluation simple
  acc_metric = tf.keras.metrics.BinaryAccuracy()
  for x_batch, y_batch in val_ds:
      logits = model(x_batch, training=False)
      preds = tf.sigmoid(logits)
      acc_metric.update_state(y_batch, preds)
  
  print(f"Accuracy validation: {acc_metric.result().numpy():.4f}")

  Explication du code :

  1. Simulation et préparation des données biomédicales
   - Données simulées avec 30 caractéristiques cliniques numériques. - Trois ensembles créés : - 300 exemples étiquetés (`X_labeled`, `y_labeled`) avec labels binaires (0 = sain, 1 = malade). - 2700 exemples non étiquetés (`X_unlabeled`). - 500 exemples de validation (`X_val`, `y_val`).
  2. Définition du modèle dense simple pour classification binaire
   Le modèle est un réseau séquentiel composé de : - une couche dense de 64 neurones avec activation ReLU, prenant en entrée les 30 features, - une couche dense de 32 neurones avec activation ReLU, - une couche dense finale avec 1 neurone produisant un logit (sortie avant sigmoid).
  3. Configuration de l’entraînement
   - optimizer = tf.keras.optimizers.Adam() : optimiseur Adam pour la mise à jour des poids. - loss_fn = tf.keras.losses.BinaryCrossentropy(from_logits=True) : fonction de perte binaire adaptée aux logits. - batch_size = 64, consistency_weight = 1.0 (poids de la perte de consistance), epochs = 15 définissent les paramètres d’entraînement.
  4. Fonction d’augmentation des données non étiquetées
   augment_data(x) ajoute un bruit gaussien (moyenne 0, écart-type 0.05) aux données non étiquetées, simulant une légère variation des features pour rendre le modèle plus robuste.
  5. Création des datasets TensorFlow
   - labeled_ds contient les données étiquetées, mélangées, découpées en batchs, et répétées indéfiniment. - unlabeled_ds contient les données non étiquetées, également mélangées, batchées et répétées. - val_ds contient les données de validation batchées.
  6. Boucle d’entraînement semi-supervisé
   Pour chaque époque et batch : - On récupère un batch étiqueté (x_lab, y_lab) et un batch non étiqueté (x_unlab). - On crée une version augmentée du batch non étiqueté (x_unlab_aug) via augment_data. - Calcul des logits sur données étiquetées et calcul de la perte supervisée (loss_sup) avec les vraies étiquettes. - Calcul des logits sur données non étiquetées normales et augmentées. - Conversion des logits en probabilités (sigmoid). - Calcul d’une perte de consistance (loss_consistency) : moyenne des carrés des différences entre les probabilités des données normales et augmentées, encourageant la stabilité des prédictions malgré l’augmentation. - La perte totale est la somme : loss = loss_sup + consistency_weight * loss_consistency. - Calcul et application des gradients pour mise à jour des poids du modèle. - Affichage de la perte moyenne par époque.
  7. Évaluation finale
   - Calcul de la précision sur le jeu de validation en comparant les prédictions (après sigmoid) aux vraies étiquettes avec BinaryAccuracy(). - Affichage de la précision finale sur les données de validation.
  Ce code met en œuvre un entraînement semi-supervisé combinant supervision classique sur un petit ensemble étiqueté et régularisation par consistance sur un grand ensemble non étiqueté, ce qui améliore la robustesse et la performance du modèle sur des données biomédicales numériques.