Introducción

La detección de género de las imágenes faciales es una de las muchas aplicaciones fascinantes de la visión por computadora. En este proyecto, combinamos OpenCV para la ubicación de confrontación y la API RoboFlow para la clasificación de género, haciendo un dispositivo que identifica caras, los verifica y predice su género. Utilizaremos Python, particularmente en Google Colab, para escribir y ejecutar este código. Este directo ofrece un tutorial fácil de seguir del código, aclarando cada paso para que pueda comprenderlo y aplicarlo a sus empresas.

Objetivo de aprendizaje

• Comprender cómo implementar la detección de rostros usando la cascade Haar de OpenCV.
• Aprenda a integrar la API ROBOFLOW para la clasificación de género.
• Explore los métodos para procesar y manipular imágenes en Python.
• Visualice los resultados de detección usando matplotlib.
• Desarrolle habilidades prácticas para combinar la IA y la visión por computadora para aplicaciones del mundo real.

Este artículo fue publicado como parte del Data Science Blogathon.

tabla de contenidos

• ¿cómo detectar género usando openCV y roboflow en python?
  • Paso 1: importar bibliotecas y cargar imagen
  • paso 2: cargar el modelo de cascade para detección facial
  [&] paso 3: Imagen
  Paso 4: Configuración de la detección de género API
  Paso 5: procesar cada cara detectada
  Paso 6: Mostrando los resultados
Preguntas frecuentes
• [&] [&] [&]]
¿Cómo detectar el género usando OpenCV y RoboFlow en Python?

aprendamos a implementar OpenCV y RoboFlow en Python para la detección de género:

Paso 1: Importar bibliotecas y cargar imagen

El paso principal es consecuencia de las bibliotecas vitales. Estamos utilizando OpenCV para la preparación de imágenes, Numpy para tratar con clústeres y matplotlib para visualizar los viene. También subimos una imagen que contenía caras que queríamos analizar.

de Google.Colab Import Files Importar CV2 importar numpy como np de matplotlib import pyplot como plt de Inference_SDK Importación InferenciaHTTPClient # Imagen de carga cargado = files.upload () # Cargue la imagen para el nombre de archivo en uploaded.keys (): img_path = nombre de archivo

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

Paso 2: Cargando el modelo Cascade Haar para la detección de cara

A continuación, apilamos la demostración de Cascade de Haar de OpenCV, que se entrena previamente para identificar caras. Este modelo escanea la imagen para patrones que se asemejan a caras humanas y devuelven sus coordenadas.

# Cargue el modelo Cascade Haar para la detección de cara face_cascade = cv2.CascadeClassifier (cv2.data.haarcascades 'haarcascade_frontalface_default.xml')

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

Paso 3: Detección de caras en la imagen

apilamos la imagen transferida y la cambiamos a escala de grises, ya que esto hace una diferencia en hacer avances para enfrentar la exactitud de la ubicación. Después, usamos el detector de la cara para encontrar caras en la imagen.

# Cargue la imagen y convierta a la escala de grises img = cv2.imread (img_path) Gray = CV2.CVTColor (IMG, CV2.Color_Bgr2Gray) # Detectar caras en la imagen Faces = face_cascade.detectMultiscale (Gray, ScaleFactor = 1.1, MinneighBors = 5, Minsize = (30, 30))

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

Imagen Cargando y conversión:
• utilizar cv2.imread () para apilar la imagen transferida.
  • cambie la imagen a escala de gris con cv2.cvtcolor () para disminuir la complejidad y actualizar el descubrimiento.
Detección de caras:
• use DetectMultiscale () para encontrar caras en la imagen de la escala de grises.
  • La función escala la imagen y verifica diferentes áreas para los patrones de cara.
  • parámetros como ScaleFactor y Minneighbors ajustan la sensibilidad y precisión de la detección.
Paso 4: Configuración de la API de detección de género

Ahora que hemos detectado las caras, inicializamos la API ROBOFLOW usando InferenceHttpClient para predecir el género de cada cara detectada.

# Inicializar InferenceHttpClient para la detección de género Client = InferenceHttpClient ( api_url = "https://detect.roboflow.com", api_key = "use_your_api" )

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

La InferenciaHTTPClient simplifica la interacción con los modelos previamente capacitados de RoboFlow al configurar un cliente con la URL de la API ROBOFLOW y la tecla API. Esta configuración permite enviar solicitudes al modelo de detección de género alojado en RoboFlow. La clave API sirve como un identificador único para la autenticación, lo que permite el acceso seguro y la utilización de la API ROBOFLOW.

Paso 5: procesar cada cara detectada

recorremos cada cara detectada, dibujamos un rectángulo a su alrededor y recortamos la imagen de la cara para su posterior procesamiento. Cada imagen de la cara recortada se guarda temporalmente y se envía a la API RoboFlow, donde se usa el modelo de detección de género-Qiyyg/2 para predecir el género.

El modelo de detección de género-Qiyyg/2 es un modelo de aprendizaje profundo previamente capacitado optimizado para clasificar el género como hombre o mujer en función de las características faciales. Proporciona predicciones con una puntuación de confianza, lo que indica cuán seguro es el modelo sobre la clasificación. El modelo está entrenado en un conjunto de datos robusto, lo que le permite hacer predicciones precisas en una amplia gama de imágenes faciales. Estas predicciones son devueltas por la API y se usan para etiquetar cada cara con el nivel de género y confianza identificados.

# inicializar el recuento de cara face_count = 0 # Lista para almacenar imágenes de cara recortada con etiquetas Cropped_faces = [] # Proceso cada cara detectada para (x, y, w, h) en las caras: face_count = 1 # Dibujar rectángulos alrededor de las caras detectadas cv2.rectangle (img, (x, y), (x w, y h), (255, 0, 0), 2) # Extraer la región de la cara face_img = img [y: y h, x: x w] # Guarde la imagen de la cara temporalmente face_img_path = 'temp_face.jpg' cv2.imwrite (face_img_path, face_img) # Detectar género utilizando la Inferencia HttpClient result = client.infer (face_img_path, model_) Si 'predicciones' en resultado y resultado ['predicciones']: predicción = resultado ['predicciones'] [0] género = predicción ['clase'] confianza = predicción ['confianza'] # Etiqueta el rectángulo con el género y la confianza etiqueta = f '{género} ({confianza: .2f})' cv2.putText (img, etiqueta, (x, y - 10), cv2.font_hershey_simplex, 0.8, (255, 0, 0), 2) # Agregue la cara recortada con la etiqueta a la lista Cropped_faces.append ((Face_img, etiqueta))

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

Paso 6: Mostrar los resultados

Finalmente, visualizamos la salida. Primero convertimos la imagen de BGR a RGB (como OpenCV usa BGR por defecto), luego mostramos las caras detectadas y las predicciones de género. Después de eso, mostramos las caras recortadas individuales con sus respectivas etiquetas.

# Convertir la imagen de BGR a RGB para mostrar img_rgb = cv2.cvtcolor (img, cv2.color_bgr2rgb) # Muestra la imagen con caras detectadas y etiquetas de género plt.figure (figsize = (10, 10)) plt.imshow (img_rgb) plt.axis ('apagado') plt.title (f "caras detectadas: {face_count}") plt.show () # Muestra cada cara recortada con su etiqueta horizontalmente Fig, Axes = plt.subplots (1, face_count, figSize = (15, 5)) para i, (face_img, etiqueta) en enumerate (cropped_faces): face_rgb = cv2.cvtcolor (face_img, cv2.color_bgr2rgb) hacha [i] .imshow (face_rgb) hacha [i] .axis ('apagado') ejes [i] .set_title (etiqueta) plt.show ()

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

Conversión de imagen:
• Dado que OpenCV usa el formato BGR de forma predeterminada, convertimos la imagen en RGB usando CV2.CVTColor () para una visualización de color correcta en Matplotlib.
mostrando resultados:
• Usamos matplotlib para mostrar la imagen con las caras detectadas y las etiquetas de género encima de ellas.
  • también mostramos cada imagen de la cara recortada y la etiqueta de género predicha en una trama secundaria separada.
datos originales

data de resultado de salida

Conclusión

En esta guía, hemos desarrollado con éxito una poderosa detección de género con OpenCV y RoboFlow en Python. Al implementar OpenCV para la detección de cara y RoboFlow para la predicción de género, creamos un sistema que puede identificar y clasificar con precisión el género en las imágenes. La adición de matplotlib para la visualización mejoró aún más nuestro proyecto, proporcionando pantallas claras y perspicaces de los resultados. Este proyecto destaca la efectividad de combinar estas tecnologías y demuestra sus beneficios prácticos en aplicaciones del mundo real, ofreciendo una solución robusta para tareas de detección de género.

Key Takeaways

El proyecto demuestra un enfoque efectivo para detectar y clasificar el género a partir de imágenes utilizando un modelo AI previamente capacitado. La manifestación distingue precisamente la orientación sexual con alta certeza, mostrando su calidad inquebrantable.

• combinando dispositivos como RoboFlow para la deducción AI, OpenCV para la preparación de imágenes y Matplotlib para la visualización, la empresa combina efectivamente diferentes innovaciones para realizar sus objetivos.
• La capacidad del sistema para distinguir y clasificar el género de diferentes personas en una sola imagen destaca su vigor y flexibilidad, lo que lo hace apropiado para varias aplicaciones.
• El uso de una demostración previamente capacitada garantiza una alta exactitud en los pronósticos, como lo demuestran las puntuaciones de certeza dadas en la próxima. Esta precisión es crucial para aplicaciones que requieren clasificación de género confiable.
• El proyecto utiliza técnicas de visualización para anotar imágenes con caras detectadas y géneros predichos. Esto hace que los resultados sean más interpretables y valiosos para un análisis posterior.

también lea: identificación de género basada en el nombre usando NLP y python

Preguntas frecuentes

Q1.

¿Cuál es el propósito del proyecto? a. El proyecto tiene como objetivo detectar y clasificar el género de las imágenes que usan AI. Aprovecha los modelos previamente capacitados para identificar y etiquetar los géneros de los individuos en las fotos.

Q2.

¿Qué tecnologías y herramientas se usaron? a. El proyecto utilizó el modelo de detección de género RoboFlow para la inferencia de IA, OPENCV para el procesamiento de imágenes y Matplotlib para la visualización. También usó Python para secuencias de comandos y manejo de datos.

Q3.

¿Cómo funciona el modelo de detección de género? a. El modelo analiza imágenes para detectar caras y luego clasifica cada cara detectada como hombre o mujer en función de los algoritmos de IA entrenados. Genera puntajes de confianza para las predicciones.

Q4.

¿Qué tan precisa es la detección de género? a. El modelo demuestra alta precisión con puntajes de confianza que indican predicciones confiables. Por ejemplo, los puntajes de confianza en los resultados fueron superiores al 80%, mostrando un rendimiento sólido.

Q5.

¿Qué tipo de imágenes puede procesar el modelo?

Los medios que se muestran en este artículo no son propiedad de Analytics Vidhya y se usa a discreción del autor.