Exportação Sony IMX500 para Ultralytics YOLO11#

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

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

O formato de modelo IMX500 foi concebido para usar energia mínima enquanto oferece desempenho rápido para redes neurais. Ele permite otimizar os teus modelos Ultralytics YOLO11 para inferência de alta velocidade e baixo consumo de energia. Neste guia, vamos acompanhar-te na exportação e implantação dos teus modelos para o formato IMX500, facilitando o bom funcionamento dos teus modelos na Raspberry Pi AI Camera.

Por que você deve exportar para IMX500?#

IMX500 Intelligent Vision Sensor da Sony é um pedaço de hardware revolucionário no processamento de IA de ponta. É o primeiro sensor de visão inteligente do mundo com capacidades de IA no chip. Este sensor ajuda a superar muitos desafios na IA de borda, incluindo gargalos de processamento de dados, preocupações com privacidade e limitações de desempenho. Embora outros sensores apenas repassem imagens e quadros, o IMX500 conta uma história completa. Ele processa dados diretamente no sensor, permitindo que os dispositivos gerem percepções em tempo real.

Exportação Sony IMX500 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 ao reduzir a latência e permitindo um 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, uma vez que não são enviados para um servidor remoto.

Principais recursos do IMX500:

• Saída de Metadados: Em vez de transmitir apenas imagens, o IMX500 pode gerar tanto a imagem quanto metadados (resultado da inferência), e pode gerar apenas metadados para minimizar o tamanho dos dados, reduzir a largura de banda e diminuir custos.
• Aborda preocupações com privacidade: Ao processar dados no 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 no sensor suporta decisões em tempo real, perfeito para aplicações de IA na borda, como sistemas autônomos.

Antes de Começar: Para melhores resultados, garante que o teu modelo YOLO11 está bem preparado para exportação seguindo o nosso Model Training Guide, Data Preparation Guide e Hyperparameter Tuning Guide.

Tarefas Suportadas#

A exportação IMX500 suporta quatro das sete tarefas do Ultralytics e apenas para YOLOv8n e YOLO11n: outras famílias de modelos, escalas e arquiteturas não são suportadas, e exportar um modelo de segmentação semântica, OBB ou estimativa de profundidade gera um erro.

Exemplos de uso#

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

O formato IMX500 suporta os modos Export, Predict e Validate. A inferência e a validação correm na Raspberry Pi AI Camera (IMX500).

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

 from ultralytics import YOLO

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

 # Validate accuracy on the COCO8 dataset
 metrics = model.val(data="coco8.yaml")

Argumentos de Exportação#

Para mais detalhes sobre o processo de exportação, visita a página de documentação do 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 implantaçã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 Implantação#

Após exportar o modelo Ultralytics YOLO11n para o formato IMX500, ele pode ser implantado 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 na Raspberry Pi e ligue a Raspberry Pi.

Pré-requisitos de software#

Passo 1: Abra uma janela de terminal e execute os seguintes comandos para atualizar o software da 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 a Raspberry Pi para que as alterações entrem em vigor.

sudo reboot

Passo 4: Instalar a Aitrios Raspberry Pi application module library

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

Passo 5: Executar a deteção de objetos, estimativa de pose, classificação e segmentação do YOLO11 usando os scripts abaixo que estão disponíveis em aitrios-rpi-application-module-library examples.

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 FPS 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 YOLOv8n, YOLO11n, YOLOv8n-pose, YOLO11n-pose, YOLOv8n-cls e YOLO11n-cls abaixo foram executados pela equipa do Ultralytics na Raspberry Pi AI Camera com o formato de modelo imx, medindo velocidade e precisão.

O que há por baixo do capô?#

Sony Model Compression Toolkit (MCT)#

Sony's Model Compression Toolkit (MCT) é uma ferramenta poderosa para otimizar modelos de deep learning através de quantização e poda. Ela 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 menor latência.

Recursos suportados do MCT#

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

1. Otimizações de Grafo: Transforma modelos em versões mais eficientes dobrando camadas como a normalização de lote (batch normalization) nas camadas precedentes.
2. Busca de Parâmetros de Quantização: Minimiza o ruído de quantização usando métricas como Erro Quadrático Médio, Sem Corte e Erro Médio Absoluto.
3. Algoritmos Avançados de Quantização:
   • Correção de Deslocamento Negativo: Aborda problemas de desempenho decorrentes da quantização de ativação simétrica.
   • Filtragem de Outliers: Usa escore z 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 bit 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 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 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 suporta 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. Esta técnica aproveita as capacidades de Single Instruction, Multiple Data (SIMD) da plataforma de destino ao podar grupos SIMD. Isso reduz o tamanho e a complexidade do modelo enquanto otimiza a utilização dos canais, alinhado com a arquitetura SIMD para uma utilização direcionada dos recursos de memória de pesos. Disponível através das APIs Keras e PyTorch.

Ferramenta de Conversão IMX500 (Compilador)#

A Ferramenta de Conversão 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 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, simplificando o processo de implementação na Raspberry Pi AI Camera.

Casos de Uso no Mundo Real#

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

• Edge AI 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 baixa potência é essencial.
• Dispositivos Vestíveis (Wearables): Implemente modelos otimizados para processamento de IA em pequena escala em dispositivos vestíveis de monitoramento de saúde.
• Cidades Inteligentes: Utilize modelos YOLO11 exportados para 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 nas lojas implementando 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 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 mais informações e diretrizes detalhadas, consulta o IMX500 website da Sony.

FAQ#