Einführung

Die Erkennung der Geschlechter 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 Auseinandersetzung bietet eine leicht zu folgende Vorgehensweise des Codes und kl?rt jeden Schritt, damit Sie ihn verstehen und auf Ihre Unternehmen anwenden k?nnen.

Lernziel

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

Dieser Artikel wurde als Teil des Data Science -Blogathons ver?ffentlicht.

Inhaltsverzeichnis

• Wie erkenne ich Geschlecht mit OpenCV und Roboflow in Python?
  • Schritt 1: Bibliotheken importieren und Bild hochladen
  • Schritt 2: Laden Sie das Haar -Kaskaden -Modell für die Gesichtserkennung
  • Schritt 3: Gesichter im Bild erkennen
  • Schritt 4: Einrichten der API der Geschlechtserkennung
  • Schritt 5: Jede erkannte Gesicht verarbeiten
  • Schritt 6: Anzeigen der Ergebnisse
• H?ufig gestellte Fragen

Wie erkenne ich Geschlecht mit OpenCV und Roboflow in Python?

Lassen Sie uns lernen, wie OpenCV und Roboflow in Python zur Erkennung von Geschlechtern implementiert werden:

Schritt 1: Bibliotheken importieren und Bild hochladen

Der Hauptschritt besteht darin, die lebenswichtigen Bibliotheken zu befolgen. 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 bef?higt die Dateien. Upload () erm?glichen Kunden, Datens?tze wie Bilder von ihren Nachbarschaftsmaschinen in die Colab -Umgebung zu übertragen. 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 Sie das Haar -Kaskaden -Modell für die Gesichtserkennung

Als n?chstes stapeln wir OpenCVs Haar Cascade-Demonstration, 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 Cascade -Modell für die Gesichtserkennung
face_cascade = cv2.cascadeClassifier (cv2.data.Haarcascades 'haarcascade_frontalface_default.xml'))

Es ist normalerweise eine weit verbreitete Strategie zur Objekterkennung. Es identifiziert Kanten, Texturen und Muster, die dem Objekt zugeordnet sind (in diesem Fall Gesichter). OpenCV liefert ein vorgebildetes Gesichtserkennungsmodell, das mit `Cascadeklassifier geladen wird."

Schritt 3: Gesichter im Bild erkennen

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

• Bildladen und Konvertierung:
  • 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.
• Gesichter erkennen:
  • 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 passen die Erkennungsempfindlichkeit und Genauigkeit an.

Schritt 4: Einrichten der API der Geschlechtserkennung

Nachdem wir die Gesichter erkannt haben, initialisieren wir die Roboflow -API unter Verwendung von Inferenzhttpclient, um das Geschlecht jedes erkannten Gesichts vorherzusagen.

 # Inferenztpclient zur Erkennung von Geschlechtern initialisieren
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 dem API-Schlüssel konfiguriert wird. 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: Jede erkannte Gesicht verarbeiten

Wir schauen uns 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, wo das Modell der geschlechtsspezifischen Erkennung von Qiyyg/2 verwendet wird, um das Geschlecht vorherzusagen.

Das Modell der geschlechtsspezifischen Kennzeichnung-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 verwendet, um jedes Gesicht mit dem identifizierten Geschlecht und Konfidenzniveau zu kennzeichnen.

 # 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), (xw, yh), (255, 0, 0), 2)
    
    # Die Gesichtsregion extrahieren
    face_img = img [y: yh, x: xw]
    
    # 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 einen Begrenzungsbox mit CV2.Rectangle (), um das Gesicht im Bild visuell hervorzuheben. Anschlie?end erfüllt es den Gesichtsbereich mit Slicing (face_img = img [y: yh, x: xw]) und isoliert es für die weitere 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 die einzelnen Krupelgesichter 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 ()

• Bildumwandlung: Da OpenCV das BGR -Format standardm??ig verwendet, konvertieren wir das Bild mit CV2.CVTColor () in RGB, um die korrekte Farbanzeige in Matplotlib zu korrekt.
• Ergebnisse anzeigen:
  • Wir verwenden Matplotlib, um das Bild mit den erkannten Gesichtern und den geschlechtsspezifischen Etiketten auf ihnen anzuzeigen.
  • Wir zeigen auch jedes verkürzte Gesichtsbild und das vorhergesagte Geschlechtsbezeichnung in einer separaten Nebenhandlung.

Originaldaten

Ausgabeergebnisdaten

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 unterstreicht die Effektivit?t der Kombination dieser Technologien und zeigt 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 zur Erkennung und Klassifizierung von Geschlecht aus Bildern mithilfe eines vorgebliebenen KI-Modells. Die Demonstration unterscheidet die sexuelle Orientierung genau mit hoher Sicherheit und zeigt ihre unerschütterliche Qualit?t.
• Durch die Kombination von Ger?ten wie Roboflow für AI -Abzug, OpenCV für die Bildvorbereitung und Matplotlib zur Visualisierung kombiniert das Unternehmen effektiv unterschiedliche Innovationen, um seine Ziele zu realisieren.
• Die F?higkeit des Systems, das Geschlecht verschiedener Personen in einem einzigen Bild zu unterscheiden und zu klassifizieren, unterstreicht seine Kraft und Flexibilit?t und ist für verschiedene Anwendungen angemessen.
• Die Verwendung einer vorgebildeten Demonstration garantiert eine hohe Genauigkeit der Prognosen, wie die Gewissheit nach dem Kommen nachgewiesen wird. 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 für die weitere Analyse interpretierbar und wertvoller.

Lesen Sie auch: Named Gender Identification mit NLP und Python genannt

H?ufig gestellte Fragen

A. Das Projekt zielt darauf ab, das Geschlecht aus Bildern mit AI zu erkennen und zu klassifizieren. Es nutzt vor ausgebildete Modelle, um die Geschlechter von Personen in Fotos zu identifizieren und zu kennzeichnen.

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

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.

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.

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

Das obige ist der detaillierte Inhalt vonGeschlechtserkennung mit OpenCV und Roboflow in Python - Analytics Vidhya. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!