Exportação do Sony IMX500 para Ultralytics YOLO11#

Este guia aborda a exportação e a implementação de modelos Ultralytics YOLO11 em Raspberry Pi AI Cameras equipadas com o sensor Sony IMX500.

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

O formato de modelo IMX500 foi concebido para utilizar o mínimo de energia e, ao mesmo tempo, proporcionar um desempenho rápido para redes neurais. Permite otimizar os teus modelos Ultralytics YOLO11 para inferência de alta velocidade e baixo consumo de energia. Neste guia, vais aprender a exportar e implementar os teus modelos no formato IMX500, facilitando o bom desempenho dos teus modelos na Raspberry Pi AI Camera.

Por que razão deves exportar para IMX500?#

O Sony IMX500 Intelligent Vision Sensor é uma peça de hardware revolucionária no processamento de IA de edge. É o primeiro sensor de visão inteligente do mundo com capacidades de IA no chip. Este sensor ajuda a ultrapassar muitos desafios da IA de edge, incluindo estrangulamentos no processamento de dados, preocupações com a privacidade e limitações de desempenho. Enquanto outros sensores se limitam a transmitir imagens e frames, o IMX500 conta a história completa. Processa os dados diretamente no sensor, permitindo que os dispositivos gerem informações em tempo real.

Exportação do Sony IMX500 para modelos YOLO11#

O IMX500 foi concebido para transformar a forma como os dispositivos processam os dados diretamente no sensor, sem precisar de os enviar para a cloud para processamento.

O IMX500 funciona com modelos quantizados. A quantização torna os modelos mais pequenos e rápidos sem perder muita precisão. É ideal para os recursos limitados da computação de edge, permitindo que as aplicações respondam rapidamente ao reduzir a latência e permitir o processamento rápido de dados localmente, sem depender da cloud. O processamento local também mantém os dados dos utilizadores privados e seguros, uma vez que não são enviados para um servidor remoto.

Principais funcionalidades do IMX500:

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

Antes de começares: Para obteres os melhores resultados, garante que o teu modelo YOLO11 está bem preparado para a exportação, seguindo o nosso Guia de Treino de Modelos, Guia de Preparação de Dados e Guia de Ajuste de Hiperparâmetros.

Tarefas suportadas#

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

Exemplos de utilização#

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

O formato IMX500 suporta os modos Exportar, Prever e Validar. A inferência e a validação são executadas 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 obter mais detalhes sobre o processo de exportação, visita a página da documentação da Ultralytics sobre exportação.

O processo de exportação criará um modelo ONNX para validação da quantização, juntamente com um diretório chamado <model-name>_imx_model. Este diretório incluirá o ficheiro packerOut.zip, essencial para empacotar o modelo para implementação no hardware IMX500. Além disso, a pasta <model-name>_imx_model conterá um ficheiro de texto (labels.txt) que lista todas as etiquetas associadas ao modelo.

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

Usar a exportação IMX500 na implementação#

Depois de exportares o modelo Ultralytics YOLO11n para o formato IMX500, podes implementá-lo na Raspberry Pi AI Camera para realizar inferência.

Pré-requisitos de hardware#

Garante que tens o hardware abaixo:

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

Liga a câmara Raspberry Pi AI ao conector MIPI CSI de 15 pinos da Raspberry Pi e liga a alimentação da Raspberry Pi.

Pré-requisitos de software#

Passo 1: Abre uma janela do terminal e executa 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: Instala o firmware IMX500, necessário para operar o sensor IMX500.

sudo apt install imx500-all

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

sudo reboot

Passo 4: Instala 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: Executa a deteção de objetos, a estimativa de pose, a classificação e a segmentação YOLO11 utilizando os scripts abaixo, disponíveis nos exemplos da biblioteca do módulo de aplicação 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 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 de YOLOv8n, YOLO11n, YOLOv8n-pose, YOLO11n-pose, YOLOv8n-cls e YOLO11n-cls abaixo foram executados pela equipa da Ultralytics numa Raspberry Pi AI Camera com o formato de modelo imx, medindo a velocidade e a 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 deep learning através de quantização e poda. Suporta vários métodos de quantização e fornece algoritmos avançados para reduzir o tamanho e a complexidade computacional dos modelos sem sacrificar significativamente a precisão. O MCT é particularmente útil para implementar modelos em dispositivos com recursos limitados, garantindo uma inferência eficiente e uma latência reduzida.

Funcionalidades suportadas do MCT#

O MCT da Sony oferece várias funcionalidades concebidas para otimizar modelos de redes neurais:

1. Otimizações do grafo: Transforma os modelos em versões mais eficientes ao integrar camadas como a normalização de lotes nas camadas anteriores.
2. Pesquisa de parâmetros de quantização: Minimiza o ruído da quantização utilizando métricas como o erro quadrático médio, sem clipping e o erro médio absoluto.
3. Algoritmos avançados de quantização:
   • Correção de deslocamento negativo: Resolve problemas de desempenho resultantes da quantização simétrica das ativações.
   • Filtragem de valores atípicos: Utiliza o z-score para detetar e remover valores atípicos.
   • Clustering: Utiliza grelhas de quantização não uniformes para obter uma melhor correspondência da distribuição.
   • Pesquisa de precisão mista: Atribui diferentes larguras de bits de quantização por camada com base na sensibilidade.
4. Visualização: Utiliza o TensorBoard para observar informações sobre o desempenho do modelo, as fases de quantização e as 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-treino (PTQ):
   • Disponível através das APIs Keras e PyTorch.
   • Complexidade: Baixa
   • Custo computacional: Baixo (minutos de CPU)
2. Quantização pós-treino baseada em gradientes (GPTQ):
   • Disponível através das APIs Keras e PyTorch.
   • Complexidade: Média
   • Custo computacional: Moderado (2–3 horas de GPU)
3. Treino consciente da quantização (QAT):
   • Complexidade: Alta
   • Custo computacional: Elevado (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étrica
3. Uniforme

Poda estruturada#

O MCT introduz uma poda de modelos estruturada e consciente do hardware, concebida para arquiteturas de hardware específicas. Esta técnica utiliza as capacidades de Instrução Única, Dados Múltiplos (SIMD) da plataforma-alvo, podando grupos SIMD. Isto reduz o tamanho e a complexidade do modelo, otimizando simultaneamente a utilização dos canais e alinhando-a com a arquitetura SIMD para uma utilização direcionada dos recursos da memória ocupada pelos pesos. Disponível através das APIs Keras e PyTorch.

IMX500 Converter Tool (compilador)#

O IMX500 Converter Tool é parte integrante do conjunto de ferramentas IMX500, permitindo a compilação de modelos para implementação no sensor IMX500 da Sony, como nas Raspberry Pi AI Cameras. Esta ferramenta facilita a transição dos modelos Ultralytics YOLO11 processados através do software Ultralytics, garantindo a sua compatibilidade e um desempenho eficiente no hardware especificado. O procedimento de exportação após a quantização do modelo envolve a geração de ficheiros 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 utilização no mundo real#

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

• IA de edge e IoT: Permite a deteção de objetos em drones ou câmaras de segurança, onde o processamento em tempo real em dispositivos de baixo consumo é essencial.
• Dispositivos vestíveis: Implementa modelos otimizados para processamento de IA em pequena escala em dispositivos vestíveis de monitorização da saúde.
• Cidades inteligentes: Utiliza modelos YOLO11 exportados para IMX500 na monitorização do trânsito e na análise de segurança, com processamento mais rápido e latência mínima.
• Análise de retalho: Melhora a monitorização em lojas ao implementar modelos otimizados em sistemas de ponto de venda ou prateleiras inteligentes.

Conclusão#

A exportação de modelos Ultralytics YOLO11 para o formato IMX500 da Sony permite implementar os teus modelos para uma inferência eficiente em câmaras baseadas no IMX500. Ao tirares partido de 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 obteres mais informações e orientações detalhadas, consulta o website do IMX500 da Sony.

Perguntas frequentes#