DEV Community: Neuman F.

Introdução à Visão Computacional - Parte 2: Detecção de Objetos com YOLO 11

Neuman F. — Sun, 08 Jun 2025 20:56:26 +0000

Introdução

Na primeira parte deste artigo, exploramos os princípios fundamentais da visão computacional e apresentamos bibliotecas e algoritmos utilizadas na área. Nessa segunda parte, iremos utilizar uma abordagem prática com o YOLOv11, algoritmo de detecção de objetos, desenvolvido pela Ultralytics. Mostraremos como configurar o ambiente, carregar um modelo YOLOv11 pré-treinado, detectar objetos em imagens e vídeos, e interpretar os resultados.

Detecção de objetos

Utilizaremos um notebook Python no ambiente Google Colab, como exemplo, porém o passo a passo pode ser seguido em qualquer outro ambiente.

Com sua conta Google, acesso o Google Colab: https://colab.research.google.com e crie um novo notebook, clicando em 'New notebook'.

Instalação de bibliotecas

Primeiramente, instalaremos a biblioteca da Ultralytics com o gerenciador de pacotes do Python, pip:

! pip install ultralytics

Utilização

Em seguida, iremos carregar um modelo YOLO versão 11 pré-treinado. Ao executar o seguinte trecho de código, um modelo será baixado do GitHub da Ultralytics para o ambiente do notebook.

from ultralytics import YOLO

model = YOLO("yolo11n.pt") # ou YOLO("yolo11n.yaml") para criar um modelo do zero

Treinamento

Treinaremos o modelo com o dataset de Common Objects in Context (ou COCO) versão 8, utilizando 5 epochs.

COCO é um conjunto de dados de detecção, segmentação e legendagem de objetos em larga escala. Em sua versão completa, ele possui mais de 200 mil imagens rotuladas, 80 categorias de objetos e 91 categorias de "coisas". Para fins de teste, utilizaremos um versão menor, composto das primeiras 128 imagens do COCO Train 2017.

Já epoch, se refere a uma passagem completa por todo o conjunto de dados de treinamento. Imagine que você tem um conjunto de imagens com rótulos, usado para treinar um modelo para detectar objetos. Durante uma epoch, o modelo "vê" todas essas imagens uma vez, ajustando seus pesos internos para aprender a fazer previsões mais precisas. Portanto, se você treinar um modelo com 50 epochs, isso significa que ele passará 50 vezes por todo o conjunto de dados. Escolher um número baixo de epochs pode causar o que chamamos de underfitting, onde o modelo aprende pouco. O oposto disso também pode ser prejudicial, pois o modelo aprende demais os dados de treino e perde capacidade de generalização, chamado de overfitting.

results = model.train(data="coco128.yaml", epochs=5)

Depois de treinado, note que foram criados diretórios para o dataset e para o resultado dos treinamentos (métricas e pesos), em runs > detect > train. No diretório de weights, estão os pesos treinados do modelo. O arquivo best.pt representa o modelo com o melhor desempenho obtido durante o treinamento, medido com base em alguma métrica de validação, geralmente mAP (mean Average Precision). Já o last.pt, é o modelo salvo ao final do treinamento, independentemente de seu desempenho. De modo geral, podemos escolher o best.pt para detectar os objetos pós treinamento, e last.pt quando quisermos continuar o treinamento de onde parou.

Para sabermos se o modelo está desempenhando bem, podemos consultar as métricas disponíveis na imagem runs/detect/train/results.png. Nela, podemos ver a evolução do desempenho do modelo a cada epoch.

Precision é a proporção de previsões corretas entre todas as previsões positivas feitas. Alta precisão significa que o modelo não comete muitos falsos positivos
Recall é a proporção de objetos verdadeiros que o modelo conseguiu identificar corretamente. Alto recall significa que o modelo não deixa escapar muitos objetos reais.
mAP_0.5 e mAP_0.5:0.95 são métrica de mean Average Precision. mAP_0.5 é a média da precisão com IoU ≥ 0.5, idealmente deve ficar acima de 0.5 (ou 50%) para tarefas gerais. Enquanto mAP_0.5:0.95 é a média da precisão com múltiplos limiares de IoU (de 0.5 a 0.95, com passo 0.05), idealmente ficando acima de 0.75 (ou 75%) em contextos profissionais mais exigentes.

Na imagem abaixo, podemos ver que a precisão está aumentando, porém o recall está instável. Além disso, pela baixa quantidade de epochs, os gráficos encontram-se muito instáveis.

Testando com 20 epochs, podemos notar que as curvas de loss de caem de forma consistente, o que indica que o modelo está conseguindo aprender com os dados. A precisão, apesar das oscilações, aparente estar aumentando. indicando que o modelo está acertando mais quando prevê a presença de objetos, e o recall está crescendo constantemente, o que indica que o modelo está detectando mais objetos verdadeiros ao longo do tempo.

Mas agora você pode estar se perguntando qual é o número ideal de epochs, e a resposta é: depende. Para datasets menores, como o COCO 128, de 50 e 100 epochs pode ser o suficiente, mas para grandes volumes de imagens, pode ser necessário mais de 300 epochs.

Para minimizar a tentativa e erro ao escolher o número de epochs, podemos utilizar o parâmetro patience, que serve para interromper automaticamente o treino quando não há melhora nas métricas por várias épocas consecutivas. Continuando nossa análise, agora podemos definir, por exemplo, epochs=100 e patience=15, que gera o resultado da figura a seguir.

Podemos notar que nos logs, foi mostrado que o treinamento parou mais cedo pois nenhuma melhora foi observada nas últimas 15 epochs, e os melhores resultados foram observados na epoch de número 73.

Sobre as métricas, observamos que a precisão cresceu e se estabilizou por volta de 0.90, o recall atingiu aproximadamente 0.85 e mAP50 chegou a 0.91, o que são bons resultados para o dataset.

Predição

Agora que temos o nosso modelo treinado, podemos utilizá-lo da seguinte forma:

model = YOLO("./runs/detect/train/weights/best.pt")

Note que, nós fizemos diferentes treinamentos, portanto várias versões do diretório "train". Então, certifique-se que você ajustou o caminho do arquivo para o último treinamento.

Então, podemos utilizar o modelo para fazer uma predição com:

results = model("https://ultralytics.com/images/bus.jpg", save=True)

O resultado da predição será salvo em 'runs/detect/predict'.

Detecção de objetos em vídeos

Para detectar objetos em vídeos, precisaremos primeiramente instalar a biblioteca OpenCV para Python, com:

! pip install opencv-python

Então, com o trecho de código abaixo, recebemos um arquivo de vídeo no formato .mp4 (input.mp4), processamos cada frame, utilizando o modelo para predizer o resultado e escrevemos em um novo frame, que fará parte de um novo arquivo de vídeo, output.mp4.

import cv2

input_path = "input.mp4"
output_path = "output.mp4"

cap = cv2.VideoCapture(input_path)

width  = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
fps    = cap.get(cv2.CAP_PROP_FPS)
fourcc = cv2.VideoWriter_fourcc(*'mp4v')

out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))

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

    results = model(frame)

    annotated_frame = results[0].plot()

    out.write(annotated_frame)

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

O resultado pode ser visto abaixo.

Referências

Introdução à Visão Computacional - Parte 1

Neuman F. — Thu, 05 Jun 2025 23:56:28 +0000

Introdução

A visão computacional é um campo da inteligência artificial que se dedica ao desenvolvimento de algoritmos e sistemas capazes de interpretar e extrair informações significativas a partir de dados visuais, como imagens e vídeos. Com a combinação de técnicas de processamento de imagens, aprendizado de máquina e redes neurais profundas, essa área permite que computadores reconheçam padrões, classifiquem objetos e compreendam cenas visuais de forma similar a que os humanos percebem o ambiente ao seu redor.

Com o avanço de recursos computacionais e o acesso a grandes volumes de dados, a visão computacional se tornou uma ferramenta poderosa em diversos setores, como segurança, medicina, industria e mobilidade autônoma. Nesse artigo, serão abordados os princípios básicos da visão computacional, suas aplicações, seus principais algoritmos e algumas das ferramentas mais utilizadas na área.

Aplicações

Rastreamento de objetos

Object Tracking, ou rastreamento de objetos, é a técnica que permite acompanhar o movimento de um ou mais objetos ao longo do tempo em uma sequência de imagens ou vídeos. Diferente da detecção de objetos, que identifica e localiza os objetos em cada quadro isoladamente, o rastreamento mantém a identidade desses objetos, seguindo seu trajeto e atualizando suas posições conforme eles se movem.

Existem diversas aplicações da técnica, mas como um dos mais comuns, podemos citar os sistemas de vigilância e segurança, onde é possível monitorar pessoas ou veículos suspeitos, análisar tráfego urbano para otimização de semáforos e contagem de veículos.

Medicina

Na radiologia, algoritmos de deep learning são amplamente utilizados para análise automatizada de exames de imagem como raios-X, tomografias computadorizadas e ressonâncias magnéticas, auxiliando na detecção precoce de câncer de pulmão, tumores cerebrais e fraturas ósseas com precisão muitas vezes superior à de radiologistas experientes. Até mesmo durante procedimentos cirúrgicos, sistemas de visão computacional já atuam, de forma a identificar estruturas anatômicas em tempo real.

Reconhecimento facial

O reconhecimento facial é uma das aplicações mais famosas da visão computacional. O processo envolve várias etapas sequenciais: primeiro a detecção do rosto na imagem, seguida pela extração de pontos de referência faciais (como olhos, nariz, boca e contorno facial), normalização da imagem para padronizar pose e iluminação, e finalmente a extração de características distintivas que formam uma representação única do rosto.

As aplicações do reconhecimento facial incluem sistemas de segurança em aeroportos, controle de acesso em edifícios corporativos, desbloqueio de smartphones, organização automática de fotos pessoais, entre outros.

Pipeline

Desde a extração dos dados brutos até o formato compreensível por computadores, uma imagem necessita passar por uma série de etapas, na qual podemos denominar de pipeline de visão computacional. De forma geral, uma pipeline geral pode ser representada pelas seguintes fases:

1. Dados de entrada

Nessa etapa, o sistema recebe os dados visuais brutos, como imagens ou vídeos. Esses dados são capturados por câmeras, sensores ou extraídos de bancos de dados.

Embora nós, humanos, vejamos imagens como composições visuais de formas, cores e objetos, os computadores enxergam imagens como matrizes de números. Cada imagem digital é composta por pixels, e cada pixel representa uma pequena parte da imagem. O valor de cada pixel é um número que indica sua cor ou intensidade, geramente varianda de 0 (preto) a 255 (branco). No caso de imagens coloridas, cada pixel é representado por três valores, um para cada cor primária (R - Vermelho, G - Verde e B - Azul).

2. Pré-processamento

O pré-processamento, por sua vez, prepara os dados para as próximas etapas, eliminando ruídos, ajustando contrastes e redimensionando imagens. Técnicas comuns incluem normalização, filtragem, conversão para escala de cinza e aumento de dados (data augmentation). Essa etapa melhora a qualidade e a consistência dos dados para facilitar a análise.

3. Seleção de áreas de interesse

Nem todas as partes da imagem são relevantes para a tarefa. Nesta etapa, o sistema identifica regiões que merecem atenção especial, como rostos em uma multidão ou placas de trânsito em uma estrada. A ideia é focar os recursos computacionais apenas onde há maior probabilidade de obter informações úteis.

4. Extração de características

Aqui, o sistema analisa as áreas de interesse para identificar padrões visuais relevantes, como bordas, texturas, formas ou cores. Esses elementos (chamados de features) são convertidos em vetores numéricos que representam as características da imagem de forma computacionalmente útil.

5. Predição / Reconhecimento

Com as características extraídas, o sistema utiliza modelos de aprendizado de máquina, como redes neurais convolucionais, para reconhecer objetos, classificar cenas ou fazer previsões. Por exemplo, ele pode identificar se uma imagem contém um carro, uma pessoa ou um animal.

A rede neural faz uma operação de convolução de matrizes. Uma matriz menor serve como filtro, também chamada de Kernel. O filtro lê todos os pixels e produz uma matriz de dimensões menores que a matriz de entrada. Estes filtros são usados para manipular a imagem, seja desfocar, detectar bordas, relevos, cores ou aumentar a nitidez.

6. Ação

Por fim, com base no reconhecimento feito, o sistema executa uma ação. Isso pode ser emitir um alerta, acionar um dispositivo, tomar uma decisão autônoma (como virar o volante em um carro) ou simplesmente registrar a informação.

Ferramentas

OpenCV

OpenCV é a biblioteca de visão computacional mais renomada e amplamente utilizada. Ela fornece acesso a mais de 2.500 algoritmos diferentes que podem ser usados para construir seu próprio modelo. Além disso, ela é compatível com bibliotecas populares como TensorFlow e PyTorch, o que permite a integração entre processamento clássico de imagens e modelos modernos de deep learning.

Website: https://opencv.org
Documentação: https://docs.opencv.org

DeepFace

DeepFace é uma biblioteca gratuita e de código aberto amplamente utilizada para reconhecimento facial. Ela oferece a interface mais simples, permitindo trabalhar com tarefas complexas de CV com apenas poucas linha de código.

Documentação: https://github.com/serengil/deepface

YOLO

You Only Look Once, ou YOLO, é um dos algoritmos mais conhecidos e eficientes para detecção de objetos em tempo real. Ele analisa a imagem completa apenas uma vez, dividindo-a em uma grade e, para cada célula, prevê as caixas delimitadoras (bounding boxes) e as classes dos objetos. Isso resulta em uma performance extremamente rápida e precisa, sendo ideal para aplicações que exigem velocidade, como sistemas de vigilância, carros autônomos e robótica.

Documentação: https://docs.ultralytics.com/models/yolo11