Um Guia Passo a Passo para Treinar Modelos YOLO11 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 YOLO11 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 orientá-lo através do processo de treinamento de YOLO11 com IBM Watsonx, cobrindo tudo, desde a configuração do seu ambiente até a avaliação de 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

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 fact sheets de IA atualizados. A plataforma ajuda a gerenciar o risco com alertas e ferramentas para detectar problemas como vieses e desvios. 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 melhora a colaboração com painéis e ferramentas de relatórios fáceis de usar.

Como Treinar YOLO11 Usando o IBM Watsonx

Você pode usar o IBM Watsonx para acelerar seu fluxo de trabalho de treinamento do modelo YOLO11.

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 opencv-contrib-python-headless
pip install ultralytics==8.0.196

Para obter instruções detalhadas e melhores práticas relacionadas ao processo de instalação, consulte nosso guia de instalação do Ultralytics. Ao instalar os pacotes necessários para o YOLO11, se você encontrar alguma dificuldade, consulte nosso guia de problemas comuns para obter 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 YOLO11 personalizado 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 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 pelo conteúdo acima que reflete nossa nova estrutura de diretório de conjunto de dados. Certifique-se de substituir a parte work_dir do caminho do diretório raiz na linha 4 pelo seu próprio caminho de diretório de trabalho que recuperamos anteriormente. Deixe as definições de subdiretório train, val e test. Além disso, não altere {work_dir} na linha 23 do código.

# Contents of new config.yaml file
def update_yaml_file(file_path):
    data = {
        "path": "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 YOLO11

Execute o seguinte código de linha de comando para ajustar um modelo YOLO11 padrão pré-treinado.

!yolo task=detect mode=train data={work_dir}/trash_ICRA19/config.yaml model=yolo11n.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: Isso delimita o número de vezes que o YOLO11 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 do modelo YOLO11. Este guia o ajudará a aproveitar ao máximo suas experiências e garantirá que você esteja usando o YOLO11 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 possíveis caixas duplicadas geradas para o mesmo objeto.
Podemos carregar as imagens com as sobreposições de caixas delimitadoras previstas para ver como 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: 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 o treinamento do YOLO11 para obter mais detalhes.

Resumo

Exploramos os principais recursos do IBM Watsonx e como treinar um modelo YOLO11 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 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 posso treinar um modelo YOLO11 usando o IBM Watsonx?

Para treinar um modelo YOLO11 usando o IBM Watsonx, siga estas etapas:

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 obter instruções detalhadas, consulte nosso guia de treinamento do modelo YOLO11.

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 o IBM Watsonx para treinar modelos Ultralytics YOLO11?

O IBM Watsonx é uma excelente escolha para treinar modelos Ultralytics YOLO11 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 o Ultralytics YOLO11 e como treinar modelos usando o IBM Watsonx no nosso guia de integração.

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

Para pré-processar o seu conjunto de dados para o treino de YOLO11 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. Atualize o ficheiro .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 YOLO11 no IBM Watsonx?

Antes de começar a treinar um modelo YOLO11 no IBM Watsonx, certifique-se de que tem 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á 11 meses ✏️ Atualizado há 4 dias

Comentários