Um guia passo-a-passo para treinar modelos YOLO11 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 os dados visuais. Um excelente 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 para todo o ciclo de vida da IA e uma integração perfeita com os serviços IBM Cloud.

Pode treinar modelosUltralytics YOLO11 utilizando o IBM Watsonx. É uma boa opção para empresas interessadas em formação eficiente de modelos, afinação para tarefas específicas e melhoria do desempenho do modelo com ferramentas robustas e uma configuração fácil de utilizar. Neste guia, iremos orientá-lo no processo de formação do YOLO11 com o IBM Watsonx, abrangendo tudo, desde a configuração do ambiente até à avaliação dos modelos formados. Vamos começar!

O que é o IBM Watsonx?

Watsonx is IBM's cloud-based platform designed for commercial generative AI and scientific data. IBM Watsonx's three components - watsonx.ai, watsonx.datae watsonx.governance - come together to create an end-to-end, trustworthy AI platform that can accelerate AI projects aimed at solving business problems. It provides powerful tools for building, training, and deploying machine learning models and makes it easy to connect with various data sources.

A sua interface fácil de utilizar e as capacidades de colaboração simplificam o processo de desenvolvimento e ajudam na gestão e implementação eficientes de modelos. Quer 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 caraterísticas do IBM Watsonx

IBM Watsonx is made of three main components: watsonx.ai, watsonx.datae watsonx.governance. Each component offers features that cater to different aspects of AI and data management. Let's take a closer look at them.

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 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 generativas. 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 na nuvem e no local através da integração do IBM Storage Fusion HCI. A sua consola de fácil utilização fornece acesso centralizado aos dados em todos os ambientes e facilita a exploração de dados com SQL comum. Optimiza as cargas de trabalho com motores de consulta eficientes como o Presto e o Spark, acelera as informações dos dados com uma camada semântica alimentada por IA, inclui uma base de dados vetorial para relevância da IA e suporta formatos de dados abertos para uma partilha fácil de dados analíticos e de IA.

Watsonx.governance

O Watsonx.governance facilita a conformidade, identificando automaticamente as alterações regulamentares e aplicando políticas. Associa os requisitos aos dados de risco internos e fornece fichas informativas actualizadas sobre IA. A plataforma ajuda a gerir o risco com alertas e ferramentas para detetar problemas como enviesamento e desvio. Além disso, automatiza a monitorização 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 de controlo e ferramentas de relatórios fáceis de utilizar.

Como treinar YOLO11 utilizando o IBM Watsonx

Pode utilizar o IBM Watsonx para acelerar o fluxo de trabalho de formação do modelo YOLO11 .

Pré-requisitos

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

Passo 1: Configurar o seu ambiente

Primeiro, você precisará configurar uma conta IBM para usar um Jupyter Notebook. Inicie sessão em watsonx.ai utilizando a sua conta IBM Cloud.

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

Assim que o fizer, será aberto um ambiente de notebook para carregar o conjunto de dados. Pode utilizar o código deste tutorial para realizar uma tarefa simples de formação de um modelo de deteção de objectos.

Passo 2: Instalar e importar bibliotecas relevantes

Em seguida, 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 com o processo de instalação, consulte o nosso guia de instalaçãoUltralytics . Ao instalar os pacotes necessários para YOLO11, se encontrar alguma dificuldade, consulte o nosso guia de Problemas comuns para obter soluções e dicas.

Em seguida, pode importar os pacotes necessários.

# Import ultralytics
import ultralytics

ultralytics.checks()

# Import packages to retrieve and display image files

Passo 3: Carregar os dados

Para este tutorial, utilizaremos um conjunto de dados de lixo marinho disponível no Kaggle. Com este conjunto de dados, vamos treinar um modelo YOLO11 para detetar e classificar lixo e objectos biológicos em imagens subaquáticas.

Podemos carregar o conjunto de dados diretamente para o bloco de notas utilizando a API do Kaggle. Primeiro, crie uma conta gratuita do Kaggle. Depois de criar uma conta, você precisará gerar uma chave de API. As instruções para gerar a sua chave podem ser encontradas na documentação da API do Kaggle na secção "Credenciais da API".

Copie e cole o seu nome de utilizador Kaggle e a sua chave API no seguinte código. Em seguida, execute 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 nosso diretório de trabalho para confirmar que o conjunto de dados "trash_ICRA19" foi carregado corretamente.

Se vir "trash_ICRA19" no conteúdo do diretório, então este foi carregado com sucesso. Deverá ver três ficheiros/pastas: a config.yaml ficheiro, um videos_for_testing e um diretório dataset diretório. Ignoraremos o diretório videos_for_testing por isso, sinta-se à vontade para o apagar.

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

Passo 4: Pré-processar os dados

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

Mas, por defeito, os modelos YOLO requerem imagens e etiquetas separadas em subdirectórios dentro da divisão train/val/test. Precisamos de 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 script a seguir para excluir o conteúdo atual de config.yaml e substituí-lo pelo conteúdo acima que reflete nossa nova estrutura de diretório do 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 do diretório de trabalho que recuperamos anteriormente. Deixe as definições dos subdirectórios train, val e test. Além disso, não altere {work_dir} na linha 23 do código.

# Contents of new confg.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: Treinar o modelo YOLO11

Execute o seguinte código de linha de comando para ajustar um modelo YOLO11 predefinido 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

Eis um olhar mais atento aos parâmetros do comando de treino do modelo:

• task: especifica a tarefa de visão por computador para a qual está a utilizar o modelo YOLO e o conjunto de dados especificados.
• modo: Indica o objetivo para o qual está a carregar o modelo e os dados especificados. Uma vez que estamos a treinar um modelo, este é definido como "treinar". Mais tarde, quando testarmos o desempenho do nosso modelo, definimo-lo para "prever".
• epochs: Isto delimita o número de vezes que YOLO11 passará por todo o nosso conjunto de dados.
• lote: O valor numérico estipula o tamanho dos lotes de formação. Os lotes são o 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: Direciona o YOLO para gerar e guardar gráficos das métricas de treino e avaliação do nosso modelo.

Para uma compreensão detalhada do processo de formação de modelos e das melhores práticas, consulte o guiaYOLO11 Model Training. Este guia ajudá-lo-á a tirar o máximo partido das suas experiências e a garantir que está a utilizar YOLO11 de forma eficaz.

Passo 6: Testar o modelo

Podemos agora efetuar 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 etiquetas previstas para cada imagem no nosso conjunto de teste, bem como novos ficheiros de imagem de saída que sobrepõem a caixa delimitadora prevista sobre a imagem original.

As etiquetas .txt previstas para cada imagem são guardadas através da opção save_txt=True e as imagens de saída com sobreposições de caixas delimitadoras são geradas através do argumento save=True argumento.
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 para ignorar caixas da mesma classe com uma sobreposição de 50% ou mais. Isto ajuda a reduzir potenciais caixas duplicadas geradas para o mesmo objeto.
podemos carregar as imagens com sobreposições de caixas delimitadoras previstas para ver o desempenho do nosso modelo numa mão-cheia 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 suas caixas delimitadoras previstas, acompanhadas de etiquetas de nome de classe e níveis de confiança.

Etapa 7: Avaliar o modelo

Podemos produzir visualizações da precisão e da recuperação do modelo para cada classe. Essas visualizações são salvas no diretório inicial, na pasta train. A pontuação de precisão é exibida no arquivo P_curve.png:

O gráfico mostra um aumento exponencial da 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 num determinado nível de confiança após duas épocas.

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

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

Passo 8: Cálculo da intersecção sobre a união

Pode medir a precisão da previsão calculando o IoU entre uma caixa delimitadora prevista e uma caixa delimitadora real para o mesmo objeto. Consulte o tutorial da IBM sobre formação YOLO11 para obter mais informações.

Resumo

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

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

Além disso, não se esqueça de consultar a página do guia de integraçãoUltralytics , para saber mais sobre diferentes integrações interessantes.

FAQ

Como posso treinar um modelo YOLO11 utilizando o IBM Watsonx?

Para treinar um modelo YOLO11 utilizando o IBM Watsonx, siga estes passos:

1. Configurar o seu ambiente: Crie uma conta IBM Cloud e configure um projeto Watsonx.ai. Use um Jupyter Notebook para seu ambiente de codificação.
2. Instalar bibliotecas: Instalar as bibliotecas necessárias como torch, opencve ultralytics.
3. Carregar dados: Utilize a API do Kaggle para carregar o seu conjunto de dados no Watsonx.
4. Pré-processar dados: Organize o seu conjunto de dados na estrutura de diretórios necessária e actualize o .yaml ficheiro de configuração.
5. Treinar o modelo: Utilize a interface de linha de comandos YOLO para treinar o seu modelo com parâmetros específicos como epochs, batch sizee learning rate.
6. Testar e avaliar: Executar a inferência para testar o modelo e avaliar o seu desempenho utilizando métricas como a precisão e a recuperação.

Para obter instruções pormenorizadas, consulte o nosso guia de formação de modelosYOLO11 .

Quais são as principais funcionalidades do IBM Watsonx para a formação de modelos de IA?

O IBM Watsonx oferece várias funcionalidades essenciais para a formação de modelos de IA:

• Watsonx.ai: Fornece ferramentas para o desenvolvimento de IA, incluindo o acesso a modelos personalizados suportados pela IBM e modelos de terceiros, como o Llama 3. Inclui o Prompt Lab, o Tuning Studio e o Flows Engine para uma gestão abrangente do ciclo de vida da IA.
• Watsonx.data: Suporta implantações na nuvem e no local, 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 o risco com alertas e fornece ferramentas para detetar problemas como parcialidade e desvio. Também inclui painéis de controlo e ferramentas de relatórios para colaboração.

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

Por que razão devo utilizar o IBM Watsonx para treinar modelos Ultralytics YOLO11 ?

O IBM Watsonx é uma excelente escolha para a formação de modelos Ultralytics YOLO11 devido ao seu conjunto abrangente de ferramentas que simplificam o ciclo de vida da IA. As principais vantagens incluem:

• Escalabilidade: Escale facilmente o seu modelo de formação com os serviços IBM Cloud.
• Integração: Integração perfeita com várias fontes de dados e APIs.
• Interface de fácil utilização: Simplifica o processo de desenvolvimento com uma interface colaborativa e intuitiva.
• Ferramentas avançadas: Acesso a ferramentas poderosas como o Prompt Lab, o Tuning Studio e o Flows Engine para melhorar o desempenho do modelo.

Saiba mais sobre Ultralytics YOLO11 e como treinar modelos utilizando o IBM Watsonx no nosso guia de integração.

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

Para pré-processar o seu conjunto de dados para YOLO11 formação no IBM Watsonx:

1. Organizar diretórios: Certifique-se de que o seu conjunto de dados segue a estrutura de diretórios YOLO com subdirectórios separados para imagens e etiquetas dentro da divisão train/val/test.
2. Atualizar o ficheiro .yaml: Modificar o .yaml para refletir a nova estrutura de diretórios e nomes de classes.
3. Executar o script de pré-processamento: Utilize um script Python para reorganizar o seu conjunto de dados e atualizar o .yaml em conformidade.

Aqui está um exemplo de script 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 pormenores, 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 iniciar a formação de um modelo YOLO11 no IBM Watsonx, certifique-se de que possui os seguintes pré-requisitos:

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

Para obter mais informações sobre como configurar o seu ambiente, visite o nosso guia de instalaçãoUltralytics .

📅 Created 5 months ago ✏️ Updated 11 days ago

Comentários