Exportação Sony IMX500 para Ultralytics YOLO11

Este guia aborda a exportação e implementação de modelos Ultralytics YOLO11 para câmeras Raspberry Pi AI que apresentam o sensor Sony IMX500.

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

O formato de modelo IMX500 foi projetado para usar o mínimo de energia, oferecendo 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 implantação de seus modelos para o formato IMX500, facilitando o bom desempenho de seus modelos na Câmera Raspberry Pi AI.

Por que você deve exportar para IMX500

O Sensor de Visão Inteligente IMX500 da Sony é uma peça de hardware revolucionária no processamento de IA de ponta. É o primeiro sensor de visão inteligente do mundo com recursos de IA no chip. Este sensor ajuda a superar muitos desafios na IA de ponta, incluindo gargalos no processamento de dados, preocupações com a privacidade e limitações de desempenho.
Enquanto outros sensores apenas transmitem imagens e quadros, o IMX500 conta toda uma história. 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 os 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 os aplicativos 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, pois 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 emitir tanto a imagem como os metadados (resultado da inferência) e pode emitir apenas os metadados para minimizar o tamanho dos dados, reduzir a largura de banda e diminuir os custos.
• Aborda Questões de Privacidade: Ao processar dados no dispositivo, o IMX500 aborda questões de privacidade, ideal para aplicações centradas no ser humano, como contagem de pessoas e rastreamento de ocupação.
• Processamento em Tempo Real: O processamento rápido no sensor suporta decisões em tempo real, perfeito para aplicações de IA de ponta, como sistemas autónomos.

Before You Begin: Para melhores resultados, certifique-se de que o seu modelo YOLO11 está bem preparado para exportação, seguindo o nosso Guia de Treino de Modelo, Guia de Preparação de Dados e Guia de Ajuste de Hiperparâmetros.

Tarefas Suportadas

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

• A deteção de objetos
• Estimativa de pose

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")

# Export a YOLO11n PyTorch model to imx format with Post-Training Quantization (PTQ)
yolo export model=yolo11n.pt format=imx data=coco8.yaml

# Run inference with the exported model
yolo predict model=yolo11n_imx_model source='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")

# Export a YOLO11n-pose PyTorch model to imx format with Post-Training Quantization (PTQ)
yolo export model=yolo11n-pose.pt format=imx data=coco8-pose.yaml

# Run inference with the exported model
yolo predict model=yolo11n-pose_imx_model source='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 packerOut.zip ficheiro, que é essencial para empacotar o modelo para implementação no hardware IMX500. Adicionalmente, o <model-name>_imx_model pasta conterá um arquivo de texto (labels.txt) listando todos os rótulos associados ao modelo.

yolo11n_imx_model
├── dnnParams.xml
├── labels.txt
├── packerOut.zip
├── yolo11n_imx.onnx
├── yolo11n_imx_MemoryReport.json
└── yolo11n_imx.pbtxt

yolo11n-pose_imx_model
├── dnnParams.xml
├── labels.txt
├── packerOut.zip
├── yolo11n-pose_imx.onnx
├── yolo11n-pose_imx_MemoryReport.json
└── yolo11n-pose_imx.pbtxt

Usando a Exportação IMX500 na Implantação

Após exportar o modelo Ultralytics YOLO11n para o formato IMX500, ele pode ser implantado na câmera Raspberry Pi AI para inferência.

Pré-requisitos de Hardware

Certifique-se de que tem o seguinte hardware:

1. Raspberry Pi 5 ou Raspberry Pi 4 Modelo B
2. Câmera AI Raspberry Pi

Conecte a câmara Raspberry Pi AI 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 Raspberry Pi para a versão mais recente.

sudo apt update && sudo apt full-upgrade

Passo 2: Instale o firmware IMX500, 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 do módulo de aplicação Aitrios Raspberry Pi

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

Passo 5: Execute a detecção de objetos e estimativa de pose YOLO11 usando os scripts abaixo, que estão disponíveis em exemplos da biblioteca do módulo de aplicação aitrios-rpi.

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()

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_yolo_pose_ultralytics


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

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

    def post_process(self, output_tensors):
        """Post-process the output tensors for pose estimation."""
        return pp_yolo_pose_ultralytics(output_tensors)


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

annotator = Annotator()

with device as stream:
    for frame in stream:
        detections = frame.detections[frame.detections.confidence > 0.4]

        annotator.annotate_keypoints(frame, detections)
        annotator.annotate_boxes(frame, detections, corner_length=20)
        frame.display()

Benchmarks

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

O que há por dentro?

Sony Model Compression Toolkit (MCT)

Model Compression Toolkit (MCT) da Sony é uma ferramenta poderosa para otimizar modelos de aprendizado profundo por meio de quantização e pruning. Ele suporta 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 implantar modelos em dispositivos com recursos limitados, garantindo inferência eficiente e latência reduzida.

Recursos Suportados do MCT

O MCT da Sony oferece uma gama de recursos projetados para otimizar modelos de rede neural:

1. Otimizações de Grafos: Transforma modelos em versões mais eficientes, integrando camadas como normalização em lote nas camadas precedentes.
2. Pesquisa de Parâmetros de Quantização: Minimiza o ruído de quantização usando métricas como Erro Médio Quadrático, Sem Clipping e Erro Médio Absoluto.
3. Algoritmos Avançados de Quantização:
   • Correção de Deslocamento Negativo: Aborda problemas de desempenho da quantização de ativação simétrica.
   • Filtragem de Outliers: Usa z-score para detectar e remover outliers.
   • Clustering: Utiliza grades de quantização não uniformes para melhor correspondência de distribuição.
   • Pesquisa 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 bits.

Quantização

O MCT suporta 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 através das APIs Keras e PyTorch.
   • Complexidade: Baixa
   • Custo Computacional: Baixo (minutos de CPU)
2. Quantização Pós-Treinamento Baseada em Gradiente (GPTQ):
   • Disponível através das APIs Keras e PyTorch.
   • Complexidade: Média
   • Custo Computacional: Moderado (2-3 horas de GPU)
3. Treinamento com Reconhecimento de Quantização (QAT):
   • Complexidade: Alta
   • Custo Computacional: Alto (12-36 horas de GPU)

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

1. Potência de Dois (compatível com hardware)
2. Simétrico
3. Uniforme

Poda Estruturada

O MCT introduz a poda estruturada de modelos, com reconhecimento de hardware, projetada para arquiteturas de hardware específicas. Esta técnica aproveita os recursos Single Instruction, Multiple Data (SIMD) da plataforma de destino, podando grupos SIMD. Isso reduz o tamanho e a complexidade do modelo, otimizando a utilização do canal, alinhado com a arquitetura SIMD para utilização direcionada de recursos da pegada de memória de pesos. Disponível através das APIs Keras e PyTorch.

Ferramenta de Conversão IMX500 (Compiler)

A Ferramenta de Conversão IMX500 é parte integrante do conjunto de ferramentas IMX500, permitindo a compilação de modelos para implantação no sensor IMX500 da Sony (por exemplo, Câmeras Raspberry Pi AI). Esta ferramenta facilita a transição de modelos Ultralytics YOLO11 processados através do software Ultralytics, garantindo que 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, agilizando o processo de implantação na Câmera Raspberry Pi AI.

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:

• Edge AI e IoT: Permite a detecção de objetos em drones ou câmeras de segurança, onde o processamento em tempo real em dispositivos de baixa potência é essencial.
• Dispositivos Vestíveis: Implante modelos otimizados para processamento de IA em pequena escala em dispositivos vestíveis de monitoramento de saúde.
• Cidades Inteligentes: Use modelos YOLO11 exportados pelo IMX500 para monitoramento de tráfego e análise de segurança com processamento mais rápido e latência mínima.
• Análise de Varejo: Melhore o monitoramento na loja implantando modelos otimizados em sistemas de ponto de venda ou prateleiras inteligentes.

Conclusão

Exportar modelos Ultralytics YOLO11 para o formato IMX500 da Sony permite que você implemente seus modelos para inferência eficiente em câmeras baseadas em IMX500. Ao aproveitar as técnicas avançadas de quantização, você pode reduzir o tamanho do modelo e melhorar a velocidade de inferência sem comprometer significativamente a precisão.

Para obter mais informações e diretrizes detalhadas, consulte o site IMX500 da Sony.

FAQ

Como exporto um modelo YOLO11 para o formato IMX500 para a câmera Raspberry Pi AI?

Para exportar um modelo YOLO11 para o formato IMX500, use 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 arquivos necessários para a implantação, incluindo packerOut.zip.

Quais são os principais benefícios de usar o formato IMX500 para implementação de Edge AI?

O formato IMX500 oferece várias vantagens importantes para a implantação de borda:

• O processamento de IA no chip reduz a latência e o consumo de energia
• Produz tanto a imagem quanto os metadados (resultado da inferência) em vez de apenas imagens
• Privacidade aprimorada 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 implementação eficiente de modelos em dispositivos com recursos limitados

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

Para implantar modelos IMX500, você precisará de:

Hardware:

• Raspberry Pi 5 ou Raspberry Pi 4 Modelo B
• Câmera AI Raspberry Pi com sensor IMX500

Software:

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

Qual o desempenho que posso esperar dos modelos YOLO11 no IMX500?

Baseado em benchmarks da Ultralytics na Raspberry Pi AI Camera:

• O YOLO11n atinge um tempo de inferência de 62,50ms por imagem
• mAP50-95 de 0.492 no conjunto de dados COCO128
• Tamanho do modelo de apenas 3,2 MB após a 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 IA de ponta.

📅 Criado há 9 meses ✏️ Atualizado há 6 dias

Comentários