Um guia passo-a-passo para treinar modelos YOLOv8 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.

Podes treinar modelosUltralytics YOLOv8 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, vamos orientá-lo no processo de formação do YOLOv8 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 de fácil utilização e 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 características do IBM Watsonx

O IBM Watsonx é composto por três componentes principais: watsonx.ai, watsonx.data e watsonx.governance. Cada componente oferece funcionalidades que se destinam a diferentes aspectos da IA e da gestão de dados. Vamos analisá-los em pormenor.

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 fazer experiências com 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 YOLOv8 utilizando o IBM Watsonx

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

Pré-requisitos

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

Passo 1: Configura o teu ambiente

Primeiro, terás de configurar uma conta IBM para utilizar um Jupyter Notebook. Inicia sessão em watsonx.ai utilizando a tua conta IBM Cloud.

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

Assim que o fizeres, será aberto um ambiente de bloco de notas para que possas carregar o teu conjunto de dados. Podes 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 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 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, consulta o nosso guia de instalaçãoUltralytics . Durante a instalação dos pacotes necessários para YOLOv8, se tiveres alguma dificuldade, consulta o nosso guia de Problemas comuns para obteres soluções e sugestões.

Depois, podes importar os pacotes necessários.

# Import ultralytics
import ultralytics

ultralytics.checks()

# Import packages to retrieve and display image files

Passo 3: Carrega 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 YOLOv8 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, cria uma conta gratuita no Kaggle. Depois de criares uma conta, terás de gerar uma chave de API. As instruções para gerar a tua chave podem ser encontradas na documentação da API do Kaggle na secção "Credenciais da API".

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

Se vires "trash_ICRA19" no conteúdo do diretório, então foi carregado com sucesso. Deves 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, estás à vontade para o apagar.

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

Passo 4: Pré-processa 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 directó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 padrão, os modelos YOLO exigem imagens e rótulos separados em subdiretó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 no 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

Executa 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. Deixa as definições dos subdirectórios train, val e test. Além disso, não alteres {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: Treina o modelo YOLOv8

Executa o seguinte código de linha de comandos para afinar um modelo YOLOv8 predefinido pré-treinado.

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

Vê mais de perto os 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 a finalidade para a qual está a carregar o modelo e os dados especificados. Como estamos a treinar um modelo, define-o como "treinar". Mais tarde, quando testarmos o desempenho do nosso modelo, define-o como "prever".
• epochs: Delimita o número de vezes que YOLOv8 passará por todo o nosso conjunto de dados.
• lote: O valor numérico estipula o tamanho dos lotes de treino. 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 salvar gráficos das métricas de treinamento e avaliação do nosso modelo.

Para uma compreensão detalhada do processo de formação de modelos e das melhores práticas, consulta o guiaYOLOv8 Model Training. Este guia irá ajudar-te a tirar o máximo partido das tuas experiências e a garantir que estás a utilizar o YOLOv8 de forma eficaz.

Passo 6: Testa o modelo

Podemos agora 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 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 argumenta.
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. 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.

Passo 7: Avalia 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 home, 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: Calcular a 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. Consulta o tutorial da IBM sobre formação YOLOv8 para obteres mais informações.

Resumo

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

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

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

FAQ

Como posso treinar um modelo YOLOv8 utilizando o IBM Watsonx?

Para treinar um modelo YOLOv8 utilizando o IBM Watsonx, segue estes passos:

1. Configurar o teu ambiente: Cria uma conta IBM Cloud e configura um projeto Watsonx.ai. Utiliza um Jupyter Notebook para o teu ambiente de codificação.
2. Instalar bibliotecas: Instala as bibliotecas necessárias, como torch, opencve ultralytics.
3. Carrega os dados: Utiliza a API do Kaggle para carregar o teu conjunto de dados no Watsonx.
4. Pré-processa os dados: Organiza o teu conjunto de dados na estrutura de directórios necessária e actualiza o .yaml ficheiro de configuração.
5. Treina o modelo: Utiliza a interface da linha de comandos YOLO para treinar o teu modelo com parâmetros específicos como epochs, batch sizee learning rate.
6. Testa e avalia: Executa a inferência para testar o modelo e avaliar o seu desempenho utilizando métricas como a precisão e a recuperação.

Para obteres instruções detalhadas, consulta o nosso guia de formação de modelosYOLOv8 .

Quais são as principais características do IBM Watsonx para o treino 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 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 e ferramentas de relatórios para colaboração.

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

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

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

• Escalabilidade: Escala facilmente o teu modelo de formação com os serviços IBM Cloud.
• Integração: Integra-se perfeitamente 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: Acede a ferramentas poderosas como o Prompt Lab, o Tuning Studio e o Flows Engine para melhorar o desempenho do modelo.

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

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

Para pré-processar o teu conjunto de dados para YOLOv8 treino no IBM Watsonx:

1. Organiza os directórios: Certifica-te de que o teu conjunto de dados segue a estrutura de directórios YOLO com subdirectórios separados para imagens e etiquetas dentro da divisão train/val/test.
2. Atualizar o ficheiro .yaml: Modifica o .yaml para refletir a nova estrutura de diretórios e nomes de classes.
3. Executa o script de pré-processamento: Utiliza um script Python para reorganizar o teu conjunto de dados e atualizar o .yaml em conformidade.

Aqui está um exemplo de script para organizar o teu 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 informações, consulta o nosso guia de pré-processamento de dados.

Quais são os pré-requisitos para treinar um modelo YOLOv8 no IBM Watsonx?

Antes de iniciar a formação de um modelo YOLOv8 no IBM Watsonx, certifica-te de que tens os seguintes pré-requisitos:

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

Para mais informações sobre como configurar o teu ambiente, visita o nosso guia de instalaçãoUltralytics .

📅 Created 1 month ago ✏️ Updated 11 days ago

Comentários