Einführung

Geschlechtserkennung aus Gesichtsbildern ist eine der vielen faszinierenden Anwendungen von Computer Vision. In diesem Projekt kombinieren wir OpenCV für den Standort und die Roboflow -API für die Klassifizierung der Geschlechter und erstellen ein Gerät, das Gesichter identifiziert, sie überprüft und ihr Geschlecht vorhersagt. Wir werden Python, insbesondere in Google Colab, verwenden, um diesen Code einzugeben und auszuführen. Diese Direkte gibt eine leicht zu befolgende Vorgehensweise des Codes und klärt jeden Schritt, damit Sie ihn verstehen und auf Ihre Unternehmungen anwenden können.

Lernziel

• Verstehen Sie, wie man die Gesichtserkennung mit der Haar Cascade von OpenCV implementiert.
• Erfahren Sie, wie Sie Roboflow -API für die Klassifizierung der Geschlechter integrieren.
• Erforschen Sie Methoden, um Bilder in Python zu verarbeiten und zu manipulieren.
.
• Erkennungsergebnisse mit Matplotlib visualisieren.
• entwickeln praktische Fähigkeiten bei der Kombination von KI und Computer Vision für reale Anwendungen.

Dieser Artikel wurde als Teil der Data Science Blogathon.

Inhaltsverzeichnis

• Wie man Geschlecht mit OpenCV und Roboflow in Python erkennt? Image
  • Schritt 4: Einrichten der Geschlechtserkennung api
  • Schritt 5: Verarbeitung jedes erkannten Face
  • ]
  Wie kann man Geschlecht mit OpenCV und Roboflow in Python erkennen?
  Lass uns lernen, wie man OpenCV und Roboflow in Python für die Erkennung von Geschlechtern implementiert:
  Schritt 1: Bibliotheken importieren und Bild hochladen
  Der primäre Schritt besteht darin, die lebenswichtigen Bibliotheken zu folgen. Wir verwenden OpenCV für die Bildvorbereitung, Numpy für den Umgang mit Clustern und Matplotlib, um die Entstehungen zu visualisieren. Wir haben auch ein Bild hochgeladen, das Gesichter enthielt, die wir analysieren wollten.
von Google.Colab -Importdateien CV2 importieren Numph als NP importieren von Matplotlib Pyplot als PLT importieren Aus Inferenz_Sdk import InferenceTtpclient # Bild hochladen Uploaded = Dateien.Upload () # Das Bild laden Für den Dateinamen in hochgeladen.Keys (): img_path = Dateiname
In Google Colab ermöglicht die Dateien. Beim Hochladen wird das Bild in einer Wortreferenz mit dem Namen übertragen, in der die Tasten mit den Datensatznamen verglichen werden. A für Schleife wird dann verwendet, um den Dateipfad für die weitere Verarbeitung zu extrahieren. Um Bildverarbeitungsaufgaben zu erledigen, wird OpenCV verwendet, um Gesichter zu erkennen und Begrenzungskästen um sie herum zu zeichnen. Gleichzeitig wird Matplotlib verwendet, um die Ergebnisse zu visualisieren, einschließlich der Anzeige des Bildes und der geschnittenen Gesichter.

Schritt 2: Laden von Haar Cascade Modell für Gesichtserkennung

Als nächstes stapeln wir die Haar-Cascade-Demonstration von OpenCV, die vorbereitet ist, um Gesichter zu identifizieren. Dieses Modell scannt das Bild für Muster, die menschlichen Gesichtern ähneln, und gibt ihre Koordinaten zurück.

# Laden Sie das Haar -Kaskadenmodell für die Gesichtserkennung face_cascade = cv2.cascadeClassifier (cv2.data.Haarcascades 'haarcascade_frontalface_default.xml'))

Es ist normalerweise eine weit verbreitete Strategie für die Objekterkennung. Es identifiziert Kanten, Texturen und Muster, die dem Objekt zugeordnet sind (in diesem Fall Gesichter). OpenCV liefert ein vorgebildetes Gesichtserkennungsmodell, das mit `CascadeClassifier.`

geladen wird.

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

Wir stapeln das übertragene Bild und ändern es in Graustufen, da dies einen Unterschied macht, um Fortschritte bei der Genauigkeit der Position zu machen. Danach verwenden wir den Gesichtsdetektor, um Gesichter im Bild zu finden.

# Laden Sie das Bild und konvertieren Sie sie in Graustufen img = cv2.imread (img_path) Gray = cv2.cvtcolor (IMG, cv2.color_bgr2Gray) # Gesichter im Bild erkennen faces = face_cascade.detectmultiscale (grau, scaleFactor = 1.1, minneighbors = 5, minsize = (30, 30))

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

Verwenden Sie cv2.imread (), um das übertragene Bild zu stapeln.

Ändern Sie das Bild in Graustufen mit cv2.cvtcolor (), um die Komplexität zu verringern und die Entdeckung zu verbessern.

# 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))

Erkennen von Gesichtern:
• Verwenden Sie DetectMultiscale (), um Gesichter im Graustufenbild zu finden.
  .
  • Die Funktion skaliert das Bild und überprüft verschiedene Bereiche auf Gesichtsmuster.
  • Parameter wie ScaleFactor und Minneighbors Anpassen der Erkennungsempfindlichkeit und -genauigkeit.
• Schritt 4: Einrichten der geschlechtsspezifischen Erkennung api
  Jetzt, da wir die Gesichter erkannt haben, initialisieren wir die Roboflow -API unter Verwendung von Inferenzhttpclient, um das Geschlecht jedes entdeckten Gesichts vorherzusagen.
  # Initialisieren Sie Inferenzhttpclient für die Erkennung der Geschlechter Client = Inferenzhttpclient ( api_url = "https://detect.roboflow.com", api_key = "use_your_api" )
  Der Inferenzhttpclient vereinfacht die Interaktion mit den vorgebildeten Modellen von Roboflow, indem ein Client mit der Roboflow-API-URL und der API-Schlüssel zu konfiguriert ist. Mit diesem Setup können Anfragen an das auf Roboflow gehostete Geschlechtserkennungsmodell gesendet werden. Der API -Schlüssel dient als eindeutige Kennung für die Authentifizierung und ermöglicht einen sicheren Zugriff auf und die Verwendung der Roboflow -API.

Schritt 5: Verarbeitung jedes erkannte Gesichts

Wir schauen durch jedes erkannte Gesicht, zeichnen ein Rechteck um es herum und schnitten das Gesichtsbild zur weiteren Verarbeitung. Jedes Krupelbild wird vorübergehend gespeichert und an die Roboflow-API gesendet, wobei das Modell der Geschlechtserkennung-QIYYG/2-Modell verwendet wird, um das Geschlecht vorherzusagen.

Das Modell der geschlechtsspezifischen Detektion-QIYYG/2 ist ein vorgebildetes Deep-Learning-Modell, das für die Klassifizierung von Geschlecht als männlich oder weiblich basierend auf Gesichtsmerkmalen optimiert ist. Es liefert Vorhersagen mit einem Konfidenzwert und zeigt an, wie sicher das Modell über die Klassifizierung geht. Das Modell wird auf einem robusten Datensatz trainiert, sodass es genaue Vorhersagen in einer Vielzahl von Gesichtsbildern vorlegen kann. Diese Vorhersagen werden von der API zurückgegeben und jedes Gesicht mit dem identifizierten Geschlecht und Konfidenzniveau kennzeichnet.

# 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))

# Die Gesichtszahl initialisieren face_count = 0 # LISTE, um geschnittene Gesichtsbilder mit Etiketten zu speichern cropped_faces = [] # Verarbeiten jeweils entdeckte Gesicht für (x, y, w, h) in Gesichtern: face_count = 1 # Rechtecke um die erkannten Gesichter zeichnen CV2.Rectangle (IMG, (x, y), (x w, y h), (255, 0, 0), 2) # Die Gesichtsregion extrahieren face_img = img [y: y h, x: x w] # Speichern Sie das Gesichtsbild vorübergehend face_img_path = 'temp_face.jpg' cv2.imwrite (face_img_path, face_img) # Geschlecht mit dem Inferenzhttpclient erkennen result = client.infer (face_img_path, model_) Wenn 'Vorhersagen' in Ergebnis und Ergebnis ['Vorhersagen']: Vorhersage = Ergebnis ['Vorhersagen'] [0] Geschlecht = Vorhersage ['Klasse'] Vertrauen = Vorhersage ['Vertrauen'] # Beschriften Sie das Rechteck mit dem Geschlecht und dem Selbstvertrauen Label = F '{Geschlecht} ({Konfidenz: .2f})' cv2.putText (IMG, Etikett, (x, y - 10), cv2.font_hershey_simplex, 0,8, (255, 0, 0), 2) # Fügen Sie das verkürzte Gesicht mit dem Etikett zur Liste hinzu croppped_faces.append ((face_img, label))

Für jedes erkannte Gesicht zeichnet das System ein Begrenzungsfeld mit CV2.Rectangle (), um das Gesicht im Bild visuell hervorzuheben. Anschließend werden die Gesichtsregion unter Verwendung von Slicing (face_img = img [y: y h, x: x w]) geschnitten und isoliert es zur weiteren Verarbeitung. Nachdem das System vorübergehend das verkürzte Gesicht gespart hat, sendet das System es über Client.infer () an das Roboflow -Modell, das die Geschlechtervorhersage zusammen mit einer Vertrauensbewertung zurückgibt. Das System fügt diese Ergebnisse als Textbezeichnungen über jedem Gesicht mit cv2.putText () hinzu und liefert ein klares und informatives Overlay.

Schritt 6: Anzeigen der Ergebnisse

Schließlich visualisieren wir die Ausgabe. Wir konvertieren zuerst das Bild von BGB in RGB (wie openCV standardmäßig BGR verwendet) und dann die erkannten Gesichter und Geschlechtsvorhersagen anstellen. Danach zeigen wir den einzelnen geschnittenen Gesichtern mit ihren jeweiligen Etiketten.

# Konvertieren Sie das Bild von BGR in RGB für die Anzeige img_rgb = cv2.cvtcolor (IMG, cv2.color_bgr2rgb) # Zeigen Sie das Bild mit erkannten Gesichtern und geschlechtsspezifischen Etiketten an Plt.Figure (AbbSize = (10, 10)) Plt.imshow (IMG_RGB) PLT.AXIS ('OFF') PLT.TITLE (f "Erkennete Gesichter: {face_count}") Plt.Show () # Zeigen Sie jedes verkürzte Gesicht mit seinem Etikett horizontal an Abb, Achsen = Plt.Subplots (1, face_count, figsize = (15, 5)) für i, (face_img, label) in aufzähliger (cropped_faces): face_rgb = cv2.cvtcolor (face_img, cv2.color_bgr2rgb) Achsen [i] .imshow (face_rgb) Achsen [i] .AXIS ('OFF') Achsen [i] .set_title (Etikett) Plt.Show ()

# 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))

Da OpenCV das BGR -Format standardmäßig verwendet, konvertieren wir das Bild mit cv2.cvtcolor () für die korrekte Farbanzeige in Matplotlib.

.

Ergebnisse anzeigen:

Wir verwenden Matplotlib, um das Bild mit den erkannten Gesichtern und den geschlechtsspezifischen Etiketten anzuzeigen.

# 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))

Wir zeigen auch jedes verkürzte Gesichtsbild und das vorhergesagte Geschlechtsetikett in einer separaten Nebenhandlung.

Originaldaten
• • Ausgabeergebnis Daten

Abschluss

In diesem Leitfaden haben wir erfolgreich eine leistungsstarke Geschlechtserkennung mit OpenCV und Roboflow in Python entwickelt. Durch die Implementierung von OpenCV zur Gesichtserkennung und Roboflow für die Vorhersage der Geschlechter haben wir ein System erstellt, das das Geschlecht in Bildern genau identifizieren und klassifizieren kann. Die Zugabe von Matplotlib zur Visualisierung verbesserte unser Projekt weiter und lieferte klare und aufschlussreiche Anzeigen der Ergebnisse. Dieses Projekt zeigt die Effektivität der Kombination dieser Technologien und demonstriert ihre praktischen Vorteile in realen Anwendungen und bietet eine robuste Lösung für Aufgaben zur Erkennung von Geschlechtern.

Key Takeaways

Das Projekt zeigt einen effektiven Ansatz zum Erkennen und Klassifizieren von Geschlecht aus Bildern mithilfe eines vorgebildeten KI-Modells. Die Demonstration unterscheidet die sexuelle Orientierung genau mit hoher Sicherheit und zeigt ihre unerschütterliche Qualität.

Durch Kombination von Geräten wie Roboflow für KI -Abzug, OpenCV für die Bildvorbereitung und Matplotlib zur Visualisierung kombiniert das Unternehmen effektiv verschiedene Innovationen, um seine Ziele zu realisieren.

Die Fähigkeit des Systems, das Geschlecht verschiedener Personen in einem einzelnen Bild zu unterscheiden und zu klassifizieren, unterstreicht seine Kraft und Flexibilität und macht es für verschiedene Anwendungen angemessen.

Die Verwendung einer vorgebreiteten Demonstration garantiert eine hohe Genauigkeit der Prognosen, wie aus den Gewissheit nachgewiesen wird, die innerhalb des Kommens verabreicht werden. Diese Genauigkeit ist für Anwendungen von entscheidender Bedeutung, die eine zuverlässige Klassifizierung der Geschlechter erfordern.

Das Projekt verwendet Visualisierungstechniken, um Bilder mit erkannten Gesichtern und vorhergesagten Geschlechtern zu kommentieren. Dies macht die Ergebnisse interpretierbarer und wertvoller für die weitere Analyse.

• auch lesen: genannte basierte Geschlechtsidentifikation mit NLP und Python
häufig gestellte Fragen
Q1.
• Was ist der Zweck des Projekts?
a. Das Projekt zielt darauf ab, das Geschlecht aus Bildern mit AI zu erkennen und zu klassifizieren. Es nutzt vorgeborene Modelle, um die Geschlechter von Personen in Fotos zu identifizieren und zu kennzeichnen.

Q2. Welche Technologien und Tools wurden verwendet?

a. Das Projekt verwendete das Roboflow -Geschlechtserkennungsmodell für AI -Inferenz, OpenCV für die Bildverarbeitung und Matplotlib zur Visualisierung. Es wurde auch Python zum Skript- und Datenhandling verwendet.

Q3. Wie funktioniert das Modell der Geschlechtserkennung?

a. Das Modell analysiert Bilder, um Gesichter zu erkennen, und klassifiziert dann jedes erkannte Gesicht als männlich oder weiblich basierend auf den ausgebildeten AI -Algorithmen. Es gibt Vertrauenswerte für die Vorhersagen aus.

Q4. Wie genau ist die Erkennung von Geschlechtern?

a. Das Modell zeigt eine hohe Genauigkeit mit Vertrauenswerten, die zuverlässige Vorhersagen anzeigen. Zum Beispiel lagen die Konfidenzwerte in den Ergebnissen über 80%und zeigten eine starke Leistung.

Q5. Welche Art von Bildern kann der Modellprozess?

Die in diesem Artikel gezeigten Medien sind nicht im Besitz von Analytics Vidhya und werden nach Ermessen des Autors verwendet.