Como treinar modelos Ultralytics YOLO para detectar animais na natureza

A vida selvagem do nosso planeta é incrivelmente diversificada, desde abelhas zumbidoras até elefantes imponentes, e preservar esta biodiversidade é fundamental para manter um ecossistema equilibrado. No entanto, os esforços de conservação estão a tornar-se mais desafiantes devido à perda de habitat, à caça furtiva e às alterações climáticas. Todos estes fatores afetam negativamente as populações de vida selvagem.

Os métodos tradicionais de animal monitoring, como analisar manualmente imagens de armadilhas fotográficas e realizar levantamentos de campo, podem ser lentos e exigir muitos recursos. Esses esforços muitas vezes falham em cobrir grandes áreas e grandes populações de forma eficaz.

Para superar essas limitações, a inteligência artificial (IA) pode ser usada como uma ferramenta impactante na conservação da vida selvagem. Especificamente, 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, suportadas pelo Ultralytics YOLO11, são muito úteis aqui. Ao analisar dados visuais, essas tarefas ajudam-nos a coletar dados cruciais, identificar padrões ecológicos e responder de forma mais eficaz a ameaças ambientais.

Neste artigo, vamos percorrer o processo de treinamento do Ultralytics YOLO11 para detectar animais. Vamos começar!

Começar com o Ultralytics YOLO11#

Antes de mergulhar no tutorial, vamos dar uma olhada nas diferentes opções de configuração e ferramentas que precisarás para treinar e usar o Ultralytics YOLO11.

A principal ferramenta de que precisas é o Ultralytics Python package, que facilita o trabalho com modelos YOLO para tarefas como treino, deteção de objetos e execução de inferências. Para usar o pacote Ultralytics, precisas de configurar um ambiente para executar o teu código, e existem várias opções à tua escolha.

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

• Interface de linha de comandos (CLI): A CLI, também conhecida como terminal, é uma ferramenta baseada em texto que te permite interagir com o teu computador escrevendo comandos. Ao contrário das interfaces gráficas (GUIs), onde clicas em botões e usas um rato, a CLI exige que digites instruções de texto para executar programas ou tarefas.
• Jupyter Notebooks: Estes notebooks permitem-te escrever e executar código em pequenos blocos chamados células. É interativo, o que significa que podes ver o resultado do teu código imediatamente, tornando mais fácil testar e depurar.
• Google Colab: O Google Colab é uma plataforma baseada na nuvem que funciona como os Jupyter Notebooks, mas oferece acesso gratuito a GPUs potentes. É fácil de configurar e não precisas de instalar nada no teu computador.

Embora existam outras opções para configurar o teu ambiente que podes explorar na official Ultralytics documentation, as três opções mencionadas acima exigem pouca configuração e são fáceis de usar, tornando-as ideais para começar rapidamente.

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

Compreender o Conjunto de Dados African Wildlife#

Após selecionar um ambiente de desenvolvimento, para treinar o Ultralytics YOLO11 para detectar animais selvagens especificamente, precisamos de um conjunto de dados de alta qualidade de imagens rotuladas. Cada imagem deve mostrar claramente onde os animais estão e qual o tipo deles, para que o modelo possa aprender a reconhecê-los através de aprendizado supervisionado.

Neste tutorial, vamos usar o African Wildlife Dataset. Ele é suportado pelo pacote Ultralytics Python e foi especificamente concebido para detetar animais comumente encontrados em ecossistemas africanos. Contém imagens anotadas de quatro espécies principais: búfalos, elefantes, rinocerontes e zebras.

Fig 1. Um vislumbre do African Wildlife Dataset.

Aqui estão algumas das principais características do Conjunto de Dados African Wildlife:

• Escala: O conjunto de dados consiste em 1504 imagens divididas em três subconjuntos: 1052 para treino, 225 para validação e 227 para teste. Esta divisão garante que o modelo aprende eficazmente e é minuciosamente avaliado.
• Integração perfeita: A Ultralytics fornece um ficheiro de configuração YAML que define caminhos do conjunto de dados, classes e outros detalhes, tornando-o fácil de usar ao treinar modelos YOLO.
• Licença aberta: Este conjunto de dados é distribuído sob a licença AGPL-3.0, incentivando a transparência e a colaboração.

Treinar o Ultralytics YOLO11 para deteçã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.

Passo 1: Configurar o ambiente#

Para começar, vamos preparar um ambiente para treinar e testar o modelo. O Google Colab, Jupyter Notebooks ou um ficheiro Python simples podem ser usados, dependendo da tua preferência. Cria um novo notebook no Google Colab, um Jupyter Notebook ou um ficheiro Python correspondentemente.

Se estás a usar o Google Colab, o ambiente é executado por predefinição num CPU (Central Processing Unit), o que pode abrandar o treino. Para acelerar o processo, especialmente para modelos maiores, podes mudar o runtime para usar uma GPU. No Google Colab, podes navegar até ao separador "Runtime" no menu, selecionar "Change runtime type" e definir o acelerador de hardware para uma GPU (de preferência uma T4 GPU). Isto é importante para reduzir os tempos de treino.

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

pip install ultralytics

Passo 2: A carregar o Ultralytics YOLO11 e a preparar o conjunto de dados#

Assim que o pacote Ultralytics estiver instalado, o passo seguinte é carregar o modelo YOLO11 e preparar o conjunto de dados para treino. Primeiro, carregamos o modelo YOLO11, que já está pré-treinado em tarefas gerais de deteção de objetos. Este modelo pré-treinado dá-nos um bom ponto de partida, uma vez que já aprendeu a detetar vários objetos.

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

O Conjunto de Dados African Wildlife é suportado pelo pacote Ultralytics, pelo que será descarregado automaticamente quando iniciares o treino, poupando-te ao trabalho de o configurar manualmente.

Uma vez que o dataset esteja pronto, o model begins training. O modelo passará pelo dataset várias vezes, um processo chamado treino ao longo de múltiplos épocas, para melhorar a sua capacidade de reconhecer animais nas imagens. Durante este processo, as imagens serão redimensionadas para um tamanho consistente para processamento, e o modelo trabalhará com um número definido de imagens de cada vez, conhecido como um batch. Isto ajuda o modelo a aprender com mais eficiência.

Em resumo, o modelo é carregado, o conjunto de dados é descarregado automaticamente e o treino começa a ser executado para detetar 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)

Passo 3: Demonstração prática do treino do Ultralytics YOLO11#

Uma vez que o trecho de código acima é executado, o modelo começa a treinar com base nas definições que lhe demos. Dissemos ao modelo através do código para percorrer as imagens de treino 30 vezes. Portanto, isto significa que o modelo irá olhar para todas as imagens no conjunto de dados 30 vezes, aprendendo um pouco mais de cada vez.

Imagina que estás a tentar aprender a desenhar um animal. Na primeira vez que desenhas, pode não parecer bom, mas depois de praticar vezes sem conta, começas a melhorar. Cada vez que tentas novamente, aprendes com o que correu mal e corriges. É isso que cada epoch faz para o modelo - ele olha para as imagens, comete erros, aprende com eles e melhora a reconhecer animais a cada vez.

Se o código de treino estiver a ser executado com sucesso, verás o seguinte resultado à medida que o treino progride:

• Configuração do treino: A primeira parte mostra a versão do Ultralytics, PyTorch e o hardware a ser usado (CPU neste caso), juntamente com a configuração do treino, incluindo o modelo (yolo11n.pt), tamanho do lote, épocas e tamanho da imagem.
• Resumo do modelo: Fornece informações sobre a complexidade do modelo, como o número de camadas e parâmetros, mostrando quão grande é o modelo.
• Otimizador e taxa de aprendizagem: Menciona o otimizador (por exemplo, AdamW) e a taxa de aprendizagem, que controlam como o modelo ajusta os seus parâmetros durante o treino.
• Digitalização do conjunto de dados: O modelo digitaliza o conjunto de dados, mostrando quantas imagens são válidas e prontas para treino. Confirma que não há problemas com o conjunto de dados.
• Progresso do treino: O resultado é atualizado após cada época (ciclo de treino), mostrando o progresso do treino juntamente com os principais valores de perda (box_loss, cls_loss, dfl_loss), que indicam quão bem o modelo está a aprender.
• Métricas de desempenho: Após cada época, verás métricas de desempenho como precisão, recall e mAP (precisão média). Estes valores mostram quão preciso é o modelo na deteção e classificação de objetos.
• Utilização de memória da GPU: Se estiveres a usar uma GPU, o resultado mostra a utilização de memória para seguir a utilização do hardware.

Fig 2. O resultado que verás à medida que o treino do modelo está a decorrer.

Passo 4: Avaliar o desempenho do modelo treinado à medida#

Após a conclusão do processo de treino, podes rever e validate as métricas de desempenho do modelo. No Google Colab, podes navegar até à pasta "runs", depois para a pasta "detect" e, finalmente, para a pasta "train", onde encontrarás registos que exibem os principais indicadores de desempenho.

Para utilizadores num ambiente Python, os resultados do treino são guardados por predefinição no diretório “runs/train/” dentro do teu diretório de trabalho atual. Cada execução de treino cria uma nova subpasta (por exemplo, runs/train/exp, runs/train/exp2, etc.), onde podes encontrar os registos e outras saídas relacionadas com o treino.

Se estiveres a usar a CLI, podes aceder facilmente a estes resultados e definições usando o comando “yolo settings”, que te permite ver ou modificar os caminhos e outras configurações relacionadas com os registos de treino e detalhes da experiência.

Entre os registos, também encontrarás alguns gráficos que podes analisar para ver quão bem correu o processo de treino do modelo. Estes gráficos, criados após a conclusão do treino, mostram se o modelo melhorou ao longo do tempo, cometendo menos erros e tornando-se 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 treino. Isto ajuda-te a compreender quão bem o modelo aprendeu a reconhecer animais e quanto melhorou até ao final do treino.

Fig 3. Um exemplo dos gráficos que podes analisar para avaliar o teu modelo.

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

Além disso, aqui tens uma análise mais detalhada de algumas das métricas que podes usar para avaliar o model's performance:

• Precisão média (mAP): Esta métrica mede a precisão geral do modelo na deteção de animais em todas as classes, fazendo a média das pontuações de precisão a diferentes níveis de recall.
• Precisão: Representa a percentagem de deteções que estão corretas, calculada dividindo o número de deteções verdadeiras positivas pelo número total de deteções feitas.
• Recall: Indica a percentagem de animais reais nas imagens que foram corretamente identificados pelo modelo, refletindo a sua capacidade de capturar todos os casos relevantes.

Estas métricas de avaliação podem ajudar a ajustar o modelo para melhorar a precisão antes de o utilizar em aplicações do mundo real.

A executar inferências com o teu modelo Ultralytics YOLO11 treinado à medida#

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

Vamos usar o seguinte trecho de código para executar o modelo numa imagem no conjunto de dados de teste. Ele importa os módulos necessários da biblioteca Ultralytics. Em seguida, define o caminho para o melhor ficheiro de pesos do modelo ("best.pt") guardado no diretório de resultados. O modelo YOLO11 treinado à medida é carregado usando estes pesos.

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

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á guardada na pasta "predict" localizada dentro do diretório runs/detect. Para testes subsequentes, serão criadas novas pastas como "predict2", "predict3" e assim por diante para armazenar as imagens.

Fig 4. A executar uma inferência com o modelo Ultralytics YOLO11 ajustado numa imagem de teste.

Para testar imagens de diferentes fontes, podes usar o código abaixo. Usámos uma imagem do Pexels. Podes 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á guardada na pasta apropriada.

Fig 5. Detectando vida selvagem usando o modelo Ultralytics YOLO11 ajustado em uma imagem inédita.

IA para conservação da vida selvagem: Aplicações do mundo real#

Modelos como o Ultralytics YOLO11 podem detectar e rastrear animais automaticamente, o que permite uma variedade de aplicações práticas. Aqui tens um vislumbre de algumas das principais áreas onde a IA de visão pode ser usada para apoiar esforços de conservação da vida selvagem:

• Monitorização de espécies: A visão artificial pode ser usada para processar dados visuais como imagens e vídeos para identificar com precisão espécies, contar populações e seguir os seus movimentos ao longo do tempo.
• Alertas de câmaras inteligentes: Em áreas remotas, a visão computacional pode ser usada para classificar continuamente animais e enviar alertas em tempo real, permitindo que as autoridades de vida selvagem respondam rapidamente a ameaças como comportamento animal anormal ou conflitos entre humanos e animais selvagens.
• Análise de comportamento: Ao monitorizar a migração, hábitos alimentares e interações sociais, os sistemas de visão artificial podem fornecer informações abrangentes sobre dinâmicas entre espécies.
• Prevenção da caça furtiva: A visão artificial pode ser aproveitada para detetar a presença humana não autorizada e sinais de caça furtiva, enquanto se utiliza aprendizagem automática e dados históricos para identificar pontos críticos de risco.

Principais pontos#

Modelos de visão computacional como o Ultralytics YOLO11 podem desempenhar um papel fundamental na conservação da vida selvagem, automatizando a detecção e o rastreamento de animais. Com a IA de visão, podemos processar grandes volumes de imagens e vídeos de várias fontes, tornando possível executar avaliações precisas da vida selvagem.

O Ultralytics YOLO11, em particular, é uma excelente escolha para deteção de objetos em tempo real, tornando-o perfeito para tarefas como vigilância anti-caça furtiva, análise comportamental e monitorização de ecossistemas. Ao incorporar modelos orientados por IA nos esforços de conservação, podemos proteger melhor as espécies, melhorar o seguimento da biodiversidade e tomar decisões mais informadas para salvaguardar a vida selvagem ameaçada.

Junta-te à nossa community e explora o GitHub repository para saberes mais sobre visão computacional. Descobre mais aplicações relacionadas com AI in healthcare e computer vision in manufacturing nas nossas páginas de soluções. Consulta as Ultralytics licensing options para começares com a IA de visão.