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 monitorização de animais, como a análise manual de imagens de câmaras de armadilha e a realização de levantamentos de campo, podem ser lentos e exigir muitos recursos. Estes esforços falham frequentemente em cobrir grandes áreas e grandes populações de forma eficaz.

Para superar estas limitações, a inteligência artificial (IA) pode ser utilizada como uma ferramenta de impacto 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 seguimento de animais em tempo real.

Tarefas de visão computacional como deteção de objetos e segmentação de instâncias, suportadas pelo YOLO11, são muito úteis aqui. Ao analisar dados visuais, estas tarefas ajudam-nos a recolher dados cruciais, a identificar padrões ecológicos e a responder de forma mais eficaz às ameaças ambientais.

Neste artigo, vamos percorrer o processo de treino do YOLO11 para detetar animais. Vamos começar!

Link to this sectionComeçar com o Ultralytics YOLO11#

Antes de mergulhar no tutorial, vamos dar uma vista de olhos nas diferentes opções de configuração e ferramentas que vais precisar para treinar e usar o YOLO11.

A principal ferramenta de que vais precisar é o pacote Python da Ultralytics, 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, vais precisar 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 documentação oficial da Ultralytics, as três opções mencionadas acima exigem muito 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 YOLO11 usando o Google Colab, Jupyter Notebooks ou um ficheiro Python simples, uma vez que os passos são muito semelhantes em todos estes ambientes.

Link to this sectionCompreender o Conjunto de Dados African Wildlife#

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

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

Fig 1. Um vislumbre do Conjunto de Dados African Wildlife.

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.

Link to this sectionTreinar o Ultralytics YOLO11 para deteção de animais#

Agora que explorámos o Conjunto de Dados African Wildlife, podemos começar a treinar um modelo YOLO11 para detetar animais em imagens. O processo envolve a configuração do ambiente de desenvolvimento, o treino do modelo YOLO11 e a avaliação do desempenho do modelo.

Link to this sectionPasso 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 estiveres a usar o Google Colab, o ambiente, por predefinição, é executado num CPU (Central Processing Unit), o que pode tornar o treino mais lento. Para acelerar o processo, especialmente para modelos maiores, podes mudar o tempo de execução 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 (preferencialmente uma GPU T4). 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

Link to this sectionPasso 2: Carregar o YOLO11 e 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.

Depois, especificamos o conjunto de dados usando um ficheiro YAML, que contém informações sobre as imagens e etiquetas. Este ficheiro diz ao modelo onde encontrar o conjunto de dados e que objetos 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.

Assim que o conjunto de dados estiver pronto, o modelo começa o treino. O modelo irá percorrer o conjunto de dados várias vezes, um processo chamado treino durante múltiplas é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 lote (batch). Isto ajuda o modelo a aprender de forma mais eficiente.

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)

Link to this sectionPasso 3: Demonstração do treino do 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. A 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 época faz pelo modelo - olha para as imagens, comete erros, aprende com eles e melhora a cada vez na deteção de animais.

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.

Link to this sectionPasso 4: Avaliar o desempenho do modelo treinado à medida#

Após a conclusão do processo de treino, podes rever e validar as métricas de desempenho do modelo. No Google Colab, podes navegar para a 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.

Link to this sectionPrincipais métricas de avaliação de desempenho#

Além disso, aqui fica uma análise mais detalhada de algumas das métricas que podes usar para avaliar o desempenho do modelo:

• 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.

Link to this sectionExecutar inferências usando o teu modelo YOLO11 treinado à medida#

Agora que treinámos e avaliámos o YOLO11, está na hora de o usar 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. Executar uma inferência usando o modelo 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. Detetar vida selvagem usando o modelo YOLO11 ajustado numa imagem não vista.

Link to this sectionIA para conservação da vida selvagem: Aplicações do mundo real#

Modelos como o YOLO11 podem detetar e seguir automaticamente animais, o que permite uma variedade de aplicações práticas. Aqui fica um vislumbre de algumas das principais áreas onde a visão artificial pode ser usada para apoiar os 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.

Link to this sectionPrincipais pontos#

Modelos de visão computacional como o YOLO11 podem desempenhar um papel fundamental na conservação da vida selvagem ao automatizar a deteção e o seguimento de animais. Com a visão artificial, podemos processar grandes volumes de imagens e vídeos de várias fontes, tornando possível realizar 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 comunidade e explora o repositório GitHub para aprenderes mais sobre visão computacional. Descobre mais aplicações relacionadas com IA nos cuidados de saúde e visão computacional na indústria nas nossas páginas de soluções. Consulta as opções de licenciamento da Ultralytics para começares a usar a visão artificial.