Guia passo a passo para treinar modelos YOLO26 com o IBM Watsonx#

Atualmente, as soluções de visão computacional escaláveis estão a tornar-se mais comuns e a transformar 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 implantação e a gestão de modelos de IA. Oferece um conjunto completo para todo o ciclo de vida da IA e integração perfeita com os serviços IBM Cloud.

Podes treinar modelos Ultralytics YOLO26 usando o IBM Watsonx. É uma boa opção para empresas interessadas em treinar modelos de forma eficiente, ajustá-los para tarefas específicas e melhorar o desempenho dos modelos com ferramentas robustas e uma configuração intuitiva. Neste guia, vamos mostrar-te o processo de treino do YOLO26 com o IBM Watsonx, desde a configuração do ambiente até à avaliação dos modelos treinados. Vamos começar!

O que é o IBM Watsonx?#

O Watsonx é a plataforma na nuvem da IBM, concebida para IA generativa comercial e dados científicos. Os três componentes do IBM Watsonx — watsonx.ai, watsonx.data e watsonx.governance — combinam-se para criar uma plataforma de IA fiável e completa, capaz de acelerar projetos de IA destinados a resolver problemas empresariais. Disponibiliza ferramentas poderosas para criar, treinar e implantar modelos de aprendizagem automática e facilita a ligação a várias fontes de dados.

A interface intuitiva e os recursos de colaboração simplificam o processo de desenvolvimento e ajudam a gerir e implantar modelos de forma eficiente. Seja para visão computacional, análise preditiva, processamento de linguagem natural ou outras aplicações de IA, o IBM Watsonx disponibiliza 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 funcionalidades para diferentes áreas de IA e gestão de dados. Vejamos cada um em mais detalhe.

Watsonx.ai#

O Watsonx.ai disponibiliza ferramentas poderosas para o desenvolvimento de IA e dá acesso a modelos personalizados com suporte da IBM, a modelos de terceiros como o Llama 3 e aos próprios modelos Granite da IBM. Inclui o Prompt Lab para experimentar prompts de IA, o Tuning Studio para melhorar o desempenho dos modelos com dados rotulados e o Flows Engine para simplificar o desenvolvimento de aplicações de IA generativa. Também oferece ferramentas abrangentes para automatizar o ciclo de vida dos modelos de IA e ligar-se a várias APIs e bibliotecas.

Watsonx.data#

O Watsonx.data é compatível com implantações na nuvem e locais através da integração com o IBM Storage Fusion HCI. A consola intuitiva oferece acesso centralizado aos dados em diferentes ambientes e facilita a exploração de dados com SQL comum. Otimiza cargas de trabalho com motores de consulta eficientes, como Presto e Spark, acelera a obtenção de informações a partir dos dados com uma camada semântica baseada em IA, inclui uma base de dados vetorial para relevância em IA e é compatível com formatos de dados abertos para facilitar a partilha de dados analíticos e de IA.

Watsonx.governance#

O Watsonx.governance facilita a conformidade ao identificar automaticamente alterações regulatórias e aplicar políticas. Liga requisitos a dados internos de risco e fornece fichas técnicas de IA atualizadas. A plataforma ajuda a gerir riscos com alertas e ferramentas para detetar problemas como viés e deriva. Também automatiza a monitorização 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órios intuitivos.

Como treinar o YOLO26 com o IBM Watsonx#

Podes usar o IBM Watsonx para acelerar o fluxo de trabalho de treino do teu modelo YOLO26.

Pré-requisitos#

Precisas de uma conta IBM Cloud para criar um projeto watsonx.ai e também de uma conta Kaggle para carregar o conjunto de dados.

Passo 1: configura o teu ambiente#

Primeiro, tens de configurar uma conta IBM para usar um Jupyter Notebook. Inicia sessão no watsonx.ai com a tua conta IBM Cloud.

Em seguida, cria um projeto watsonx.ai e um Jupyter Notebook.

Depois disso, será aberto um ambiente de notebook para carregares o teu conjunto de dados. Podes usar o código deste tutorial para realizar uma tarefa simples de treino de um modelo de deteção de objetos.

Passo 2: instala e importa as bibliotecas relevantes#

Em seguida, podes instalar e importar as bibliotecas Python necessárias.

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

Para obter instruções detalhadas e boas práticas relacionadas ao processo de instalação, consulte nosso guia de instalação da Ultralytics. Se tiver dificuldades ao instalar os pacotes necessários para YOLO26, consulte nosso guia de problemas comuns para ver soluções e dicas.

Depois, podes importar os pacotes necessários.

import ultralytics

ultralytics.checks()

Passo 3: carrega os dados#

Neste tutorial, vamos usar um conjunto de dados de lixo marinho disponível no Kaggle. Com este conjunto de dados, vamos treinar um modelo YOLO26 personalizado para detetar 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. Depois de criares a conta, terás de gerar uma chave API. Encontras as instruções para gerar a chave na documentação da API do Kaggle, na secção "API credentials".

Copia e cola o teu nome de utilizador do Kaggle e a chave API no código seguinte. Depois, executa o código para instalar a API e carregar o conjunto de dados no Watsonx.

# Install kaggle
pip install kaggle

Depois de 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, imprimimos e guardámos o diretório de trabalho. Também imprimimos o conteúdo do diretório de trabalho para confirmar que o conjunto de dados "trash_ICRA19" foi carregado corretamente.

Se vires "trash_ICRA19" entre os conteúdos do diretório, significa que foi carregado com sucesso. Deves ver três ficheiros/pastas: um ficheiro config.yaml, um diretório videos_for_testing e um diretório dataset. Vamos ignorar o diretório videos_for_testing, por isso podes eliminá-lo.

Vamos usar o ficheiro config.yaml e o conteúdo do diretório do conjunto de dados para treinar o nosso modelo de deteção de objetos. Aqui está uma imagem de exemplo do nosso conjunto de dados de lixo marinho.

Passo 4: pré-processa os dados#

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

No entanto, por padrão, os modelos YOLO exigem imagens e rótulos separados em subdiretórios dentro das divisões train/val/test. Temos de reorganizar o diretório para que tenha 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)

Em seguida, temos de modificar o ficheiro .yaml do conjunto de dados. Esta é a configuração que usaremos no ficheiro .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 eliminar o conteúdo atual de config.yaml e substituí-lo pela configuração que reflete a nova estrutura de diretórios do conjunto de dados. O script usa automaticamente a variável work_dir que definimos anteriormente, por isso confirma que aponta para o teu conjunto de dados antes da execução e mantém inalteradas as definições dos subdiretórios train, val e test.

# 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: treina o modelo YOLO26#

Executa o seguinte código de linha de comandos para ajustar um modelo YOLO26 padrão pré-treinado.

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

Vejamos mais de perto os parâmetros do comando de treino do modelo:

• detect: a tarefa de visão computacional para a qual estás a usar o modelo YOLO e o conjunto de dados especificados.
• train: o modo, que indica a finalidade para a qual estás a carregar o modelo e os dados especificados. Mais tarde, quando testarmos o desempenho do nosso modelo, usaremos predict.
• epochs: define o número de vezes que o YOLO26 percorrerá todo o conjunto de dados.
• batch: O valor numérico especifica os tamanhos dos lotes de treinamento. Os lotes correspondem ao número de imagens que um modelo processa antes de atualizar os parâmetros.
• plots: Instrui o YOLO a gerar e salvar gráficos das métricas de treinamento e avaliação do nosso modelo.

Para entender detalhadamente o processo de treinamento do modelo e conhecer as práticas recomendadas, consulte o guia de treinamento de modelos YOLO26. Este guia vai ajudar você a aproveitar ao máximo seus experimentos e garantir o uso eficaz do YOLO26.

Etapa 6: testar o modelo#

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

!yolo detect 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 do conjunto de teste, além de novos arquivos de imagem de saída que sobrepõem a caixa delimitadora prevista à 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 caixas delimitadoras são geradas pelo argumento save=True. O parâmetro conf=0.5 instrui o modelo a ignorar todas as previsões com nível de confiança inferior a 50%.

Por fim, iou=.5 instrui o modelo a ignorar caixas da mesma classe com sobreposição igual ou superior a 50%. Isso ajuda a reduzir possíveis caixas duplicadas geradas para o mesmo objeto. Podemos carregar as imagens com sobreposições das caixas delimitadoras previstas para ver o desempenho do nosso modelo 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 as caixas delimitadoras previstas, acompanhadas de rótulos com os nomes das classes e níveis de confiança.

Etapa 7: avaliar o modelo#

Podemos gerar visualizações da precisão e da revocação do modelo para cada classe. Essas visualizações são salvas no diretório da execução de treinamento ({work_dir}/runs/detect/train/). A pontuação de precisão é exibida em BoxP_curve.png:

O gráfico mostra um aumento exponencial da precisão à medida que o nível de confiança das previsões do modelo aumenta. No entanto, a precisão do modelo ainda não se estabilizou em 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 segue na direção oposta, apresentando valores maiores para instâncias com menor confiança e valores menores para instâncias com maior confiança. Este é um exemplo adequado do equilíbrio entre precisão e revocação em modelos de classificação.

Etapa 8: calcular a interseção sobre união#

Você pode medir a acurácia da previsão calculando o IoU entre uma caixa delimitadora prevista e uma caixa delimitadora de referência do mesmo objeto. Confira o tutorial da IBM sobre o treinamento do YOLO26 para saber mais.

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 criação de modelos, gerenciamento de dados e conformidade.

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

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

Perguntas frequentes#