Pular para conteúdo

Detecção por Imagem (YOLOv8)

Introdução

Métodos de aprendizado profundo têm sido amplamente utilizados para a tarefa em questão. As redes neurais convolucionais (CNNs) são componentes essenciais do aprendizado profundo e são amplamente utilizadas para a detecção de objetos em imagens, devido à sua capacidade de lidar com dados multidimensionais (DU et al., 2023). As CNNs consistem em sistemas nos quais “neurônios” artificiais estão interconectados, trocando informações entre si. Essas redes são compostas por várias camadas de neurônios, em que cada neurônio responde a combinações de entradas provenientes das camadas anteriores. O aprendizado dessas redes ocorre por meio do ajuste dos pesos durante o processo de treinamento (HIJAZI; KUMAR; ROWEN, 2015).. Segundo Silva, Teixeira e Frances (2023), as arboviroses transmitidas pelo mosquito Aedes, como Dengue, Zika e Chikungunya, são um problema de saúde pública, para contrarrestar isto, propuseram o uso de algoritmos de detecção de objetos (YOLO) com redes neurais convolucionais (CNNs) para identificar e classificar larvas do mosquito. A abordagem alcançou bons resultados, com 85,6% de mAP e erro médio quadrático (MSE) de 0,70024, indicando desempenho satisfatório. Oliveira et al. (2023) apresenta um sistema inteligente baseado em Visão Computacional e Internet das Coisas (IoT) para a detecção em tempo real do mosquito Aedes aegypti. Utilizando o algoritmo YOLOv7, o sistema demonstrou desempenho superior em relação a métodos tradicionais, alcançando uma acurácia de 97%. Este trabalho combinou detecção precisa com coleta contínua de dados por meio de uma arquitetura IoT. Tendo em vista a grande quantidade de trabalhos e datasets destinados à tarefa identificação de mosquitos, propõe-se o uso do modelo YOLO V8 para identificação de mosquitos do tipo Aedes Aegypti.

Dataset

Contar com um dataset de imagens é parte fundamental para o treinamento de qualquer algoritmo de detecção de objetos. Pela extrema relevância do tema, existem diversos datasets de imagens de mosquitos Aedes Aegypti em plataformas de machine learning como Kaggle ou Roboflow. Para realizar o treinamento, primeiro foi escolhida uma base de dados que concordasse com os nossos objetivos. Nesse contexto, foi escolhida o dataset contido no projeto “mosquito Computer Vision Project”, disponível na página Roboflow. Este dataset contém 3552 imagens, sendo 70% para treinamento, 20% para validação e 10% para teste. As etiquetas são duas: “aedes” e “non_aedes”, ou seja, o algoritmo detecta estas duas classes de mosquitos.

Treinamento

Para o treinamento da rede com dados personalizados, utilizou-se a plataforma Google Colab, que oferece acesso gratuito a recursos computacionais, sendo especialmente útil para tarefas de aprendizado de máquina e ciência de dados. Devido às limitações do plano básico da plataforma, o modelo foi treinado por apenas 80 épocas. O primeiro passo para realizar o treinamento é estabelecer uma conexão com a API do Roboflow, autenticando o acesso com a chave API fornecida (no caso, "a0T2wJrHefPJmOlvYn42"). Isso permite a interação com projetos, versões e datasets armazenados na plataforma Roboflow. Em seguida, acessa-se o workspace chamado "researchmosquito" dentro da conta da equipe e, posteriormente, o projeto específico chamado "mosquito-hpxxz". No Roboflow, os dados são organizados dentro de workspaces e projetos. Por fim, realiza-se o download da versão 1 do projeto no formato YOLOv8. O Roboflow oferece diferentes formatos de exportação, sendo "yolov8" um dos formatos compatíveis com o modelo YOLOv8. Isso significa que as imagens e anotações do dataset serão baixadas no formato adequado para treinar o modelo YOLOv8.

O código utilizado para essa tarefa é apresentado a seguir:

# -*- coding: utf-8 -*-
"""DENGUE.ipynb
Automatically generated by Colab.
Original file is located at
https://colab.research.google.com/drive/1d28jYJ5iC2TtGYJqaeFsPKp6KluhiUs8
"""

# MY_SECRET_KEY=""

!pip install ultralytics
!pip install roboflow

import ultralytics
from roboflow import Roboflow
from ultralytics import YOLO
from IPython.display import Image

rf = Roboflow(api_key="SUA_API_KEY_AQUI")
project = rf.workspace("researchmosquito").project("mosquito-hpxxz")
version = project.version(1)
dataset = version.download("yolov8")

from ultralytics import YOLO

# Carrega o modelo YOLOv8 pré-treinado (por exemplo, YOLOv8n, YOLOv8s, YOLOv8m, etc.)
model = YOLO("yolov8n.pt") # Use seu próprio modelo treinado: "runs/detect/train/weights/best.pt"

# Mostrar a arquitectura del modelo
print(model.model)

!yolo task=detect mode=train model=yolov8s.pt
data=/content/mosquito-1/data.yaml epochs=500 imgsz=640 plots=True

# VIEW MODEL TRANING CHARTS
Image(filename=f'/content/runs/detect/train/results.png', width=600)

# VALIDATION
!yolo task=detect mode=val model=/content/runs/detect/train/weights/best.pt
data=/content/mosquito-1/data.yaml

# Passo 1: Compactar a pasta /content/runs em um arquivo .zip
!zip -r /content/runs.zip /content/runs

# Passo 2: Fazer o download do .zip
from google.colab import files
files.download('/content/runs.zip')

Deploy

Por enquanto, o algoritmo está sendo testado no notebook pessoal, utilizando uma câmera web para captação de vídeo. Um detalhe importante do algoritmo de detecção, é que a inferência pode ser realizada tanto em vídeo quanto em imagens. O código realiza a captura de vídeo em tempo real e a detecção de objetos utilizando um modelo YOLO pré-treinado. Primeiramente, o modelo é carregado a partir de um arquivo de pesos e "aquecido" com uma previsão inicial, preparando-o para a detecção. O código configura diretórios de saída para salvar os resultados, o vídeo resultante e o arquivo de relatório. Em seguida, inicia a captura de vídeo com a webcam e define a largura, altura e FPS dos frames. Utilizando o OpenCV, um escritor de vídeo é configurado para salvar o vídeo com as detecções em formato MP4. A cada frame capturado, o modelo realiza a detecção de objetos e, quando detectados, salva as imagens com as detecções, registra informações como timestamp, número de objetos detectados e nome do arquivo no relatório. A contagem total de detecções e a taxa de FPS são exibidas na tela. Ao final do processo, o relatório é completado com informações gerais sobre o tempo de gravação, a quantidade total de detecções, o tamanho do arquivo de vídeo e a memória utilizada. O código finaliza liberando os recursos de captura e gravação, e fechando as janelas abertas. Dessa forma, o modelo YOLOv8 realiza a detecção e registra as informações em tempo real, criando um relatório e salvando as imagens e vídeos das detecções para análise posterior.

O código utilizado consta a seguir:

# -*- coding: utf-8 -*-
"""dengue_deploy.ipynb
Automatically generated by Colab.
Original file is located at
https://colab.research.google.com/drive/1kXsD1Ocp8-23ERrrb6TVepNgz2gzRzXY
"""
#from ultralytics import YOLO
# Cargar el modelo entrenado
#model = YOLO(r'C:\Users\lopez\OneDrive\Escritorio\DENGUE\best-80.pt')
########### Modelo com relatorio 2

from ultralytics import YOLO
import cv2
import os
import time
import numpy as np
import psutil
import os.path as path

# Carregar o modelo
modelo = YOLO(r'C:\Users\lopez\OneDrive\Escritorio\DENGUE\best-80.pt')

# Aquece o modelo
_ = modelo.predict(np.zeros((480, 640, 3), dtype=np.uint8), imgsz=480, 
conf=0.70, stream=False, verbose=False)

# Diretórios
diretorio_saida =
r'C:\Users\lopez\OneDrive\Escritorio\DENGUE\resultados\prediccion2'
os.makedirs(diretorio_saida, exist_ok=True)
video_saida = os.path.join(diretorio_saida, 'video_prediccao.mp4')
relatorio_path = os.path.join(diretorio_saida, 'relatorio.txt')

# Iniciar a captura de vídeo
cap = cv2.VideoCapture(0)
cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)

largura_frame = int(cap.get(3))
altura_frame = int(cap.get(4))
fps = int(cap.get(cv2.CAP_PROP_FPS)) or 24

# Criar o escritor de vídeo
out = cv2.VideoWriter(
    video_saida,
    cv2.VideoWriter_fourcc(*'mp4v'),
    fps,
    (largura_frame, altura_frame)
)

frame_id = 0
total_deteccoes = 0
start_time = time.time() # Início da gravação

# Abrir o arquivo de relatório
with open(relatorio_path, 'w') as relatorio:
    relatorio.write('RELATÓRIO DE DETECÇÕES\n')
    relatorio.write('========================\n\n')

    while cap.isOpened():
        ret, frame = cap.read()
        if not ret:
            break

    frame_start = time.time()

    resultados = modelo.predict(
        source=frame,
        imgsz=480,
        conf=0.70,
        stream=False,
        verbose=False
    )

    for r in resultados:
        frame_end = time.time()
        fps_atual = 1 / (frame_end - frame_start + 1e-6) # Evitar divisão por zero

        if r.boxes and len(r.boxes) > 0:
            total_deteccoes += 1
            timestamp = time.strftime("%Y%m%d-%H%M%S")
            nome_arquivo = f'deteccao_{timestamp}_{frame_id}.jpg'
            caminho_arquivo = os.path.join(diretorio_saida, nome_arquivo)
            cv2.imwrite(caminho_arquivo, r.plot()) # Salvar imagem

            # Escrever no relatório
            relatorio.write(f'Deteção {total_deteccoes}:\n')
            relatorio.write(f' - Timestamp: {timestamp}\n')
            relatorio.write(f' - Arquivo: {nome_arquivo}\n')
            relatorio.write(f' - Objetos detectados: {len(r.boxes)}\n\n')
            relatorio.flush() # Salvar imediatamente

            frame_id += 1

        texto = f'Deteções: {total_deteccoes} | FPS: {fps_atual:.1f}'
        cv2.putText(
            r.plot(), texto, (10, 30),
            cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 255, 0), 2
        )

        out.write(r.plot())
        cv2.imshow('Predição', r.plot())

    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

    # Tempo total de gravação
    tempo_gravacao = time.time() - start_time

    # Estatísticas gerais
    peso_video = path.getsize(video_saida) / (1024 * 1024) # Em MB
    memoria_usada = psutil.virtual_memory().used / (1024 * 1024) # Em MB

    # Escrever estatísticas no relatório
    relatorio.write('\n\n')
    relatorio.write('=====================\n')
    relatorio.write(f'Tempo total de gravação: {tempo_gravacao / 60:.2f} minutos\n')
    relatorio.write(f'Quantidade total de detecções: {total_deteccoes}\n')
    relatorio.write(f'Peso do arquivo de vídeo: {peso_video:.2f} MB\n')
    relatorio.write(f'Memória utilizada (aproximadamente): {memoria_usada:.2f} MB\n')

# Finalizar
cap.release()
out.release()
cv2.destroyAllWindows()

Resultados

O modelo foi testado por meio de vídeos de mosquitos gravados em um celular. Para isso, o celular foi posicionado na frente da câmera web, permitindo a realização da inferência em tempo real com o vídeo sendo capturado diretamente. Durante o teste, o modelo YOLO foi capaz de realizar a detecção de objetos (mosquitos) nos frames do vídeo, e os resultados da detecção foram registrados em imagens e vídeos, como parte do processo de avaliação. A seguir, os resultados das detecções realizadas pelo modelo são apresentados.

Exemplos de uso do algoritmo

Métricas de Avaliação

Durante o treinamento do modelo, gráficos foram gerados para ilustrar as variações de métricas importantes, como box loss, classification loss, distribution focal loss, precisão (precision), recall e mean average precision (mAP), tanto para os conjuntos de treinamento quanto de validação ao longo das épocas de treinamento. Esses gráficos fornecem uma visão detalhada da performance do modelo, destacando como ele evolui e ajusta seus parâmetros para melhorar a detecção e a classificação dos objetos ao longo do tempo. As métricas de perda (loss) indicam a eficiência do modelo em minimizar os erros durante o processo de treinamento, enquanto as métricas de precisão, recall e mAP fornecem uma avaliação da qualidade das predições do modelo em termos de sua capacidade de detectar corretamente os objetos e minimizar falsos positivos e negativos.

Metrícas

Referências bibliográficas

  • DU, Xing et al. A comparative study of different CNN models and transfer learning effect for underwater object classification in side-scan sonar images. Remote Sensing, v. 15, n. 3, p. 593, jan. 2023. DOI: https://doi.org/10.3390/rs15030593.

  • HIJAZI, Samer; KUMAR, Rishi; ROWEN, Chris. Using convolutional neural networks for image recognition. 2015.

  • SILVA, Romário; TEIXEIRA, Carlos de Mattos; FRANCES, Carlos. Modelo de classificação e detecção de larvas de mosquitos Aedes usando YOLO. [S.l.], 29 out. 2023.

  • OLIVEIRA, Danilo et al. Application of YOLOv7 for real-time detection of Aedes aegypti. [S.l.: s.n.], 11 out. 2023.

  • ROBOFLOW. Mosquito Detection Dataset – mosquito-hpxxz. Roboflow Universe, 2023. Disponível em: https://universe.roboflow.com/researchmosquito/mosquito-hpxxz. Acesso em: 25 abril 2025.

Histórico de Versão

Versão Descrição Data Responsável
1.0 Criação do documento 01/05/2025 Alejandro Lopez