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?

O Watsonx é a plataforma baseada 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 - juntam-se para criar uma plataforma de IA fiável e de ponta a ponta que pode acelerar os projectos de IA destinados a resolver problemas empresariais. Fornece ferramentas poderosas para criar, treinar e implementar modelos de aprendizagem automática e facilita a ligação a várias fontes de dados.

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

O IBM Watsonx é constituído 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 olhadela mais detalhada.

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 .

📅C riado há 4 meses ✏️ Atualizado há 2 meses

Comentários