Link to this sectionExportaçã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 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 entrega 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, mostraremos como exportar e implantar seus modelos para o formato IMX500, facilitando o desempenho dos seus modelos na Raspberry Pi AI Camera.

Link to this sectionPor que você deve exportar para IMX500?#

O Sensor de Visão Inteligente IMX500 da Sony é um hardware revolucionário em processamento de IA na borda (edge AI). É o primeiro sensor de visão inteligente do mundo com capacidades de IA integradas ao chip. Este sensor ajuda a superar muitos desafios na IA na 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.

Link to this sectionExportaçã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 trabalha 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 um processamento de dados rápido 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 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, 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.

Link to this sectionTarefas Suportadas#

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

• Detecção de Objetos
• Estimativa de Pose
• Classificação
• Segmentação de instância

Link to this sectionExemplos 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 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")

Link to this sectionArgumentos de Exportação#

Para mais detalhes sobre o processo de exportação, visite 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, junto 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

Link to this sectionUsando 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.

Link to this sectionPré-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.

Link to this sectionPré-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: Instale a biblioteca do módulo 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 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 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()

Link to this sectionBenchmarks#

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

Link to this sectionO que há por baixo do capô?#

Link to this sectionSony Model Compression Toolkit (MCT)#

O Model Compression Toolkit (MCT) da Sony é uma ferramenta poderosa para otimizar modelos de aprendizado profundo por meio de quantização e poda. 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.

Link to this sectionRecursos 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.

Link to this sectionQuantizaçã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

Link to this sectionPoda 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.

Link to this sectionFerramenta 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.

Link to this sectionCasos 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.

Link to this sectionConclusã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, consulte o site do IMX500 da Sony.

Link to this sectionFAQ#

Link to this sectionComo exporto um modelo YOLO11 para o formato IMX500 para a Raspberry Pi AI Camera?#

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 implementação, incluindo packerOut.zip.

Link to this sectionQuais 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 implementação na borda (edge):

• 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 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

Link to this sectionQuais pré-requisitos de hardware e software são necessários para a implementação do IMX500?#

Para implementar modelos IMX500, você precisará 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 do IMX500 (sudo apt install imx500-all)

Link to this sectionQue desempenho posso esperar dos modelos YOLO11 no IMX500?#

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

• O YOLO11n alcança 58,82ms de tempo de inferência por imagem
• mAP50-95 de 0,517 no conjunto de dados COCO128
• Tamanho do modelo de apenas 2,2 MB após a quantização

Isso demonstra que o formato IMX500 oferece inferência eficiente em tempo real enquanto mantém uma boa precisão para aplicações de Edge AI.