Como treinar modelos Ultralytics YOLO para detectar animais na natureza

A vida selvagem do nosso planeta é incrivelmente diversa, de abelhas zumbidoras a elefantes imponentes, e preservar essa biodiversidade é fundamental para manter um ecossistema equilibrado. No entanto, os esforços de conservação estão ficando mais difíceis devido à perda de habitat, à caça ilegal e às mudanças climáticas. Todos esses fatores afetam negativamente as populações de animais selvagens.

Os métodos tradicionais de monitoramento de animais, como analisar manualmente imagens de câmeras de trilha e realizar levantamentos de campo, podem ser lentos e exigir muitos recursos. Muitas vezes, esses esforços não conseguem cobrir grandes áreas e populações de maneira eficaz.

Para superar essas limitações, a inteligência artificial (AI) pode ser usada como uma ferramenta eficaz na conservação da vida selvagem. Em especial, modelos de visão computacional como o Ultralytics YOLO11 podem analisar dados visuais, como imagens e vídeos, para automatizar a identificação e o rastreamento de animais em tempo real.

Tarefas de visão computacional como detecção de objetos e segmentação de instâncias, com suporte do Ultralytics YOLO11, são muito úteis nesse contexto. Ao analisar dados visuais, essas tarefas nos ajudam a coletar dados essenciais, identificar padrões ecológicos e responder com mais eficácia às ameaças ambientais.

Neste artigo, vamos explicar o processo de treino do Ultralytics YOLO11 para detetar animais.

Começando a usar o Ultralytics YOLO11#

Antes de começar o tutorial, vamos ver as diferentes opções de configuração e as ferramentas necessárias para treinar e usar o Ultralytics YOLO11.

A principal ferramenta necessária é o pacote Python da Ultralytics, que facilita o trabalho com modelos YOLO em tarefas como treinamento, detecção de objetos e execução de inferências. Para usar o pacote da Ultralytics, precisas configurar um ambiente para executar o código, e há várias opções disponíveis.

Estas são algumas das opções mais populares para configurar o teu ambiente de desenvolvimento:

• Interface de linha de comando (CLI): a CLI, também conhecida como terminal, é uma ferramenta baseada em texto que permite interagir com o computador digitando comandos. Ao contrário das interfaces gráficas (GUIs), nas quais clicas em botões e usas o mouse, a CLI exige que digites instruções para executar programas ou tarefas.
• Jupyter Notebooks: esses notebooks permitem escrever e executar código em pequenos blocos chamados células. São interativos: podes ver o resultado do código imediatamente, o que facilita os testes e a depuração.
• Google Colab: o Google Colab é uma plataforma na nuvem que funciona como o Jupyter Notebooks, mas oferece acesso gratuito a GPUs potentes. É fácil de configurar e não precisas instalar nada no computador.

Embora existam outras opções de configuração do ambiente que podes explorar na documentação oficial da Ultralytics, as três opções mencionadas acima exigem pouca configuração e são fáceis de usar, o que as torna ideais para começar rapidamente.

Neste tutorial, vamos mostrar como configurar e treinar o Ultralytics YOLO11 usando o Google Colab, o Jupyter Notebooks ou um simples arquivo Python, já que as etapas são muito semelhantes em todos esses ambientes.

Entendendo o conjunto de dados African Wildlife#

Depois de escolher um ambiente de desenvolvimento, para treinar o Ultralytics YOLO11 especificamente para detectar animais selvagens, precisamos de um conjunto de dados de alta qualidade com imagens rotuladas. Cada imagem deve mostrar claramente onde estão os animais e de que tipo são, para que o modelo aprenda a reconhecê-los por meio de aprendizado supervisionado.

Neste tutorial, vamos usar o conjunto de dados African Wildlife. Ele é compatível com o pacote Python da Ultralytics e foi desenvolvido especificamente para detectar animais comuns nos ecossistemas africanos. O conjunto contém imagens anotadas de quatro espécies importantes: búfalos, elefantes, rinocerontes e zebras.

Fig. 1. Uma amostra do conjunto de dados African Wildlife.

Estas são algumas características importantes do conjunto de dados African Wildlife:

• Escala: o conjunto de dados contém 1504 imagens divididas em três subconjuntos: 1052 para treinamento, 225 para validação e 227 para teste. Essa divisão garante que o modelo aprenda com eficácia e seja avaliado de forma completa.
• Integração fácil: A Ultralytics fornece um ficheiro de configuração YAML que define os caminhos dos conjuntos de dados, as classes e outros detalhes, facilitando a sua utilização no treino de modelos YOLO.
• Licenciamento: O conjunto de dados de origem, publicado no Kaggle por Bianca Ferreira, não especifica uma licença; por isso, consulta os termos antes de o usares comercialmente.

Treinando o Ultralytics YOLO11 para detecção de animais#

Agora que exploramos o African Wildlife Dataset, podemos começar a treinar um modelo Ultralytics YOLO11 para detectar animais em imagens. O processo envolve configurar o ambiente de desenvolvimento, treinar o modelo YOLO11 e avaliar o desempenho do modelo.

Etapa 1: Configurando o ambiente#

Para começar, vamos preparar um ambiente para treinar e testar o modelo. Podes usar o Google Colab, o Jupyter Notebooks ou um simples arquivo Python, conforme tua preferência. Cria um novo notebook do Google Colab ou do Jupyter, ou um arquivo Python, conforme o caso.

Se estiveres usando o Google Colab, o ambiente é executado por padrão numa CPU (unidade central de processamento), o que pode deixar o treinamento mais lento. Para acelerar o processo, especialmente com modelos maiores, podes mudar o ambiente de execução para usar uma GPU. No Google Colab, acessa a guia "Ambiente de execução" no menu, seleciona "Alterar tipo de ambiente de execução" e define o acelerador de hardware como GPU (de preferência uma GPU T4). Isso é importante para reduzir o tempo de treinamento.

Em seguida, independentemente do ambiente que estiveres usando, precisas instalar o pacote Python da Ultralytics. Se estiveres usando um ambiente baseado em notebook (Google Colab ou Jupyter), executa o comando a seguir com um ponto de exclamação (!) no início.

pip install ultralytics

Etapa 2: Carregando o Ultralytics YOLO11 e preparando o conjunto de dados#

Depois de instalar o pacote Ultralytics, o próximo passo é carregar o modelo YOLO11 e preparar o conjunto de dados para treinamento. Primeiro, carregamos o modelo YOLO11n, que já foi pré-treinado para tarefas gerais de detecção de objetos. Esse modelo pré-treinado é um bom ponto de partida, pois já aprendeu a detectar vários objetos.

Em seguida, especificamos o conjunto de dados usando um arquivo YAML, que contém informações sobre as imagens e os rótulos. Esse arquivo informa ao modelo onde encontrar o conjunto de dados e quais objetos ele deve aprender a reconhecer.

O pacote Ultralytics oferece suporte ao African Wildlife Dataset, por isso o conjunto de dados será baixado automaticamente quando você iniciar o treinamento, sem que você precise configurá-lo manualmente. Você também pode explorar as imagens e os rótulos do conjunto de dados na Ultralytics Platform.

Quando o conjunto de dados estiver pronto, o modelo começa a ser treinado. O modelo percorre o conjunto de dados várias vezes, num processo chamado treinamento por múltiplas épocas, para melhorar sua capacidade de reconhecer animais nas imagens. Durante esse processo, as imagens são redimensionadas para um tamanho uniforme, e o modelo processa um número definido de imagens por vez, chamado lote. Isso ajuda o modelo a aprender com mais eficiência.

Em resumo, o modelo é carregado, o conjunto de dados é baixado automaticamente e o treinamento começa a ser executado para detectar animais com base no conjunto de dados African Wildlife quando o trecho de código abaixo é executado.

from ultralytics import YOLO

model = YOLO("yolo11n.pt")
results = model.train(data="african-wildlife.yaml", epochs=30, batch=8)

O mesmo código funciona com os modelos Ultralytics YOLO26 mais recentes: basta substituir yolo11n.pt por yolo26n.pt.

Etapa 3: Guia passo a passo do treinamento do Ultralytics YOLO11#

Depois que o trecho de código acima é executado, o modelo começa a ser treinado com base nas configurações fornecidas. O código instrui o modelo a percorrer as imagens de treinamento 30 vezes. Isso significa que o modelo analisará todas as imagens do conjunto de dados 30 vezes, aprendendo um pouco mais a cada vez.

Imagina que estás tentando aprender a desenhar um animal. Na primeira tentativa, o desenho pode não ficar bom, mas, depois de praticar várias vezes, começas a melhorar. A cada nova tentativa, aprendes com os erros e os corriges. É isso que cada época faz pelo modelo: ele analisa as imagens, comete erros, aprende com eles e melhora seu reconhecimento de animais a cada vez.

Se o código de treinamento estiver sendo executado corretamente, você verá a seguinte saída à medida que o treinamento avança:

• Configuração do treinamento: A primeira parte mostra as versões do Ultralytics e do PyTorch, o hardware utilizado (CPU neste caso) e a configuração do treinamento, incluindo o modelo (yolo11n.pt), o tamanho do lote, o número de épocas e o tamanho da imagem.
• Resumo do modelo: Apresenta informações sobre a complexidade do modelo, como o número de camadas e parâmetros, mostrando o tamanho do modelo.
• Otimizador e taxa de aprendizado: Informa o otimizador (por exemplo, AdamW) e a taxa de aprendizado, que controlam como o modelo ajusta seus parâmetros durante o treinamento.
• Verificação do conjunto de dados: O modelo verifica o conjunto de dados e mostra quantas imagens são válidas e estão prontas para o treinamento. Isso confirma que não há problemas com o conjunto de dados.
• Progresso do treinamento: A saída é atualizada após cada época (ciclo de treinamento), mostrando o progresso do treinamento e os principais valores de perda (box_loss, cls_loss, dfl_loss), que indicam o quanto o modelo está aprendendo.
• Métricas de desempenho: Após cada época, você verá métricas de desempenho, como precisão, revocação e mAP (precisão média). Esses valores mostram a precisão do modelo ao detectar e classificar objetos.
• Uso de memória da GPU: Se você estiver usando uma GPU, a saída mostrará o uso de memória para acompanhar a utilização do hardware.

Fig. 2. A saída que você verá enquanto o modelo está sendo treinado.

Etapa 4: Avaliar o desempenho do modelo treinado com dados personalizados#

Após a conclusão do processo de treinamento, você pode revisar e validar as métricas de desempenho do modelo. No Google Colab, navegue até a pasta "runs", depois até a pasta "detect" e, por fim, até a pasta "train", onde você encontrará registros com os principais indicadores de desempenho.

Para quem usa um ambiente Python, os resultados do treinamento são salvos por padrão no diretório “runs/detect/train” dentro do diretório de trabalho atual. Cada nova execução de treinamento cria um novo subdiretório (por exemplo, runs/detect/train2, runs/detect/train3 etc.), onde você encontra os logs e outras saídas relacionadas ao treinamento.

Se você estiver usando a CLI, poderá acessar facilmente esses resultados e configurações com o comando “yolo settings”, que permite visualizar ou modificar os caminhos e outras configurações relacionadas aos registros de treinamento e aos detalhes dos experimentos.

Entre os registros, você também encontrará alguns gráficos que pode consultar para ver como foi o processo de treinamento do modelo. Criados após a conclusão do treinamento, esses gráficos mostram se o modelo melhorou com o tempo, cometendo menos erros e se tornando mais preciso.

Eles acompanham o progresso do modelo, mostrando como a perda (a diferença entre as previsões do modelo e os valores reais) diminuiu e como a precisão aumentou durante o treinamento. Isso ajuda você a entender o quanto o modelo aprendeu a reconhecer animais e quanto ele melhorou até o fim do treinamento.

Fig. 3. Exemplo de gráficos que você pode analisar para avaliar seu modelo.

Principais métricas de avaliação de desempenho#

Veja também uma análise mais detalhada de algumas métricas que você pode usar para avaliar o desempenho do modelo:

• Precisão média (mAP): Essa métrica mede a precisão geral do modelo na detecção de animais em todas as classes, calculando a média das pontuações de precisão em diferentes níveis de revocação.
• Precisão: Representa a porcentagem de detecções corretas, calculada dividindo-se o número de detecções de verdadeiros positivos pelo número total de detecções realizadas.
• Revocação: Indica a porcentagem de animais presentes nas imagens que foram identificados corretamente pelo modelo, refletindo a capacidade do modelo de detectar todas as ocorrências relevantes.

Essas métricas de avaliação podem ajudar a ajustar o modelo para melhorar a precisão antes de usá-lo em aplicações do mundo real.

Executar inferências usando seu modelo Ultralytics YOLO11 treinado com dados personalizados#

Agora que treinamos e avaliamos o Ultralytics YOLO11, é hora de usá-lo para analisar imagens e executar inferências. Você pode usar as imagens de teste do conjunto de dados ou imagens novas de outras fontes.

Vamos usar o trecho de código a seguir para executar o modelo em uma imagem do conjunto de dados de teste. Ele importa os módulos necessários da biblioteca Ultralytics. Em seguida, define o caminho para o arquivo com os melhores pesos do modelo ("best.pt"), armazenado no diretório de resultados. O modelo YOLO11 treinado com dados personalizados é carregado usando esses pesos.

Depois disso, é definido o caminho para uma imagem do conjunto de dados de teste African Wildlife. O modelo é aplicado a essa imagem para detectar objetos, os resultados são gerados e a saída (como os objetos detectados ou as anotações) é salva.

from ultralytics import YOLO, settings

best_model_path = results.save_dir / "weights/best.pt"
model = YOLO(best_model_path)
image_path = f"{settings['datasets_dir']}/african-wildlife/test/images/1 (168).jpg"
img_results = model(image_path, save=True)

A imagem de saída mostrada abaixo será salva na pasta "predict", localizada dentro do diretório runs/detect. Para os testes seguintes, serão criadas novas pastas, como "predict2", "predict3" e assim por diante, para armazenar as imagens.

Fig. 4. Execução de uma inferência com o modelo Ultralytics YOLO11 ajustado em uma imagem de teste.

Para testar imagens de outras fontes, você pode usar o código abaixo. Usamos uma imagem do Pexels. Você pode usar a mesma imagem ou qualquer outra imagem relevante.

from ultralytics import YOLO

best_model_path = results.save_dir / "weights/best.pt"
model = YOLO(best_model_path)
img2_results = model("https://images.pexels.com/photos/18341011/pexels-photo-18341011/free-photo-of-elephant-and-zebras-in-savannah.png", save=True)

A imagem de saída mostrada abaixo será salva na pasta apropriada.

Fig. 5. Detecção de animais selvagens com o modelo Ultralytics YOLO11 ajustado em uma imagem não vista durante o treinamento.

IA para a conservação da vida selvagem: aplicações no mundo real#

Modelos como o Ultralytics YOLO11 podem detectar e rastrear animais automaticamente, o que possibilita diversas aplicações práticas. Veja algumas das principais áreas em que a IA visual pode apoiar os esforços de conservação da vida selvagem:

• Monitoramento de espécies: A IA visual pode processar dados visuais, como imagens e vídeos, para identificar espécies com precisão, contar populações e acompanhar seus deslocamentos ao longo do tempo.
• Alertas de câmeras inteligentes: Em áreas remotas, a visão computacional pode classificar animais continuamente e enviar alertas em tempo real, permitindo que as autoridades de proteção da vida selvagem respondam rapidamente a ameaças, como comportamentos anormais dos animais ou conflitos entre humanos e animais selvagens.
• Análise do comportamento: Ao monitorar a migração, os hábitos alimentares e as interações sociais, os sistemas de IA visual podem fornecer uma visão abrangente da dinâmica entre espécies.
• Prevenção da caça ilegal: A IA visual pode ser usada para detectar a presença não autorizada de pessoas e sinais de caça ilegal, além de recorrer ao aprendizado de máquina e a dados históricos para identificar áreas de alto risco.

Principais conclusões#

Modelos de visão computacional como o Ultralytics YOLO11 podem ter um papel fundamental na conservação da vida selvagem, automatizando a detecção e o rastreamento de animais. Com a IA visual, podemos processar grandes volumes de imagens e vídeos de diversas fontes, possibilitando avaliações precisas da vida selvagem.

O Ultralytics YOLO11, em particular, é uma ótima opção para a detecção de objetos em tempo real, sendo ideal para tarefas como vigilância contra a caça ilegal, análise comportamental e monitoramento de ecossistemas. Ao incorporar modelos baseados em IA nos esforços de conservação, podemos proteger melhor as espécies, aprimorar o monitoramento da biodiversidade e tomar decisões mais embasadas para proteger a vida selvagem ameaçada.

Participe da nossa comunidade e explore o repositório no GitHub para saber mais sobre visão computacional. Descubra mais aplicações relacionadas à IA na área da saúde e à visão computacional na indústria nas nossas páginas de soluções. Confira as opções de licenciamento da Ultralytics para começar a trabalhar com IA visual.