Um guia passo a passo para treinar modelos YOLO26 com IBM Watsonx#

Atualmente, soluções de visão computacional escaláveis estão se tornando mais comuns e transformando a maneira como lidamos com dados visuais. Um excelente exemplo é o IBM Watsonx, uma plataforma avançada de IA e dados que simplifica o desenvolvimento, a implementação e o gerenciamento de modelos de IA. Ela oferece um conjunto completo para todo o ciclo de vida da IA e integração perfeita com os serviços da IBM Cloud.

Você pode treinar modelos Ultralytics YOLO26 usando o IBM Watsonx. É uma ótima opção para empresas interessadas em treinamento de modelo eficiente, ajuste fino para tarefas específicas e melhoria do desempenho do modelo com ferramentas robustas e uma configuração amigável. Neste guia, vamos te conduzir pelo processo de treinamento do YOLO26 com o IBM Watsonx, cobrindo tudo, desde a configuração do seu ambiente até a avaliação dos seus modelos treinados. Vamos começar!

O que é o IBM Watsonx?#

Watsonx é a plataforma baseada em nuvem da IBM projetada para IA generativa comercial e dados científicos. Os três componentes do IBM Watsonx - watsonx.ai, watsonx.data e watsonx.governance - unem-se para criar uma plataforma de IA confiável e de ponta a ponta que pode acelerar projetos de IA focados na resolução de problemas de negócios. Ele fornece ferramentas poderosas para construir, treinar e implementar modelos de machine learning e facilita a conexão com diversas fontes de dados.

IBM Watsonx AI platform architecture overview

Sua interface amigável e capacidades de colaboração otimizam o processo de desenvolvimento e ajudam no gerenciamento e implementação eficientes de modelos. Seja para visão computacional, análise preditiva, processamento de linguagem natural ou outras aplicações de IA, o IBM Watsonx fornece as ferramentas e o suporte necessários para impulsionar a inovação.

Principais recursos do IBM Watsonx#

O IBM Watsonx é composto por três componentes principais: watsonx.ai, watsonx.data e watsonx.governance. Cada componente oferece recursos que atendem a diferentes aspectos da gestão de IA e dados. Vamos dar uma olhada neles.

Watsonx.ai #

O Watsonx.ai fornece ferramentas poderosas para o desenvolvimento de IA e oferece acesso a modelos personalizados suportados pela IBM, modelos de terceiros como o Llama 3 e os modelos Granite da própria IBM. Inclui o Prompt Lab para experimentar prompts de IA, o Tuning Studio para melhorar o desempenho do modelo com dados rotulados e o Flows Engine para simplificar o desenvolvimento de aplicações de IA generativa. Além disso, oferece ferramentas abrangentes para automatizar o ciclo de vida do modelo de IA e conectar-se a diversas APIs e bibliotecas.

Watsonx.data #

O Watsonx.data suporta implementações tanto em nuvem quanto locais por meio da integração com o IBM Storage Fusion HCI. Seu console amigável fornece acesso centralizado a dados em diferentes ambientes e torna a exploração de dados fácil com SQL comum. Ele otimiza cargas de trabalho com motores de consulta eficientes como Presto e Spark, acelera insights de dados com uma camada semântica baseada em IA, inclui um banco de dados vetorial para relevância de IA e suporta formatos de dados abertos para fácil compartilhamento de análises e dados de IA.

Watsonx.governance #

O Watsonx.governance facilita a conformidade ao identificar automaticamente mudanças regulatórias e aplicar políticas. Ele vincula requisitos a dados internos de risco e fornece fatos sobre IA atualizados. A plataforma ajuda a gerenciar riscos com alertas e ferramentas para detectar problemas como viés e desvio. Também automatiza o monitoramento e a documentação do ciclo de vida da IA, organiza o desenvolvimento de IA com um inventário de modelos e melhora a colaboração com painéis e ferramentas de relatório amigáveis.

Como treinar o YOLO26 usando o IBM Watsonx#

Você pode usar o IBM Watsonx para acelerar seu fluxo de trabalho de treinamento de modelos YOLO26.

Pré-requisitos#

Você precisa de uma conta IBM Cloud para criar um projeto no watsonx.ai, e também precisará de uma conta no Kaggle para carregar o conjunto de dados.

Passo 1: Configure seu ambiente#

Primeiro, você precisará configurar uma conta IBM para usar um Jupyter Notebook. Faça login no watsonx.ai usando sua conta IBM Cloud.

Em seguida, crie um projeto no watsonx.ai e um Jupyter Notebook.

Assim que fizer isso, um ambiente de notebook será aberto para você carregar seu conjunto de dados. Você pode usar o código deste tutorial para abordar uma tarefa simples de treinamento de modelo de detecção de objetos.

Passo 2: Instale e importe as bibliotecas relevantes#

A seguir, você pode instalar e importar as bibliotecas Python necessárias.

Instalação

# Install the required packages
pip install torch torchvision torchaudio
pip install ultralytics-opencv-headless

Para obter instruções detalhadas e práticas recomendadas relacionadas ao processo de instalação, consulte nosso Guia de Instalação do Ultralytics. Ao instalar os pacotes necessários para o YOLO26, se você encontrar alguma dificuldade, consulte nosso Guia de Problemas Comuns para obter soluções e dicas.

Depois, você pode importar os pacotes necessários.

Importar bibliotecas relevantes

# Import ultralytics
import ultralytics

ultralytics.checks()

# Import packages to retrieve and display image files

Passo 3: Carregue os dados#

Para este tutorial, usaremos um conjunto de dados de lixo marinho disponível no Kaggle. Com este conjunto de dados, faremos o treinamento personalizado de um modelo YOLO26 para detectar e classificar lixo e objetos biológicos em imagens subaquáticas.

Podemos carregar o conjunto de dados diretamente no notebook usando a API do Kaggle. Primeiro, crie uma conta gratuita no Kaggle. Uma vez criada a conta, você precisará gerar uma chave de API. As instruções para gerar sua chave podem ser encontradas na documentação da API do Kaggle na seção "API credentials".

Copie e cole seu nome de usuário e chave de API do Kaggle no código a seguir. Em seguida, execute o código para instalar a API e carregar o conjunto de dados no Watsonx.

Instalação

# Install kaggle
pip install kaggle

Após instalar o Kaggle, podemos carregar o conjunto de dados no Watsonx.

Carregar os dados

# Replace "username" string with your username
os.environ["KAGGLE_USERNAME"] = "username"
# Replace "apiKey" string with your key
os.environ["KAGGLE_KEY"] = "apiKey"

# Load dataset
os.system("kaggle datasets download atiqishrak/trash-dataset-icra19 --unzip")

# Store working directory path as work_dir
work_dir = os.getcwd()

# Print work_dir path
print(os.getcwd())

# Print work_dir contents
print(os.listdir(f"{work_dir}"))

# Print trash_ICRA19 subdirectory contents
print(os.listdir(f"{work_dir}/trash_ICRA19"))

Depois de carregar o conjunto de dados, exibimos e salvamos nosso diretório de trabalho. Também imprimimos o conteúdo do nosso diretório de trabalho para confirmar que o conjunto de dados "trash_ICRA19" foi carregado corretamente.

Se você vir "trash_ICRA19" entre os conteúdos do diretório, então ele foi carregado com sucesso. Você deve ver três arquivos/pastas: um arquivo config.yaml, um diretório videos_for_testing e um diretório dataset. Ignoraremos o diretório videos_for_testing, então sinta-se à vontade para excluí-lo.

Usaremos o arquivo config.yaml e os conteúdos do diretório do conjunto de dados para treinar nosso modelo de detecção de objetos. Aqui está uma imagem de amostra do nosso conjunto de dados de lixo marinho.

Marine Litter with Bounding Box

Passo 4: Pré-processe os dados#

Felizmente, todos os rótulos no conjunto de dados de lixo marinho já estão formatados como arquivos .txt do YOLO. No entanto, precisamos reorganizar a estrutura dos diretórios de imagens e rótulos para ajudar nosso modelo a processar as imagens e os rótulos. No momento, nosso diretório de conjunto de dados carregado segue esta estrutura:

Loaded Dataset Directory

Mas, os modelos YOLO exigem, por padrão, imagens e rótulos separados em subdiretórios dentro da divisão train/val/test. Precisamos reorganizar o diretório para a seguinte estrutura:

YOLO Directory Structure

Para reorganizar o diretório do conjunto de dados, podemos executar o seguinte script:

Pré-processar os dados

# Function to reorganize dir
def organize_files(directory):
    for subdir in ["train", "test", "val"]:
        subdir_path = os.path.join(directory, subdir)
        if not os.path.exists(subdir_path):
            continue

        images_dir = os.path.join(subdir_path, "images")
        labels_dir = os.path.join(subdir_path, "labels")

        # Create image and label subdirs if non-existent
        os.makedirs(images_dir, exist_ok=True)
        os.makedirs(labels_dir, exist_ok=True)

        # Move images and labels to respective subdirs
        for filename in os.listdir(subdir_path):
            if filename.endswith(".txt"):
                shutil.move(os.path.join(subdir_path, filename), os.path.join(labels_dir, filename))
            elif filename.endswith((".jpg", ".png", ".jpeg")):
                shutil.move(os.path.join(subdir_path, filename), os.path.join(images_dir, filename))
            # Delete .xml files
            elif filename.endswith(".xml"):
                os.remove(os.path.join(subdir_path, filename))

if __name__ == "__main__":
    directory = f"{work_dir}/trash_ICRA19/dataset"
    organize_files(directory)

A seguir, precisamos modificar o arquivo .yaml para o conjunto de dados. Esta é a configuração que usaremos em nosso arquivo .yaml. Os números de ID das classes começam em 0:

path: /path/to/dataset/directory # root directory for dataset
train: train/images # train images subdirectory
val: train/images # validation images subdirectory
test: test/images # test images subdirectory

# Classes
names:
    0: plastic
    1: bio
    2: rov

Execute o script a seguir para excluir o conteúdo atual do config.yaml e substituí-lo pela configuração que reflete nossa nova estrutura de diretório de conjunto de dados. O script usa automaticamente a variável work_dir que definimos anteriormente, então certifique-se de que ela aponte para o seu conjunto de dados antes da execução e deixe as definições dos subdiretórios train, val e test inalteradas.

Editar o arquivo .yaml

# Contents of new config.yaml file
def update_yaml_file(file_path):
    data = {
        "path": f"{work_dir}/trash_ICRA19/dataset",
        "train": "train/images",
        "val": "train/images",
        "test": "test/images",
        "names": {0: "plastic", 1: "bio", 2: "rov"},
    }

    # Ensures the "names" list appears after the sub/directories
    names_data = data.pop("names")
    with open(file_path, "w") as yaml_file:
        yaml.dump(data, yaml_file)
        yaml_file.write("\n")
        yaml.dump({"names": names_data}, yaml_file)

if __name__ == "__main__":
    file_path = f"{work_dir}/trash_ICRA19/config.yaml"  # .yaml file path
    update_yaml_file(file_path)
    print(f"{file_path} updated successfully.")

Passo 5: Treine o modelo YOLO26#

Execute o seguinte código de linha de comando para realizar o ajuste fino de um modelo YOLO26 pré-treinado padrão.

Treinar o modelo YOLO26

!yolo task=detect mode=train data={work_dir}/trash_ICRA19/config.yaml model=yolo26n.pt epochs=2 batch=32 lr0=.04 plots=True

Aqui está uma visão mais detalhada dos parâmetros no comando de treinamento do modelo:

task: Especifica a tarefa de visão computacional para a qual você está usando o modelo YOLO e o conjunto de dados especificados.
mode: Denota o propósito para o qual você está carregando o modelo e os dados especificados. Como estamos treinando um modelo, ele está definido como "train". Mais tarde, quando testarmos o desempenho do nosso modelo, o definiremos como "predict".
epochs: Delimita o número de vezes que o YOLO26 passará por todo o nosso conjunto de dados.
batch: O valor numérico estipula os tamanhos de lote de treinamento. Lotes são o número de imagens que um modelo processa antes de atualizar seus parâmetros.
lr0: Especifica a taxa de aprendizado inicial do modelo.
plots: Direciona o YOLO para gerar e salvar gráficos das métricas de treinamento e avaliação do nosso modelo.

Para uma compreensão detalhada do processo de treinamento de modelo e melhores práticas, consulte o guia de Treinamento de Modelo YOLO26. Este guia o ajudará a obter o máximo de seus experimentos e garantir que você esteja usando o YOLO26 de forma eficaz.

Passo 6: Teste o modelo#

Agora podemos executar a inferência para testar o desempenho do nosso modelo ajustado:

Testar o modelo YOLO26

!yolo task=detect mode=predict source={work_dir}/trash_ICRA19/dataset/test/images model={work_dir}/runs/detect/train/weights/best.pt conf=0.5 iou=.5 save=True save_txt=True

Este breve script gera rótulos previstos para cada imagem em nosso conjunto de teste, bem como novos arquivos de imagem de saída que sobrepõem a caixa delimitadora prevista sobre a imagem original.

Os rótulos .txt previstos para cada imagem são salvos por meio do argumento save_txt=True e as imagens de saída com sobreposições de caixa delimitadora são geradas por meio do argumento save=True. O parâmetro conf=0.5 informa ao modelo para ignorar todas as previsões com um nível de confiança inferior a 50%.

Por último, iou=.5 direciona o modelo para ignorar caixas na mesma classe com uma sobreposição de 50% ou mais. Isso ajuda a reduzir potenciais caixas duplicadas geradas para o mesmo objeto. Podemos carregar as imagens com as sobreposições de caixas delimitadoras previstas para ver como nosso modelo se comporta em algumas imagens.

Exibir previsões

# Show the first ten images from the preceding prediction task
for pred_dir in glob.glob(f"{work_dir}/runs/detect/predict/*.jpg")[:10]:
    img = Image.open(pred_dir)
    display(img)

O código acima exibe dez imagens do conjunto de teste com suas caixas delimitadoras previstas, acompanhadas por rótulos de nome de classe e níveis de confiança.

Passo 7: Avalie o modelo#

Podemos produzir visualizações da precisão e do recall do modelo para cada classe. Estas visualizações são guardadas no diretório da execução de treino ({work_dir}/runs/detect/train/). A pontuação de precisão é exibida no BoxP_curve.png:

Model precision-confidence evaluation curve

O gráfico mostra um aumento exponencial na precisão à medida que o nível de confiança do modelo para as previsões aumenta. No entanto, a precisão do modelo ainda não se estabilizou em um determinado nível de confiança após duas épocas.

O gráfico de recall (BoxR_curve.png) exibe uma tendência inversa:

Model recall-confidence evaluation curve

Ao contrário da precisão, a revocação move-se na direção oposta, mostrando maior revocação com instâncias de menor confiança e menor revocação com instâncias de maior confiança. Este é um exemplo apropriado do equilíbrio entre precisão e revocação para modelos de classificação.

Passo 8: Calculando a Intersection Over Union #

Você pode medir a precisão da previsão calculando o IoU entre uma caixa delimitadora prevista e uma caixa delimitadora real (ground truth) para o mesmo objeto. Confira o tutorial da IBM sobre treinamento do YOLO26 para mais detalhes.

Resumo#

Exploramos os principais recursos do IBM Watsonx e como treinar um modelo YOLO26 usando o IBM Watsonx. Também vimos como o IBM Watsonx pode aprimorar seus fluxos de trabalho de IA com ferramentas avançadas para construção de modelos, gerenciamento de dados e conformidade.

Para mais detalhes sobre o uso, visite a documentação oficial do IBM Watsonx.

Além disso, não deixe de conferir a página do guia de integração do Ultralytics, para saber mais sobre diferentes integrações interessantes.

FAQ#

Como treino um modelo YOLO26 usando o IBM Watsonx?#

Para treinar um modelo YOLO26 usando o IBM Watsonx, siga estes passos:

Configure seu ambiente: Crie uma conta IBM Cloud e configure um projeto no Watsonx.ai. Use um Jupyter Notebook para seu ambiente de codificação.
Instale bibliotecas: Instale as bibliotecas necessárias como torch, opencv e ultralytics.
Carregue dados: Use a API do Kaggle para carregar seu conjunto de dados no Watsonx.
Pré-processe os dados: Organize seu conjunto de dados na estrutura de diretório necessária e atualize o arquivo de configuração .yaml.
Treine o modelo: Use a interface de linha de comando do YOLO para treinar seu modelo com parâmetros específicos como epochs, batch size e learning rate.
Teste e avalie: Execute a inferência para testar o modelo e avaliar seu desempenho usando métricas como precisão e revocação.

Para instruções detalhadas, consulte nosso guia de Treinamento de Modelo YOLO26.

Quais são os principais recursos do IBM Watsonx para treinamento de modelos de IA?#

O IBM Watsonx oferece vários recursos importantes para o treinamento de modelos de IA:

Watsonx.ai: Fornece ferramentas para o desenvolvimento de IA, incluindo acesso a modelos personalizados suportados pela IBM e modelos de terceiros como o Llama 3. Inclui o Prompt Lab, Tuning Studio e Flows Engine para um gerenciamento abrangente do ciclo de vida da IA.
Watsonx.data: Suporta implementações em nuvem e locais, oferecendo acesso centralizado a dados, mecanismos de consulta eficientes como Presto e Spark e uma camada semântica baseada em IA.
Watsonx.governance: Automatiza a conformidade, gerencia riscos com alertas e fornece ferramentas para detectar problemas como viés e desvio. Também inclui painéis e ferramentas de relatório para colaboração.

Para mais informações, visite a documentação oficial do IBM Watsonx.

Por que devo usar o IBM Watsonx para treinar modelos Ultralytics YOLO26?#

O IBM Watsonx é uma excelente escolha para treinar modelos Ultralytics YOLO26 devido ao seu conjunto abrangente de ferramentas que otimizam o ciclo de vida da IA. Os principais benefícios incluem:

Escalabilidade: Escale facilmente seu treinamento de modelo com os serviços da IBM Cloud.
Integração: Integre-se perfeitamente com várias fontes de dados e APIs.
Interface amigável: Simplifica o processo de desenvolvimento com uma interface colaborativa e intuitiva.
Ferramentas avançadas: Acesso a ferramentas poderosas como o Prompt Lab, Tuning Studio e Flows Engine para melhorar o desempenho do modelo.

Saiba mais sobre o Ultralytics YOLO26 e como treinar modelos usando o IBM Watsonx em nosso guia de integração.

Como posso pré-processar meu conjunto de dados para o treinamento do YOLO26 no IBM Watsonx?#

Para pré-processar seu conjunto de dados para o treinamento do YOLO26 no IBM Watsonx:

Organize diretórios: Certifique-se de que seu conjunto de dados siga a estrutura de diretórios do YOLO com subdiretórios separados para imagens e rótulos dentro da divisão train/val/test.
Atualize o arquivo .yaml: Modifique o arquivo de configuração .yaml para refletir a nova estrutura de diretórios e nomes de classes.
Execute o script de pré-processamento: Use um script Python para reorganizar seu conjunto de dados e atualizar o arquivo .yaml adequadamente.

Aqui está um script de exemplo para organizar seu conjunto de dados:

import os
import shutil

def organize_files(directory):
    for subdir in ["train", "test", "val"]:
        subdir_path = os.path.join(directory, subdir)
        if not os.path.exists(subdir_path):
            continue

        images_dir = os.path.join(subdir_path, "images")
        labels_dir = os.path.join(subdir_path, "labels")

        os.makedirs(images_dir, exist_ok=True)
        os.makedirs(labels_dir, exist_ok=True)

        for filename in os.listdir(subdir_path):
            if filename.endswith(".txt"):
                shutil.move(os.path.join(subdir_path, filename), os.path.join(labels_dir, filename))
            elif filename.endswith((".jpg", ".png", ".jpeg")):
                shutil.move(os.path.join(subdir_path, filename), os.path.join(images_dir, filename))

if __name__ == "__main__":
    directory = f"{work_dir}/trash_ICRA19/dataset"
    organize_files(directory)

Para mais detalhes, consulte nosso guia de pré-processamento de dados.

Quais são os pré-requisitos para treinar um modelo YOLO26 no IBM Watsonx?#

Antes de começar a treinar um modelo YOLO26 no IBM Watsonx, garante que tens os seguintes pré-requisitos:

Conta IBM Cloud: Cria uma conta na IBM Cloud para acederes ao Watsonx.ai.
Conta Kaggle: Para carregares conjuntos de dados, precisarás de uma conta Kaggle e de uma chave de API.
Jupyter Notebook: Configura um ambiente de Jupyter Notebook dentro do Watsonx.ai para programação e treino de modelos.

Para mais informações sobre como configurar o teu ambiente, visita o nosso guia de instalação do Ultralytics.

Colaboradores

GLglenn-jocher¹⁵ RIRizwanMunawar² RAraimbekovm¹ ONonuralpszr¹ AMambitious-octopus¹ MAMatthewNoyce¹ LALaughing-q¹ ABabirami-vina¹

Criado 29 de jul. de 2024Atualizado há 2 semanas