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

Atualmente, soluções de visão computacional escaláveis estão se tornando mais comuns e transformando a forma como lidamos com dados visuais. Um ótimo exemplo é o IBM Watsonx, uma plataforma avançada de dados e IA que simplifica o desenvolvimento, a implementação e a gestão 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 boa 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 fácil de usar. Neste guia, vamos te acompanhar 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 voltados para resolver problemas de negócios. Ela fornece ferramentas poderosas para construir, treinar e implementar modelos de aprendizado de máquina e facilita a conexão com várias fontes de dados.

IBM Watsonx AI platform architecture overview

Sua interface amigável e recursos de colaboração otimizam o processo de desenvolvimento e ajudam na gestão e implementação eficiente 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 dados e IA. Vamos dar uma olhada mais de perto neles.

Watsonx.ai

O Watsonx.ai oferece ferramentas poderosas para o desenvolvimento de IA e acesso a modelos personalizados suportados pela IBM, modelos de terceiros como Llama 3 e os próprios modelos Granite da IBM. Ele 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 várias APIs e bibliotecas.

Watsonx.data

O Watsonx.data suporta implementações tanto em nuvem quanto locais através da integração IBM Storage Fusion HCI. Seu console amigável fornece acesso centralizado aos dados entre ambientes e facilita a exploração de dados 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 em IA e suporta formatos de dados abertos para facilitar o 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 de risco internos e fornece fact sheets de 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 aprimora 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 o fluxo de trabalho de treinamento do seu modelo 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 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 realizar 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 instruções detalhadas e práticas recomendadas relacionadas ao processo de instalação, consulte nosso guia de instalação da 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, vamos treinar de forma personalizada 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. Depois de criar uma 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 do Kaggle e a chave de API 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"))

Após carregar o conjunto de dados, imprimimos 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ê deverá 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 o conteúdo do diretório do conjunto de dados para treinar nosso modelo de detecção de objetos. Aqui está uma imagem de exemplo 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 imagem e rótulo para ajudar nosso modelo a processar a imagem e os rótulos. No momento, nosso diretório de conjunto de dados carregado segue esta estrutura:

Loaded Dataset Directory

Mas, os modelos YOLO por padrão exigem imagens e rótulos separados em subdiretórios dentro da divisão train/val/test. Precisamos reorganizar o diretório na 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") or filename.endswith(".png") or filename.endswith(".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 da classe 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 seguinte script para excluir o conteúdo atual de 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 de subdiretório train, val e test inalteradas.

Edite 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 padrão pré-treinado.

Treine 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: Indica 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: Isso 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 do modelo YOLO26. Este guia o ajudará a tirar o máximo proveito 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 com ajuste fino:

Teste 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 através do argumento save_txt=True e as imagens de saída com sobreposições de caixa delimitadora são geradas através 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 possíveis caixas duplicadas geradas para o mesmo objeto. Podemos carregar as imagens com sobreposições de caixas delimitadoras previstas para ver como nosso modelo funciona 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 recall do modelo para cada classe. Essas visualizações são salvas no diretório inicial, dentro da pasta train. A pontuação de precisão é exibida em P_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 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 (R_curve.png) exibe uma tendência inversa:

Model recall-confidence evaluation curve

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

Passo 8: Calculando a Interseção sobre União

Você pode medir a precisão da previsão calculando o IoU entre uma caixa delimitadora prevista e uma caixa delimitadora de verdade fundamental 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, gestão 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 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 Watsonx.ai. Use um Jupyter Notebook como seu ambiente de codificação.
Instale bibliotecas: Instale 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 dados: Organize seu conjunto de dados na estrutura de diretórios 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 recall.

Para instruções detalhadas, consulte nosso guia de treinamento do modelo YOLO26.

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

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

Watsonx.ai: Fornece ferramentas para 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 uma gestão abrangente do ciclo de vida da IA.
Watsonx.data: Suporta implementações em nuvem e locais, oferecendo acesso centralizado a dados, motores 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 o treinamento do seu modelo com os serviços da IBM Cloud.
Integração: Integre 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 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 classe.
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") or filename.endswith(".png") or filename.endswith(".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, certifique-se de que tens os seguintes pré-requisitos:

IBM Cloud Account: Cria uma conta no IBM Cloud para aceder ao Watsonx.ai.
Kaggle Account: Para carregar conjuntos de dados, precisarás de uma conta Kaggle e de uma API key.
Jupyter Notebook: Configura um ambiente 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 Ultralytics Installation guide.

Contributors

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

Created 29 de jul. de 2024Updated mês passado