Introdução

A detecção de gênero das imagens faciais é uma das muitas aplicações fascinantes da visão computacional. Neste projeto, combinamos o OpenCV para a localização de confronto e a API Roboflow para classificação de gênero, fazendo um dispositivo que identifica rostos, verifica -os e prevê seu gênero. Utilizamos o Python, principalmente no Google Colab, para digitar e executar este código. Esse direto fornece um passo a passo fácil de seguir do código, esclarecendo cada etapa para que você possa entender e aplicá-lo aos seus empreendimentos.

Objetivo de aprendizagem

• entenda como implementar a detecção de rosto usando a cascata Haar do OpenCV.
• Saiba como integrar a API Roboflow para classificação de gênero.
• Explore os métodos para processar e manipular imagens em python.
• Visualize os resultados da detecção usando Matplotlib.
• Desenvolva habilidades práticas na combinação de IA e visão computacional para aplicativos do mundo real.

Este artigo foi publicado como parte do blogathon. ÍNDICE TABELA

Como detectar gênero usando o OpenCV e Roboflow em Python?

Etapa 1: Importando bibliotecas e upload de detecção de face
• Image
  Etapa 4: Configurando a API de detecção de gênero
  Etapa 5: Processando cada face detectada
  Etapa 6: Exibindo os resultados
  • freqüentemente perguntas
  perguntas frequentes
Como detectar gênero usando o OpenCV e Roboflow em Python?
Vamos aprender a implementar o OpenCV e Roboflow em Python para detecção de gênero:

Etapa 1: Importando bibliotecas e upload de imagem

A etapa principal é conseqüência das bibliotecas vitais. Estamos utilizando o OpenCV para preparação de imagens, Numpy para lidar com clusters e Matplotlib para visualizar o que vem. Também enviamos uma imagem que continha rostos que queríamos analisar.

do google.colab Importar arquivos importar CV2 importar numpy como np De Matplotlib Import pyplot como PLT de inference_sdk importar inferênciahttpclient # Carregar imagem upload = files.upload () # Carregue a imagem para o nome do arquivo em upload.keys (): img_path = nome do arquivo

No Google Colab, o File.upload () trabalha capacita os clientes a transferir registros, como imagens, de suas máquinas de vizinhança para o ambiente Colab. Após o upload, a imagem é guardada em uma referência de palavra chamada transferida, onde as chaves se comparam aos nomes dos registros. A for loop é então usado para extrair o caminho do arquivo para processamento adicional. Para lidar com tarefas de processamento de imagens, o OpenCV é empregado para detectar rostos e desenhar caixas delimitadoras ao seu redor. Ao mesmo tempo, o matplotlib é utilizado para visualizar os resultados, incluindo a exibição da imagem e os rostos cortados.

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

Em seguida, empilhamos a demonstração de cascata de Haar da OpenCV, que é pré-treinada para identificar faces. Este modelo digitaliza a imagem para padrões semelhantes a rostos humanos e devolve suas coordenadas.

# carregue o modelo Haar Cascade para detecção de rosto FACE_CASCADE = CV2.CASCADECLASSIFIER (CV2.DATA.HAARCASCADES 'HAARCASCADE_FRONTALFACE_DEFAULL.XML')

geralmente é uma estratégia predominante para detecção de objetos. Ele identifica bordas, texturas e padrões associados ao objeto (neste caso, faces). O OpenCV fornece um modelo de detecção de rosto pré-treinado, que é carregado usando `cascadeclassifier.`

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

empilhamos a imagem transferida e alteramos -a para escala de cinza, pois isso faz a diferença em fazer avanços na exatidão da localização. Posteriormente, usamos o detector de rosto para encontrar rostos na imagem.

# carregue a imagem e converta em escala de cinza img = cv2.imread (img_path) cinza = cv2.cvtcolor (img, cv2.color_bgr2gray) # Detecte rostos na imagem FACES = FACE_CASCADE.DETECTMULTISCALE (cinza, 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))

• utilize cv2.imread () para empilhar a imagem transferida. altere a imagem para escala de cinza com cv2.cvtcolor () para diminuir a complexidade e atualizar a descoberta.
  detectando rostos:
• use DetectMultisCale () para encontrar rostos na imagem em escala de cinza. A função escala a imagem e verifica diferentes áreas para padrões de rosto.
  • parâmetros como ScaleFactor e Minneighbors ajustam a sensibilidade e a precisão da detecção.
  Etapa 4: Configurando a API de detecção de gênero
  !
# inicialize inferenceHttpClient para detecção de gênero Cliente = inferencehttpclient ( api_url = "https://detect.roboflow.com", api_key = "use_your_api" )

A inferênciaHttpClient simplifica a interação com os modelos pré-treinados do Roboflow, configurando um cliente com a tecla Roboflow API URL e API. Essa configuração permite que as solicitações sejam enviadas para o modelo de detecção de gênero hospedado no Roboflow. A chave da API serve como um identificador exclusivo para autenticação, permitindo acesso seguro e utilização da API do Roboflow.

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

Etapa 5: Processando cada face detectada

Largamos por cada face detectada, desenhamos um retângulo ao seu redor e cortamos a imagem da face para um processamento adicional. Cada imagem de face cortada é temporariamente salva e enviada para a API Roboflow, onde o modelo de detecção de gênero-qiyyyg/2 é usado para prever o gênero.

O modelo de detecção de gênero-qiyyyg/2 é um modelo de aprendizado profundo pré-treinado otimizado para classificar o gênero como homem ou mulher com base em recursos faciais. Ele fornece previsões com uma pontuação de confiança, indicando o quão certo é o modelo sobre a classificação. O modelo é treinado em um conjunto de dados robusto, permitindo que ele faça previsões precisas em uma ampla gama de imagens faciais. Essas previsões são retornadas pela API e usadas para rotular cada face com o nível de gênero e confiança identificado.

# Inicialize a contagem de rosto face_count = 0 # Lista para armazenar imagens de rosto cortadas com rótulos Cropped_faces = [] # Processe cada face detectada para (x, y, w, h) em rostos: face_count = 1 # Desenhe retângulos em torno dos rostos detectados cv2.rectangle (img, (x, y), (x w, y h), (255, 0, 0), 2) # Extraia a região do rosto face_img = img [y: y h, x: x w] # Salve a imagem do rosto temporariamente face_img_path = 'temp_face.jpg' cv2.imwrite (face_img_path, face_img) # Detecte gênero usando o inferencehttpclient resultado = client.infer (face_img_path, modelo_) Se 'previsões' em resultado e resultado ['previsões']: Previsão = resultado ['previsões'] [0] Gênero = previsão ['classe'] confiança = previsão ['confiança'] # Rotule o retângulo com o gênero e a confiança etiqueta = f '{gênero} ({confiança: .2f})' cv2.putText (img, etiqueta, (x, y - 10), cv2.font_hershey_simplex, 0,8, (255, 0, 0), 2) # Adicione o rosto cortado com a etiqueta à lista Cropped_faces.append ((FACE_IMG, LABEL))

Para cada face reconhecida, o sistema desenha uma caixa delimitadora usando cv2.rectangle () para destacar visualmente a face na imagem. Em seguida, ele colhe a região da face usando o fatiamento (face_img = img [y: y h, x: x w]), isolando -o para processamento adicional. Depois de salvar temporariamente a face cortada, o sistema o envia para o modelo Roboflow via client.infer (), que retorna a previsão de gênero junto com uma pontuação de confiança. O sistema adiciona esses resultados como etiquetas de texto acima de cada face usando cv2.putText (), fornecendo uma sobreposição clara e informativa.

Etapa 6: exibindo os resultados

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

# Converta a imagem de BGR para RGB para exibição img_rgb = cv2.cvtcolor (img, cv2.color_bgr2rgb) # Exiba a imagem com rostos detectados e etiquetas de gênero plt.figure (figSize = (10, 10))) plt.imshow (img_rgb) plt.axis ('off') plt.title (f "faces detectadas: {face_count}") plt.show () # Exiba cada rosto cortado com seu rótulo horizontalmente Fig, eixos = plt.sublots (1, face_count, figSize = (15, 5)) para i, (face_img, rótulo) em enumerado (cortada_faces): FACE_RGB = CV2.CVTCOLOR (FACE_IMG, CV2.COLOR_BGR2RGB) eixos [i] .imshow (face_rgb) eixos [i] .xis ('off') eixos [i] .set_title (etiqueta) plt.show ()

Conversão de imagem:

Como o OpenCV usa o formato BGR por padrão, convertemos a imagem em RGB usando CV2.CVTCOLOR () para exibição de cores correta em matplotlib.

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

exibindo resultados:
• Usamos o matplotlib para exibir a imagem com as faces detectadas e os rótulos de gênero em cima deles.
• também mostramos cada imagem de rosto cortada e a etiqueta de gênero prevista em uma subtrama separada.
  dados originais

Dados de resultado de saída

Conclusão

Neste guia, desenvolvemos com sucesso uma poderosa detecção de gênero com OpenCV e Roboflow no Python. Ao implementar o OpenCV para detecção de rosto e roboflow para previsão de gênero, criamos um sistema que pode identificar e classificar com precisão o gênero nas imagens. A adição de matplotlib para visualização aumentou ainda mais nosso projeto, fornecendo exibições claras e perspicazes dos resultados. Este projeto destaca a eficácia da combinação dessas tecnologias e demonstra seus benefícios práticos em aplicativos do mundo real, oferecendo uma solução robusta para tarefas de detecção de gênero.

key tkeaways

O projeto demonstra uma abordagem eficaz para detectar e classificar o gênero das imagens usando um modelo de IA pré-treinado. A demonstração distingue com precisão orientação sexual com alta certeza, exibindo sua qualidade inabalável.

combinando dispositivos como Roboflow para dedução da AI, OpenCV para preparação de imagens e Matplotlib para visualização, o empreendimento combina efetivamente inovações diferentes para realizar seus objetivos.

A capacidade do sistema de distinguir e classificar o gênero de pessoas diferentes em uma única imagem destaca seu vigor e flexibilidade, tornando -o apropriado para várias aplicações.

• O uso de uma demonstração pré-treinada garante uma alta exatidão nas previsões, conforme comprovado pelas pontuações de certeza dadas dentro da chegada. Essa precisão é crucial para aplicações que requerem classificação confiável de gênero.
• O projeto usa técnicas de visualização para anotar imagens com faces detectadas e sexos previstos. Isso torna os resultados mais interpretáveis ​​e valiosos para análises adicionais.
• também leia: Identificação de gênero baseada no nome usando NLP e Python
Perguntas frequentes

Q1. Qual é o objetivo do projeto?

a. O projeto pretende detectar e classificar o gênero das imagens usando a IA. Ele aproveita os modelos pré-treinados para identificar e rotular os sexos dos indivíduos nas fotos.

Q2. Quais tecnologias e ferramentas foram usadas?

a. O projeto utilizou o modelo de detecção de gênero do Roboflow para inferência de IA, OpenCV para processamento de imagens e matplotlib para visualização. Também usou o Python para scripts e manuseio de dados.

Q3. Como o modelo de detecção de gênero funciona?

a. O modelo analisa imagens para detectar faces e depois classifica cada face detectada como homem ou mulher com base nos algoritmos de AI treinados. Ele gera pontuações de confiança para as previsões.

Q4. quão precisa é a detecção de gênero? O modelo demonstra alta precisão com pontuações de confiança indicando previsões confiáveis. Por exemplo, as pontuações de confiança nos resultados foram acima de 80%, mostrando um desempenho forte. Q5.

Que tipo de imagens o modelo pode processar?

A mídia mostrada neste artigo não é de propriedade da Analytics Vidhya e é usada a critério do autor.