Um Guia Passo a Passo para Treinar Modelos YOLO26 com IBM Watsonx

Atualmente, soluções escaláveis de visão computacional 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, a implementação e o gerenciamento de modelos de IA. Ele oferece um conjunto completo para todo o ciclo de vida da IA e integração perfeita com os serviços IBM Cloud.

Você pode treinar modelos Ultralytics YOLO26 usando 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 guiá-lo pelo processo de treinamento do YOLO26 com 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 fins comerciais IA generativa e dados científicos. Os três componentes do IBM Watsonx - watsonx.ai, watsonx.data, e watsonx.governance - se unem para criar uma plataforma de IA completa e confiável, que pode acelerar projetos de IA destinados a resolver problemas de negócios. Ela fornece ferramentas poderosas para construir, treinar e implantação de modelos de aprendizado de máquina e facilita a conexão com várias fontes de dados.

Sua interface amigável e recursos de colaboração 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 Funcionalidades 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

Watsonx.ai oferece ferramentas poderosas para o desenvolvimento de IA e 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 várias APIs e bibliotecas.

Watsonx.data

Watsonx.data suporta implementações tanto na nuvem quanto on-premises através da integração com o IBM Storage Fusion HCI. Seu console amigável fornece acesso centralizado a dados em todos os ambientes e facilita a exploração de dados com SQL comum. Ele otimiza cargas de trabalho com engines de consulta eficientes como Presto e Spark, acelera insights de dados com uma camada semântica alimentada por IA, inclui um banco de dados vetorial para relevância de IA e suporta formatos de dados abertos para fácil compartilhamento de dados de análise e IA.

Watsonx.governance

O Watsonx.governance facilita a conformidade, identificando automaticamente as mudanças regulatórias e aplicando políticas. Ele vincula os requisitos aos dados de risco internos e fornece fichas informativas de IA atualizadas. A plataforma ajuda a gerenciar o risco com alertas e ferramentas para detectar problemas como viés e desvio. Ele também automatiza o monitoramento e a documentação do ciclo de vida da IA, organiza o desenvolvimento da IA com um inventário de modelos e aprimora a colaboração com painéis e ferramentas de relatórios fáceis de usar.

Como Treinar YOLO26 Usando IBM Watsonx

Você pode usar 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 watsonx.ai, e também precisará de uma conta Kaggle para carregar o conjunto de dados.

Passo 1: Configure o 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.

Depois de fazer 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

Em seguida, 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 ao processo de instalação, confira 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 soluções e dicas.

Em seguida, 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, treinaremos um modelo YOLO26 personalizado para detect e classify 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 Kaggle gratuita. 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 "Credenciais da API".

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"))

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 se o conjunto de dados "trash_ICRA19" foi carregado corretamente.

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

Usaremos o config.yaml arquivo e o conteúdo do diretório do conjunto de dados para treinar nosso detecção de objetos modelo. 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 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:

No entanto, 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 na 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") 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)

Em seguida, 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 de 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 substitua-o pela configuração que reflete nossa nova estrutura de diretório de conjunto de dados. O script usa automaticamente o work_dir variável que definimos anteriormente, portanto, certifique-se de que ela aponte para seu conjunto de dados antes da execução e deixe as definições de subdiretório de treino, validação e teste 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 ajustar um modelo YOLO26 padrão pré-treinado.

!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 análise 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: Isto 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. Os 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 do modelo e das melhores práticas, consulte o guia de Treinamento de Modelos YOLO26. Este guia o ajudará a tirar o máximo proveito de seus experimentos e a 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:

!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 save_txt=True argumento e as imagens de saída com sobreposições de caixa delimitadora são geradas através do save=True argumento. 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 fim, iou=.5 direciona o modelo para ignorar caixas na mesma classe com uma sobreposição de 50% ou maior. Ajuda a reduzir potenciais caixas duplicadas geradas para o mesmo objeto. Podemos carregar as imagens com sobreposições de caixa delimitadora previstas para ver como nosso modelo se comporta em um punhado de 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: Avaliar o Modelo

Podemos produzir visualizações da precisão e da revocação do modelo para cada classe. Essas visualizações são salvas no diretório inicial, na pasta de treinamento. A pontuação de precisão é exibida em P_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 (R_curve.png) exibe uma tendência inversa:

Ao contrário da precisão, a revocação se move 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 adequado da compensação na precisão e revocação para modelos de classificação.

Etapa 8: Calculando a Intersecção Sobre a 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 de YOLO26 para mais detalhes.

Resumo

Exploramos os principais recursos do IBM Watsonx e como treinar um modelo YOLO26 usando 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 obter mais detalhes sobre o uso, visite a documentação oficial do IBM Watsonx.

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

FAQ

Como faço para treinar um modelo YOLO26 usando IBM Watsonx?

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

1. Configure seu ambiente: Crie uma conta na IBM Cloud e configure um projeto Watsonx.ai. Use um Jupyter Notebook para seu ambiente de codificação.
2. Instalar bibliotecas: Instale as bibliotecas necessárias, como torch, opencv, e ultralytics.
3. Carregar dados: Use a API Kaggle para carregar seu conjunto de dados no Watsonx.
4. Pré-processar dados: Organize seu conjunto de dados na estrutura de diretório necessária e atualize o .yaml arquivo de configuração.
5. Treinar o Modelo: Use a interface de linha de comando YOLO para treinar seu modelo com parâmetros específicos, como epochs, batch size, e learning rate.
6. Testar e avaliar: 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 modelos YOLO26.

Quais são as principais funcionalidades do IBM Watsonx para o 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 com suporte da IBM e modelos de terceiros, como o Llama 3. Ele inclui o Prompt Lab, o Tuning Studio e o Flows Engine para o gerenciamento abrangente do ciclo de vida da IA.
• Watsonx.data: Suporta implementações em nuvem e on-premises, oferecendo acesso centralizado a dados, mecanismos de consulta eficientes como Presto e Spark, e uma camada semântica alimentada por IA.
• Watsonx.governance: Automatiza a conformidade, gere riscos com alertas e fornece ferramentas para detetar problemas como viés e desvio. Também inclui dashboards e ferramentas de relatório para colaboração.

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

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

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 treino do seu modelo com os serviços 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 Ultralytics YOLO26 e como treinar modelos usando IBM Watsonx em nosso guia de integração.

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

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

1. Organize os Diretórios: Garanta que o seu conjunto de dados segue a estrutura de diretórios YOLO com subdiretórios separados para imagens e rótulos dentro da divisão treino/val/teste.
2. Atualizar Arquivo .yaml: Modifique o .yaml ficheiro de configuração para refletir a nova estrutura de diretórios e nomes de classe.
3. Execute o Script de Pré-processamento: Use um script Python para reorganizar o seu conjunto de dados e atualizar o .yaml ficheiro em conformidade.

Aqui está um script de amostra para organizar o 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 o 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 ter os seguintes pré-requisitos:

• Conta IBM Cloud: Crie uma conta no IBM Cloud para aceder ao Watsonx.ai.
• Conta Kaggle: Para carregar conjuntos de dados, precisará de uma conta Kaggle e uma chave de API.
• Jupyter Notebook: Configure um ambiente Jupyter Notebook dentro do Watsonx.ai para codificação e treino de modelos.

Para mais informações sobre como configurar o seu ambiente, visite o nosso guia de Instalação Ultralytics.

📅 Criado há 1 ano ✏️ Atualizado há 4 dias

Comentários