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

Hoje em dia, 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 IA e dados que simplifica o desenvolvimento, o despliegue 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 do IBM Cloud.

Podes treinar modelos Ultralytics YOLO26 usando o IBM Watsonx. É uma boa opção para empresas interessadas em treinamento de modelos 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 orientar-te no processo de treinamento do YOLO26 com o IBM Watsonx, cobrindo desde a configuração do ambiente até a avaliação dos teus 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 de ponta a ponta que pode acelerar projetos de IA voltados para a resolução de problemas de negócios. Ele fornece ferramentas poderosas para construir, treinar e implantar modelos de aprendizado de máquina e facilita a conexão com várias fontes de dados.

Sua interface amigável e capacidades colaborativas agilizam o processo de desenvolvimento e ajudam no gerenciamento e implantaçã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 IA e do gerenciamento de dados. Vamos dar uma olhada mais de perto 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 próprios modelos Granite da IBM. Ele inclui o Prompt Lab para experimentar prompts de IA, o Tuning Studio 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 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 torna a conformidade mais fácil ao identificar automaticamente mudanças regulatórias e aplicar políticas. Ele vincula requisitos a dados de risco internos e fornece fichas técnicas de IA atualizadas. 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 fáceis de usar e ferramentas de relatórios.

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#

Precisas de uma conta da IBM Cloud para criar um projeto no watsonx.ai, e também precisarás de uma conta do Kaggle para carregar o conjunto de dados.

Passo 1: Configure seu ambiente#

Primeiro, precisarás configurar uma conta da IBM para usar um Jupyter Notebook. Inicia sessão no watsonx.ai usando a tua conta da IBM Cloud.

Em seguida, cria 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.

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

Para instruções detalhadas e melhores práticas relacionadas com o processo de instalação, consulta o nosso guia de instalação do Ultralytics. Ao instalar os pacotes necessários para o YOLO26, se encontrares alguma dificuldade, consulta o nosso guia de problemas comuns para obter soluções e dicas.

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

# 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, cria uma conta gratuita no Kaggle. Assim que tiveres criado uma conta, precisarás gerar uma chave de API. As instruções para gerar a tua chave podem ser encontradas na documentação da API do Kaggle sob a 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.

# Install kaggle
pip install kaggle

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

# 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 virem "trash_ICRA19" entre os conteúdos do diretório, então ele foi carregado com sucesso. Deves ver três arquivos/pastas: um arquivo config.yaml, um diretório videos_for_testing e um diretório dataset. Vamos ignorar o diretório videos_for_testing, por isso podes apagá-lo à vontade.

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

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:

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:

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

# 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

Executa o seguinte script para apagar o conteúdo atual de config.yaml e substituí-lo pela configuração que reflete a nossa nova estrutura de diretórios do conjunto de dados. O script usa automaticamente a variável work_dir que definimos anteriormente, por isso certifica-te de que ela aponta para o teu conjunto de dados antes da execução, e deixa as definições dos subdiretórios train, val e test inalteradas.

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

!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 estás a usar 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 os 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 do modelo e das melhores práticas, consulta o guia de Treinamento de Modelos YOLO26. Este guia ajudar-te-á a tirar o máximo proveito dos teus experimentos e a garantir que estás a usar o YOLO26 de forma eficaz.

Passo 6: Teste o modelo#

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

!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 no nosso conjunto de teste, bem como novos arquivos de imagem de saída que sobrepõem a caixa delimitadora prevista em cima da imagem original.

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 caixas delimitadoras são geradas através do argumento save=True. O parâmetro conf=0.5 informa o modelo para ignorar todas as previsões com um nível de confiança inferior a 50%.

Por fim, iou=.5 orienta o modelo a 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 sobreposições de caixas delimitadoras previstas para ver como o nosso modelo se comporta em algumas imagens.

# 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 revocação do modelo para cada classe. Essas visualizações são salvas no diretório de execução do treinamento ({work_dir}/runs/detect/train/). A pontuação de precisão é exibida no BoxP_curve.png:

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 revocação (BoxR_curve.png) exibe uma tendência inversa:

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 Intersecção sobre União#

Podes medir a precisão da previsão calculando o IoU entre uma caixa delimitadora prevista e uma caixa delimitadora de verdade básica para o mesmo objeto. Consulta o tutorial da IBM sobre como treinar o 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, visita a documentação oficial do IBM Watsonx.

Além disso, certifica-te de conferir a página do guia de integração da Ultralytics para saberes mais sobre diferentes integrações empolgantes.

FAQ#