Introduction

La détection de genre à partir d'images faciales est l'une des nombreuses applications fascinantes de la vision par ordinateur. Dans ce projet, nous combinons OpenCV pour l'emplacement de confrontation et l'API Roboflow pour la classification des sexes, créant un appareil qui identifie les visages, les vérifie et prédit leur sexe. Nous utiliserons Python, en particulier dans Google Colab, pour taper et exécuter ce code. Ce direct donne une procédure pas à pas facile à suivre du code, clarifiant chaque étape afin que vous puissiez le comprendre et l'appliquer à vos entreprises.

Objectif d'apprentissage

• comprendre comment implémenter la détection du visage à l'aide de la cascade Haar d'OpenCV.
• Apprenez à intégrer l'API Roboflow pour la classification des sexes.
• Explorez des méthodes pour traiter et manipuler des images dans Python.
• visualiser les résultats de détection à l'aide de matplotlib.
• Développer des compétences pratiques pour combiner l'IA et la vision par ordinateur pour les applications du monde réel.

Cet article a été publié dans le cadre du Blogathon de science des données.

Table of contents

• How to Detect Gender Using OpenCV and Roboflow in Python?
  • Step 1: Importing Libraries and Uploading Image
  • Step 2: Loading Haar Cascade Model for Face Detection
  • Step 3: Detecting Faces in the Image
  • Étape 4: Configuration de l'API de détection de genre
  • Étape 5: Traitement de chaque face détectée
  • Étape 6: Affichage des résultats
• Questions fréquemment posées

Comment détecter le genre à l'aide d'OpenCv et Roboflow dans Python?

Apprenez à implémenter OpenCV et Roboflow dans Python pour la détection de genre:

Étape 1: Importation de bibliothèques et téléchargement de l'image

L'étape principale consiste à conséquence des bibliothèques vitales. Nous utilisons OpenCV pour la préparation d'images, Numpy pour faire face aux clusters et Matplotlib pour visualiser les provocations. Nous avons également téléchargé une image qui contenait des visages que nous voulions analyser.

from google.colab import files
import cv2
import numpy as np
from matplotlib import pyplot as plt
from inference_sdk import InferenceHTTPClient

# Upload image
uploaded = files.upload()

# Load the image
for filename in uploaded.keys():
    img_path = filename

Dans Google Colab, le travail de fichiers.upload () permet aux clients de transférer des enregistrements, tels que des images, de leurs machines de quartier dans l'environnement Colab. Lors du téléchargement, l'image est mise en place dans une référence de mot nommée transférée, où les clés se comparent aux noms d'enregistrement. Une boucle pour la boucle est ensuite utilisée pour extraire le chemin du fichier pour un traitement ultérieur. Pour gérer les tâches de traitement d'image, OpenCV est utilisé pour détecter les visages et dessiner des boîtes de délimitation autour d'eux. En même temps, Matplotlib est utilisé pour visualiser les résultats, notamment en affichant l'image et les visages recadrés.

Étape 2: Chargement du modèle de cascade Haar pour la détection du visage

Ensuite, nous empilons la démonstration de la cascade Haar d'OpenCV, qui est pré-formée pour identifier les visages. Ce modèle analyse l'image des motifs ressemblant à des visages humains et renvoie leurs coordonnées.

# Load the Haar Cascade model for face detection
face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades   'haarcascade_frontalface_default.xml')

Il s'agit généralement d'une stratégie répandue pour la détection d'objets. Il identifie les bords, les textures et les modèles associés à l'objet (dans ce cas, les visages). OpenCV fournit un modèle de détection de visage pré-formé, qui est chargé à l'aide de `CascadeClassifier.`

Étape 3: détection des visages dans l'image

Nous empilons l'image transférée et la modifions en niveaux de gris, car cela fait une différence dans les progrès de l'exactitude de l'emplacement. Ensuite, nous utilisons le détecteur de visage pour trouver des faces dans l'image.

# Load the image and convert to grayscale
img = cv2.imread(img_path)
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

# Detect faces in the image
faces = face_cascade.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=5, minSize=(30, 30))

• Chargement et conversion de l'image:
  • utilisez cv2.imread () pour empiler l'image transférée.
  • Modifiez l'image en niveaux de gris avec cv2.cvtcolor () pour diminuer la complexité et mettre à niveau la découverte.
• Détection des visages:
  • Utilisez DetectMultiScale () pour trouver des faces dans l'image en niveaux de gris.
  • La fonction évolue l'image et vérifie différentes zones pour les modèles de visage.
  • Paramètres comme ScaleFactor et Minneighbors ajustent la sensibilité et la précision de la détection.

Étape 4: Configuration de l'API de détection de genre

Maintenant que nous avons détecté les visages, nous initialisons l'API Roboflow en utilisant InferenceHttpClient pour prédire le sexe de chaque face détectée.

# Initialize InferenceHTTPClient for gender detection
CLIENT = InferenceHTTPClient(
    api_url="https://detect.roboflow.com",
    api_key="USE_YOUR_API"
)

L'inferenceHttpClient simplifie l'interaction avec les modèles pré-formés de Roboflow en configurant un client avec l'URL de l'API Roboflow et la clé API. Cette configuration permet d'envoyer des demandes au modèle de détection de genre hébergé sur Roboflow. La clé API sert d'identifiant unique pour l'authentification, permettant un accès et une utilisation sécurisés de l'API Roboflow.

Étape 5: traitement de chaque face détectée

Nous parcourons chaque visage détecté, dessinez un rectangle autour de lui et recadorons l'image du visage pour un traitement ultérieur. Chaque image de visage recadrée est temporairement enregistrée et envoyée à l'API Roboflow, où le modèle de détection de sexe-qiyyg / 2 est utilisé pour prédire le genre.

Le modèle de détection de sexe-qiyyg / 2 est un modèle d'apprentissage en profondeur pré-formé optimisé pour la classification du genre comme hommes ou femmes en fonction des caractéristiques faciales. Il fournit des prévisions un score de confiance, indiquant à quel point le modèle est certain de la classification. Le modèle est formé sur un ensemble de données robuste, ce qui lui permet de faire des prédictions précises sur un large éventail d'images faciales. Ces prédictions sont renvoyées par l'API et utilisées pour étiqueter chaque visage avec le sexe et le niveau de confiance identifiés.

# Initialize face count
face_count = 0

# List to store cropped face images with labels
cropped_faces = []

# Process each detected face
for (x, y, w, h) in faces:
    face_count  = 1
    # Draw rectangles around the detected faces
    cv2.rectangle(img, (x, y), (x   w, y   h), (255, 0, 0), 2)
    
    # Extract the face region
    face_img = img[y:y h, x:x w]
    
    # Save the face image temporarily
    face_img_path = 'temp_face.jpg'
    cv2.imwrite(face_img_path, face_img)
    
    # Detect gender using the InferenceHTTPClient
    result = CLIENT.infer(face_img_path, model_)
    
    if 'predictions' in result and result['predictions']:
        prediction = result['predictions'][0]
        gender = prediction['class']
        confidence = prediction['confidence']
        
        # Label the rectangle with the gender and confidence
        label = f'{gender} ({confidence:.2f})'
        cv2.putText(img, label, (x, y - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.8, (255, 0, 0), 2)
        
        # Add the cropped face with label to the list
        cropped_faces.append((face_img, label))

Pour chaque face reconnue, le système dessine une boîte de délimitation à l'aide de cv2.rectangle () pour mettre en surbrillance visuellement le visage dans l'image. Il rassemble ensuite la région du visage en utilisant le tranchage (face_img = img [y: y h, x: x w]), l'isolant pour un traitement ultérieur. Après avoir temporairement économisé la face courte, le système l'envoie au modèle Roboflow via client.infer (), qui renvoie la prédiction de genre avec un score de confiance. Le système ajoute ces résultats sous forme d'étiquettes de texte au-dessus de chaque face à l'aide de cv2.putText (), fournissant une superposition claire et informative.

Étape 6: Affichage des résultats

Enfin, nous visualisons la sortie. Nous convertissons d'abord l'image de BGR en RVB (comme OpenCV utilise BGR par défaut), puis affichons les faces détectées et les prédictions de genre. Après cela, nous montrons les visages connectés individuels avec leurs étiquettes respectives.

# Convert image from BGR to RGB for display
img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)

# Display the image with detected faces and gender labels
plt.figure(figsize=(10, 10))
plt.imshow(img_rgb)
plt.axis('off')
plt.title(f"Detected Faces: {face_count}")
plt.show()

# Display each cropped face with its label horizontally
fig, axes = plt.subplots(1, face_count, figsize=(15, 5))
for i, (face_img, label) in enumerate(cropped_faces):
    face_rgb = cv2.cvtColor(face_img, cv2.COLOR_BGR2RGB)
    axes[i].imshow(face_rgb)
    axes[i].axis('off')
    axes[i].set_title(label)
plt.show()

• Conversion d'image: Puisque OpenCV utilise le format BGR par défaut, nous convertissons l'image en RGB en utilisant CV2.CVTCOLOR () pour l'affichage de couleur correct dans Matplotlib.
• Affichage des résultats:
  • Nous utilisons Matplotlib pour afficher l'image avec les faces détectées et les étiquettes de genre sur eux.
  • Nous montrons également chaque image de visage recadré et l'étiquette de genre prévue dans une intrigue secondaire séparée.

Données originales

Données de résultat de sortie

Conclusion

Dans ce guide, nous avons développé avec succès une puissante détection de genre avec OpenCV et Roboflow dans Python. En mettant en œuvre OpenCV pour la détection du visage et Roboflow pour la prédiction de genre, nous avons créé un système qui peut identifier et classer avec précision le sexe dans les images. L'ajout de Matplotlib pour la visualisation a encore amélioré notre projet, fournissant des affichages clairs et perspicaces des résultats. Ce projet met en évidence l'efficacité de la combinaison de ces technologies et démontre leurs avantages pratiques dans les applications du monde réel, offrant une solution robuste pour les tâches de détection de genre.

Takeaways clés

• Le projet démontre une approche efficace pour détecter et classer le sexe à partir d'images à l'aide d'un modèle d'IA pré-formé. La démonstration distingue précisément l'orientation sexuelle avec une grande certitude, affichant sa qualité inébranlable.
• en combinant des appareils tels que Roboflow pour la déduction AI, OpenCV pour la préparation d'images et Matplotlib pour la visualisation, l'entreprise combine efficacement différentes innovations pour réaliser ses objectifs.
• La capacité du système à distinguer et à classer le sexe de différentes personnes sur une seule image met en évidence sa vigueur et sa flexibilité, ce qui le rend approprié pour diverses applications.
• Utilisation d'une démonstration pré-formée garantit une grande exactitude dans les prévisions, comme le prouvent les scores de certitude donnés dans la prochaine. Cette précision est cruciale pour les applications nécessitant une classification des sexes fiable.
• Le projet utilise des techniques de visualisation pour annoter les images avec des visages détectés et des genres prédits. Cela rend les résultats plus interprétables et précieux pour une analyse plus approfondie.

Lisez également: identification de genre basée sur le nom à l'aide de NLP et Python

Questions fréquemment posées

a. Le projet vise à détecter et à classer les sexes à partir d'images utilisant l'IA. Il exploite les modèles pré-formés pour identifier et étiqueter les sexes des individus sur les photos.

a. Le projet a utilisé le modèle de détection de genre Roboflow pour l'inférence AI, l'OpenCV pour le traitement d'image et le matplotlib pour la visualisation. Il a également utilisé Python pour les scripts et la gestion des données.

a. Le modèle analyse les images pour détecter les visages, puis classe chaque visage détecté comme un homme ou une femme en fonction des algorithmes d'IA formés. Il étend les scores de confiance pour les prédictions.

a. Le modèle démontre une précision élevée avec des scores de confiance indiquant des prédictions fiables. Par exemple, les scores de confiance dans les résultats étaient supérieurs à 80%, montrant des performances solides.

Le média illustré dans cet article ne appartient pas à l'analyse vidhya et est utilisé à la discrétion de l'auteur.