Exportação IMX500 para Ultralytics YOLO11

Este guia aborda a exportação e implementação de modelos Ultralytics YOLO11 para Raspberry Pi AI Cameras que possuem o sensor Sony IMX500.

Implementar modelos de visão computacional em dispositivos com poder computacional limitado, como a Raspberry Pi AI Camera, pode ser um desafio. Usar um formato de modelo otimizado para um desempenho mais rápido faz uma enorme diferença.

O formato de modelo IMX500 foi projetado para usar o mínimo de energia enquanto oferece um desempenho rápido para redes neurais. Ele permite que você otimize seus modelos Ultralytics YOLO11 para inferência de alta velocidade e baixo consumo de energia. Neste guia, vamos orientá-lo na exportação e implementação dos seus modelos para o formato IMX500, facilitando o bom desempenho dos seus modelos na Raspberry Pi AI Camera.

Por que você deveria exportar para IMX500?

O Sensor de Visão Inteligente IMX500 da Sony é uma peça de hardware revolucionária no processamento de IA de borda (edge AI). É o primeiro sensor de visão inteligente do mundo com recursos de IA integrados ao chip. Este sensor ajuda a superar muitos desafios em IA de borda, incluindo gargalos de processamento de dados, preocupações com privacidade e limitações de desempenho. Enquanto outros sensores apenas transmitem imagens e quadros, o IMX500 conta uma história completa. Ele processa dados diretamente no sensor, permitindo que os dispositivos gerem insights em tempo real.

Exportação IMX500 da Sony para modelos YOLO11

O IMX500 foi projetado para transformar a forma como os dispositivos lidam com dados diretamente no sensor, sem a necessidade de enviá-los para a nuvem para processamento.

O IMX500 funciona com modelos quantizados. A quantização torna os modelos menores e mais rápidos sem perder muita precisão. É ideal para os recursos limitados da computação de borda, permitindo que as aplicações respondam rapidamente reduzindo a latência e permitindo o processamento rápido de dados localmente, sem dependência da nuvem. O processamento local também mantém os dados do usuário privados e seguros, já que não são enviados para um servidor remoto.

Principais características do IMX500:

• Saída de Metadados: Em vez de transmitir apenas imagens, o IMX500 pode produzir tanto a imagem quanto os metadados (resultado da inferência), e pode produzir apenas metadados para minimizar o tamanho dos dados, reduzir a largura de banda e diminuir os custos.
• Aborda preocupações com privacidade: Ao processar dados no próprio dispositivo, o IMX500 resolve preocupações com privacidade, sendo ideal para aplicações centradas em humanos, como contagem de pessoas e rastreamento de ocupação.
• Processamento em tempo real: O processamento rápido e no sensor oferece suporte a decisões em tempo real, perfeito para aplicações de IA de borda, como sistemas autônomos.

Antes de começar: Para obter melhores resultados, certifique-se de que seu modelo YOLO11 esteja bem preparado para exportação seguindo nosso Guia de Treinamento de Modelos, Guia de Preparação de Dados e Guia de Ajuste de Hiperparâmetros.

Tarefas Suportadas

Atualmente, você só pode exportar modelos que incluam as seguintes tarefas para o formato IMX500.

• Object Detection
• Estimativa de Pose
• Classification
• Segmentação de instância

Exemplos de Uso

Exporte um modelo Ultralytics YOLO11 para o formato IMX500 e execute a inferência com o modelo exportado.

 from ultralytics import YOLO

 # Load a YOLO11n PyTorch model
 model = YOLO("yolo11n.pt")

 # Export the model
 model.export(format="imx", data="coco8.yaml")  # exports with PTQ quantization by default

 # Load the exported model
 imx_model = YOLO("yolo11n_imx_model")

 # Run inference
 results = imx_model("https://ultralytics.com/images/bus.jpg")

 from ultralytics import YOLO

 # Load a YOLO11n-pose PyTorch model
 model = YOLO("yolo11n-pose.pt")

 # Export the model
 model.export(format="imx", data="coco8-pose.yaml")  # exports with PTQ quantization by default

 # Load the exported model
 imx_model = YOLO("yolo11n-pose_imx_model")

 # Run inference
 results = imx_model("https://ultralytics.com/images/bus.jpg")

 from ultralytics import YOLO

 # Load a YOLO11n-cls PyTorch model
 model = YOLO("yolo11n-cls.pt")

 # Export the model
 model.export(format="imx", data="imagenet10")  # exports with PTQ quantization by default

 # Load the exported model
 imx_model = YOLO("yolo11n-cls_imx_model")

 # Run inference
 results = imx_model("https://ultralytics.com/images/bus.jpg", imgsz=224)

 from ultralytics import YOLO

 # Load a YOLO11n-seg PyTorch model
 model = YOLO("yolo11n-seg.pt")

 # Export the model
 model.export(format="imx", data="coco8-seg.yaml")  # exports with PTQ quantization by default

 # Load the exported model
 imx_model = YOLO("yolo11n-seg_imx_model")

 # Run inference
 results = imx_model("https://ultralytics.com/images/bus.jpg")

Argumentos de Exportação

Para mais detalhes sobre o processo de exportação, visite a página de documentação da Ultralytics sobre exportação.

O processo de exportação criará um modelo ONNX para validação de quantização, juntamente com um diretório chamado <model-name>_imx_model. Este diretório incluirá o arquivo packerOut.zip, que é essencial para empacotar o modelo para implementação no hardware IMX500. Além disso, a pasta <model-name>_imx_model conterá um arquivo de texto (labels.txt) listando todos os rótulos associados ao modelo.

yolo11n_imx_model
├── dnnParams.xml
├── labels.txt
├── packerOut.zip
├── model_imx.onnx
├── model_imx_MemoryReport.json
└── model_imx.pbtxt

Usando a exportação IMX500 na implementação

Após exportar o modelo Ultralytics YOLO11n para o formato IMX500, ele pode ser implementado na Raspberry Pi AI Camera para inferência.

Pré-requisitos de hardware

Certifique-se de ter o hardware abaixo:

1. Raspberry Pi 5 ou Raspberry Pi 4 Model B
2. Raspberry Pi AI Camera

Conecte a Raspberry Pi AI Camera ao conector MIPI CSI de 15 pinos no Raspberry Pi e ligue o Raspberry Pi.

Pré-requisitos de software

Passo 1: Abra uma janela de terminal e execute os seguintes comandos para atualizar o software do Raspberry Pi para a versão mais recente.

sudo apt update && sudo apt full-upgrade

Passo 2: Instale o firmware do IMX500, que é necessário para operar o sensor IMX500.

sudo apt install imx500-all

Passo 3: Reinicie o Raspberry Pi para que as alterações entrem em vigor.

sudo reboot

Passo 4: Instale a biblioteca de módulos de aplicação Aitrios para Raspberry Pi.

pip install git+https://github.com/SonySemiconductorSolutions/aitrios-rpi-application-module-library.git

Passo 5: Execute a detecção de objetos, estimativa de pose, classificação e segmentação do YOLO11 usando os scripts abaixo, que estão disponíveis nos exemplos da aitrios-rpi-application-module-library.

import numpy as np
from modlib.apps import Annotator
from modlib.devices import AiCamera
from modlib.models import COLOR_FORMAT, MODEL_TYPE, Model
from modlib.models.post_processors import pp_od_yolo_ultralytics

class YOLO(Model):
    """YOLO model for IMX500 deployment."""

    def __init__(self):
        """Initialize the YOLO model for IMX500 deployment."""
        super().__init__(
            model_file="yolo11n_imx_model/packerOut.zip",  # replace with proper directory
            model_type=MODEL_TYPE.CONVERTED,
            color_format=COLOR_FORMAT.RGB,
            preserve_aspect_ratio=False,
        )

        self.labels = np.genfromtxt(
            "yolo11n_imx_model/labels.txt",  # replace with proper directory
            dtype=str,
            delimiter="\n",
        )

    def post_process(self, output_tensors):
        """Post-process the output tensors for object detection."""
        return pp_od_yolo_ultralytics(output_tensors)

device = AiCamera(frame_rate=16)  # Optimal frame rate for maximum DPS of the YOLO model running on the AI Camera
model = YOLO()
device.deploy(model)

annotator = Annotator()

with device as stream:
    for frame in stream:
        detections = frame.detections[frame.detections.confidence > 0.55]
        labels = [f"{model.labels[class_id]}: {score:0.2f}" for _, score, class_id, _ in detections]

        annotator.annotate_boxes(frame, detections, labels=labels, alpha=0.3, corner_radius=10)
        frame.display()

Benchmarks

Os benchmarks de YOLOv8n, YOLO11n, YOLOv8n-pose, YOLO11n-pose, YOLOv8n-cls e YOLO11n-cls abaixo foram executados pela equipe da Ultralytics na Raspberry Pi AI Camera com o formato de modelo imx, medindo velocidade e precisão.

O que acontece nos bastidores?

Sony Model Compression Toolkit (MCT)

O Sony Model Compression Toolkit (MCT) é uma ferramenta poderosa para otimizar modelos de aprendizado profundo por meio de quantização e poda. Ele oferece suporte a vários métodos de quantização e fornece algoritmos avançados para reduzir o tamanho do modelo e a complexidade computacional sem sacrificar significativamente a precisão. O MCT é particularmente útil para implementar modelos em dispositivos com recursos limitados, garantindo uma inferência eficiente e latência reduzida.

Recursos suportados pelo MCT

O MCT da Sony oferece uma variedade de recursos projetados para otimizar modelos de redes neurais:

1. Otimizações de Grafo: Transforma modelos em versões mais eficientes, integrando camadas como normalização em lote (batch normalization) em camadas anteriores.
2. Busca de Parâmetros de Quantização: Minimiza o ruído de quantização usando métricas como Erro Médio Quadrático, Sem Recorte (No-Clipping) e Erro Médio Absoluto.
3. Algoritmos de Quantização Avançados:
   • Correção de Deslocamento Negativo: Aborda problemas de desempenho decorrentes da quantização de ativação simétrica.
   • Filtragem de Outliers: Usa pontuação z (z-score) para detectar e remover outliers.
   • Clustering: Utiliza grades de quantização não uniformes para melhor correspondência de distribuição.
   • Busca de Precisão Mista: Atribui diferentes larguras de bits de quantização por camada com base na sensibilidade.
4. Visualização: Use o TensorBoard para observar insights de desempenho do modelo, fases de quantização e configurações de largura de bit.

Quantização

O MCT oferece suporte a vários métodos de quantização para reduzir o tamanho do modelo e melhorar a velocidade de inferência:

1. Quantização Pós-Treinamento (PTQ):
   • Disponível via APIs Keras e PyTorch.
   • Complexidade: Baixa
   • Custo Computacional: Baixo (minutos de CPU)
2. Quantização Pós-Treinamento baseada em gradiente (GPTQ):
   • Disponível via APIs Keras e PyTorch.
   • Complexidade: Média
   • Custo Computacional: Moderado (2-3 horas de GPU)
3. Treinamento com Consciência de Quantização (QAT):
   • Complexidade: Alta
   • Custo Computacional: Alto (12-36 horas de GPU)

O MCT também oferece suporte a vários esquemas de quantização para pesos e ativações:

1. Potência de dois (amigável ao hardware)
2. Simétrico
3. Uniforme

Poda Estruturada

O MCT introduz a poda de modelos estruturada e consciente do hardware, projetada para arquiteturas de hardware específicas. Essa técnica aproveita os recursos de SIMD (Single Instruction, Multiple Data) da plataforma de destino, podando grupos SIMD. Isso reduz o tamanho e a complexidade do modelo enquanto otimiza a utilização de canais, alinhada com a arquitetura SIMD para utilização direcionada de recursos da pegada de memória de pesos. Disponível via APIs Keras e PyTorch.

Ferramenta Conversora IMX500 (Compilador)

A Ferramenta Conversora IMX500 é parte integrante do conjunto de ferramentas IMX500, permitindo a compilação de modelos para implementação no sensor IMX500 da Sony (por exemplo, Raspberry Pi AI Cameras). Esta ferramenta facilita a transição de modelos Ultralytics YOLO11 processados pelo software Ultralytics, garantindo que eles sejam compatíveis e tenham um desempenho eficiente no hardware especificado. O procedimento de exportação após a quantização do modelo envolve a geração de arquivos binários que encapsulam dados essenciais e configurações específicas do dispositivo, simplificando o processo de implementação na Raspberry Pi AI Camera.

Casos de Uso no Mundo Real

A exportação para o formato IMX500 tem ampla aplicabilidade em vários setores. Aqui estão alguns exemplos:

• IA de Borda e IoT: Permita a detecção de objetos em drones ou câmeras de segurança, onde o processamento em tempo real em dispositivos de baixo consumo de energia é essencial.
• Dispositivos Vestíveis: Implemente modelos otimizados para processamento de IA em pequena escala em dispositivos vestíveis de monitoramento de saúde.
• Cidades Inteligentes: Usa modelos YOLO11 exportados para IMX500 para monitorização de tráfego e análise de segurança com processamento mais rápido e latência mínima.
• Análise de Retalho: Melhora a monitorização na loja ao implementar modelos otimizados em sistemas de ponto de venda ou prateleiras inteligentes.

Conclusão

Exportar modelos Ultralytics YOLO11 para o formato IMX500 da Sony permite-te implementar os teus modelos para inferência eficiente em câmaras baseadas em IMX500. Ao aproveitar técnicas avançadas de quantização, podes reduzir o tamanho do modelo e melhorar a velocidade de inferência sem comprometer significativamente a precisão.

Para mais informações e orientações detalhadas, consulta o site IMX500 da Sony.

FAQ

Como exporto um modelo YOLO11 para o formato IMX500 para a Raspberry Pi AI Camera?

Para exportar um modelo YOLO11 para o formato IMX500, usa a API Python ou o comando CLI:

from ultralytics import YOLO

model = YOLO("yolo11n.pt")
model.export(format="imx")  # Exports with PTQ quantization by default

O processo de exportação criará um diretório contendo os ficheiros necessários para a implementação, incluindo packerOut.zip.

Quais são os principais benefícios de usar o formato IMX500 para implementação de IA na periferia (edge AI)?

O formato IMX500 oferece várias vantagens importantes para a implementação na periferia:

• O processamento de IA no chip reduz a latência e o consumo de energia
• Produz tanto imagem quanto metadados (resultado da inferência) em vez de apenas imagens
• Privacidade reforçada ao processar dados localmente sem dependência da nuvem
• Capacidades de processamento em tempo real ideais para aplicações sensíveis ao tempo
• Quantização otimizada para uma implementação eficiente do modelo em dispositivos com recursos limitados

Quais os pré-requisitos de hardware e software necessários para a implementação IMX500?

Para implementar modelos IMX500, precisarás de:

Hardware:

• Raspberry Pi 5 ou Raspberry Pi 4 Model B
• Raspberry Pi AI Camera com sensor IMX500

Software:

• Raspberry Pi OS Bookworm
• Firmware e ferramentas IMX500 (sudo apt install imx500-all)

Que desempenho posso esperar dos modelos YOLO11 no IMX500?

Com base nos benchmarks da Ultralytics na Raspberry Pi AI Camera:

• O YOLO11n alcança 62,50ms de tempo de inferência por imagem
• mAP50-95 de 0,492 no dataset COCO128
• Tamanho do modelo de apenas 3,2MB após quantização

Isto demonstra que o formato IMX500 proporciona uma inferência eficiente em tempo real, mantendo uma boa precisão para aplicações de edge AI.