Um 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 implementação e a gestão de modelos de IA. Oferece um conjunto completo de ferramentas para todo o ciclo de vida da IA e uma 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 num treino de modelos eficiente, no ajuste fino para tarefas específicas e na melhoria do 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 baseada na cloud 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 — juntam-se para criar uma plataforma de IA completa e fiável, capaz de acelerar projetos de IA destinados a resolver problemas empresariais. Fornece ferramentas poderosas para criar, treinar e implementar modelos de machine learning, facilitando a ligação a várias fontes de dados.

A sua interface intuitiva e as capacidades de colaboração simplificam o processo de desenvolvimento e ajudam a gerir e implementar 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 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 funcionalidades destinadas a diferentes aspetos da IA e da gestão de dados. Vejamos cada um deles com mais atenção.

Watsonx.ai#

O Watsonx.ai fornece ferramentas poderosas para o desenvolvimento de IA e oferece acesso a modelos personalizados suportados pela IBM, a modelos de terceiros como o Llama 3 e aos modelos Granite da própria IBM. Inclui o Prompt Lab para experimentar prompts de IA, o Tuning Studio para melhorar o desempenho dos modelos com dados etiquetados 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 estabelecer ligação a várias APIs e bibliotecas.

Watsonx.data#

O Watsonx.data suporta implementações na cloud e no local através da integração com o IBM Storage Fusion HCI. A sua consola intuitiva fornece acesso centralizado aos dados em diferentes ambientes e facilita a exploração de dados com SQL comum. Otimiza as cargas de trabalho com motores de consulta eficientes, como o Presto e o Spark, acelera a obtenção de insights sobre os dados com uma camada semântica baseada em IA, inclui uma base de dados vetorial para relevância em IA e suporta 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 regulamentares e aplicar políticas. Liga os requisitos aos dados internos de risco e fornece fichas técnicas de IA atualizadas. A plataforma ajuda a gerir o risco com alertas e ferramentas para detetar problemas como enviesamento 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 dashboards intuitivos e ferramentas de geração de relatórios.

Como treinar o YOLO26 usando o IBM Watsonx#

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

Pré-requisitos#

Precisas de uma conta IBM Cloud para criar um projeto watsonx.ai e também precisarás 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 usando 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 com o processo de instalação, consulte o nosso guia de instalação do Ultralytics. Ao instalar os pacotes necessários para YOLO26, se encontrar alguma dificuldade, consulte o nosso guia de problemas comuns para obter 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 para o notebook usando a API do Kaggle. Primeiro, cria uma conta Kaggle gratuita. Depois de criares a conta, terás de gerar uma chave de API. Podes encontrar as instruções para gerar a tua 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 de 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 nosso 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. Deverás 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. Eis uma imagem de exemplo do nosso conjunto de dados de lixo marinho.

Passo 4: Pré-processa os dados#

Felizmente, todas as etiquetas do conjunto de dados de lixo marinho já estão formatadas como ficheiros .txt do YOLO. No entanto, precisamos de reorganizar a estrutura dos diretórios de imagens e etiquetas para ajudar o nosso modelo a processar as imagens e as etiquetas. Atualmente, o diretório do conjunto de dados carregado segue esta estrutura:

No entanto, por predefinição, os modelos YOLO requerem imagens e etiquetas separadas em subdiretórios dentro da divisão train/val/test. Temos de reorganizar o diretório com 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, precisamos de modificar o ficheiro .yaml do conjunto de dados. Esta é a configuração que vamos usar no nosso ficheiro .yaml. Os números dos IDs 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 script seguinte para eliminar o conteúdo atual de config.yaml e substituí-lo pela configuração que representa 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 ela 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 código de linha de comandos seguinte para ajustar um modelo YOLO26 pretreinado predefinido.

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

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

• detect: A tarefa de computer vision para a qual estás a usar o modelo YOLO especificado e o conjunto de dados.
• train: O modo que indica o propósito para o qual estás a carregar o modelo especificado e os dados. Mais tarde, quando testarmos o desempenho do modelo, usaremos predict.
• epochs: Define o número de vezes que o YOLO26 percorrerá todo o nosso conjunto de dados.
• batch: O valor numérico especifica os tamanhos dos batches de treino. Os batches correspondem ao número de imagens que um modelo processa antes de atualizar os seus parâmetros.
• lr0: Especifica a taxa de aprendizagem inicial do modelo.
• plots: Indica ao YOLO que deve gerar e guardar gráficos das métricas de treino e avaliação do nosso modelo.

Para compreenderes em detalhe o processo de treino de modelos e as melhores práticas, consulta o guia de treino de modelos YOLO26. Este guia ajudar-te-á a tirar o máximo partido das tuas experiências e a garantir que estás a usar o YOLO26 de forma eficaz.

Passo 6: Testa 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 etiquetas previstas para cada imagem do nosso conjunto de teste, bem como novos ficheiros de imagem de saída que sobrepõem a caixa delimitadora prevista à imagem original.

As etiquetas .txt previstas para cada imagem são guardadas através 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 de que deve ignorar todas as previsões com um nível de confiança inferior a 50%.

Por último, iou=.5 indica ao modelo que deve ignorar caixas da mesma classe com uma sobreposição igual ou superior a 50%. Isto 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 num conjunto 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 apresenta dez imagens do conjunto de teste com as respetivas caixas delimitadoras previstas, acompanhadas por etiquetas com os nomes das classes e níveis de confiança.

Passo 7: Avalia o modelo#

Podemos gerar 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 é apresentada em BoxP_curve.png:

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

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

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

Passo 8: Calcula a Interseção sobre a União#

Podes medir a exatidão das previsões calculando o IoU entre uma caixa delimitadora prevista e uma caixa delimitadora de verdade fundamental para o mesmo objeto. Consulta o tutorial da IBM sobre o treino do YOLO26 para obteres mais detalhes.

Resumo#

Explorámos as principais funcionalidades do IBM Watsonx e a forma de treinar um modelo YOLO26 usando o IBM Watsonx. Também vimos como o IBM Watsonx pode melhorar os teus fluxos de trabalho de IA com ferramentas avançadas para criação de modelos, gestão de dados e conformidade.

Para obteres mais detalhes sobre a utilização, visita a documentação oficial do IBM Watsonx.

Consulta também a página do guia de integrações da Ultralytics para saberes mais sobre outras integrações interessantes.

Perguntas frequentes#