Reconnaissance Faciale

Fonctions :

• Reconnaissance Faciale (exemple)

  La reconnaissance faciale permet de localiser et/ou identifier un ou plusieurs visages dans une image ou une vidéo. Elle peut s'appuyer sur des méthodes simples comme les classifieurs Haar (OpenCV) ou sur des réseaux de neurones convolutifs (CNN) pour des résultats plus précis.

  Exemple de code :

  📋 Copy

  import numpy as np
  import matplotlib.pyplot as plt
  from sklearn.datasets import fetch_lfw_people
  from sklearn.model_selection import train_test_split
  from sklearn.preprocessing import LabelBinarizer
  import tensorflow as tf
  from tensorflow.keras import layers, models
  
  # 1. Charger le dataset LFW
  lfw = fetch_lfw_people(min_faces_per_person=50, resize=0.5)
  X = lfw.images  # (n_samples, height, width)
  y = lfw.target
  target_names = lfw.target_names
  print("Classes:", target_names)
  
  # 2. Normalisation et format pour CNN
  X = X / 255.0
  X = X[..., np.newaxis]  # (n_samples, height, width, 1)
  
  # 3. Encodage one-hot des labels
  lb = LabelBinarizer()
  y_encoded = lb.fit_transform(y)
  
  # 4. Séparation en train/test
  X_train, X_test, y_train, y_test = train_test_split(X, y_encoded, test_size=0.2, random_state=42)
  
  # 5. Construction du CNN
  model = models.Sequential([
      layers.Conv2D(32, (3,3), activation='relu', input_shape=X.shape[1:]),
      layers.MaxPooling2D(2,2),
      layers.Conv2D(64, (3,3), activation='relu'),
      layers.MaxPooling2D(2,2),
      layers.Flatten(),
      layers.Dense(128, activation='relu'),
      layers.Dense(len(target_names), activation='softmax')
  ])
  
  model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
  model.summary()
  
  # 6. Entraînement
  history = model.fit(X_train, y_train, epochs=10, batch_size=32, validation_split=0.1)
  
  # 7. Évaluation
  loss, acc = model.evaluate(X_test, y_test)
  print(f"\n✅ Test Accuracy: {acc:.4f}")
  
  # 8. Affichage de quelques prédictions
  y_pred = model.predict(X_test)
  y_pred_classes = np.argmax(y_pred, axis=1)
  y_true = np.argmax(y_test, axis=1)
  
  plt.figure(figsize=(12,6))
  for i in range(10):
      plt.subplot(2,5,i+1)
      plt.imshow(X_test[i].squeeze(), cmap='gray')
      plt.title(f"Préd: {target_names[y_pred_classes[i]]}\nVrai: {target_names[y_true[i]]}")
      plt.axis('off')
  plt.tight_layout()
  plt.show()

  Explication du code :

  1. Chargement des données LFW (Labeled Faces in the Wild)
   
  - Dataset : visages de personnes célèbres avec `min_faces_per_person=50` (filtre les classes rares). 
  - `X` contient les images (dimensions : n_samples × height × width). 
  - `y` contient les indices des classes. 
  - `target_names` contient les noms correspondants aux classes.
  
  2. Prétraitement des données
   
  - **Normalisation** : les valeurs des pixels sont divisées par 255. 
  - **Redimensionnement pour CNN** : ajout d’une dimension pour les canaux (grayscale → `(H, W, 1)`).
  
  3. Encodage des labels
   
  - Utilisation de `LabelBinarizer` pour encoder les labels en one-hot.
  4. Séparation des données
   
  - `train_test_split` : 80% pour l'entraînement, 20% pour le test.
  
  5. Construction du modèle CNN
   
  - **Architecture** : 
  - `Conv2D(32)` + `MaxPooling2D(2x2)` 
  - `Conv2D(64)` + `MaxPooling2D(2x2)` 
  - `Flatten` - `Dense(128, relu)` 
  - `Dense(len(target_names), softmax)` 
  - **Compilation** : - Optimiseur : `Adam` 
  - Perte : `categorical_crossentropy` 
  - Métrique : `accuracy`
  
  6. Entraînement du modèle
   
  - Entraînement sur 10 époques, batch de 32. 
  - 10% des données d'entraînement utilisées pour la validation.
  
  7. Évaluation du modèle
   
  - Évaluation sur l’ensemble de test. 
  - Affichage de la précision finale (`acc`).
  
  8. Prédictions et visualisation
   
  - Prédiction sur les images de test. 
  - Extraction des classes prédites et réelles avec `argmax`. 
  - Affichage de 10 images testées avec leur prédiction et leur étiquette réelle.