Exportação para Sony IMX500 com Ultralytics YOLO11#

Este guia aborda a exportação e a implantação de modelos Ultralytics YOLO11 em câmeras Raspberry Pi AI Camera com sensor Sony IMX500.

Implantar modelos de visão computacional em dispositivos com poder computacional limitado, como a Raspberry Pi AI Camera, pode ser complicado. Usar um formato de modelo otimizado para maior velocidade faz uma grande diferença.

O formato de modelo IMX500 foi desenvolvido para consumir pouca energia e, ao mesmo tempo, oferecer alto desempenho para redes neurais. Ele permite otimizar seus modelos Ultralytics YOLO11 para inferência rápida e de baixo consumo de energia. Neste guia, vamos mostrar como exportar e implantar seus modelos no formato IMX500, facilitando a obtenção de um bom desempenho dos modelos na Raspberry Pi AI Camera.

Por que exportar para IMX500?#

O sensor de visão inteligente IMX500 da Sony é um hardware revolucionário para o processamento de IA de borda. É o primeiro sensor de visão inteligente do mundo com recursos de IA integrados no chip. Esse sensor ajuda a superar muitos desafios da IA de borda, 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 a história completa. Ele processa dados diretamente no sensor, permitindo que os dispositivos gerem insights em tempo real.

Exportação da Sony IMX500 para modelos YOLO11#

O IMX500 foi desenvolvido para transformar a maneira como os dispositivos processam dados diretamente no sensor, sem precisar enviá-los à 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 processar dados localmente com agilidade, sem depender da nuvem. O processamento local também mantém os dados dos usuários privados e seguros, pois eles não são enviados a um servidor remoto.

Principais recursos do IMX500:

• Saída de metadados: Em vez de transmitir apenas imagens, o IMX500 pode gerar tanto imagens quanto metadados (resultados da inferência), ou somente metadados para minimizar o tamanho dos dados, reduzir o uso de largura de banda e diminuir os custos.
• Lida com preocupações de privacidade: Ao processar dados no dispositivo, o IMX500 lida com questões de privacidade e é ideal para aplicações centradas nas pessoas, como contagem de pessoas e monitoramento de ocupação.
• Processamento em tempo real: O processamento rápido diretamente no sensor permite tomar decisões em tempo real, sendo ideal para aplicações de IA de borda, como sistemas autônomos.

Antes de começar: Para obter os melhores resultados, prepare bem seu modelo YOLO11 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#

A exportação para IMX500 oferece suporte a quatro das sete tarefas da Ultralytics e somente para YOLOv8n e YOLO11n: outras famílias de modelos, escalas e arquiteturas não são compatíveis, e a exportação de 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 inferências com o modelo exportado.

O formato IMX500 oferece suporte aos 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

# Carrega um modelo YOLO11n PyTorch
model = YOLO("yolo11n.pt")

# Exporta o modelo
model.export(format="imx", data="coco8.yaml")  # exporta com quantização PTQ por padrão

# Carrega o modelo exportado
imx_model = YOLO("yolo11n_imx_model")

# Executar inferência
results = imx_model("https://ultralytics.com/images/bus.jpg")

from ultralytics import YOLO

# Carrega um modelo YOLO11n-pose PyTorch
model = YOLO("yolo11n-pose.pt")

# Exporta o modelo
model.export(format="imx", data="coco8-pose.yaml")  # exporta com quantização PTQ por padrão

# Carrega o modelo exportado
imx_model = YOLO("yolo11n-pose_imx_model")

# Executar inferência
results = imx_model("https://ultralytics.com/images/bus.jpg")

from ultralytics import YOLO

# Carrega um modelo YOLO11n-cls PyTorch
model = YOLO("yolo11n-cls.pt")

# Exporta o modelo
model.export(format="imx", data="imagenet10")  # exporta com quantização PTQ por padrão

# Carrega o modelo exportado
imx_model = YOLO("yolo11n-cls_imx_model")

# Executar inferência
results = imx_model("https://ultralytics.com/images/bus.jpg", imgsz=224)

from ultralytics import YOLO

# Carrega um modelo YOLO11n-seg PyTorch
model = YOLO("yolo11n-seg.pt")

# Exporta o modelo
model.export(format="imx", data="coco8-seg.yaml")  # exporta com quantização PTQ por padrão

# Carrega o modelo exportado
imx_model = YOLO("yolo11n-seg_imx_model")

# Executar inferência
results = imx_model("https://ultralytics.com/images/bus.jpg")

from ultralytics import YOLO

# Carrega o modelo IMX500 exportado
model = YOLO("yolo11n_imx_model")

# Validar a precisão no conjunto de dados COCO8
metrics = model.val(data="coco8.yaml")

Argumentos de exportação#

Para 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, além de um diretório chamado <model-name>_imx_model. Esse diretório incluirá o arquivo packerOut.zip, 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) com a lista de 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

Usar 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.

Requisitos de hardware#

Verifique se você tem o seguinte hardware:

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

Conecte a câmera Raspberry Pi AI Camera ao conector MIPI CSI de 15 pinos da Raspberry Pi e ligue a Raspberry Pi

Requisitos de software#

Etapa 1: Abra uma janela do 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

Etapa 2: Instale o firmware IMX500, necessário para operar o sensor IMX500.

sudo apt install imx500-all

Etapa 3: Reinicie a Raspberry Pi para que as alterações entrem em vigor

sudo reboot

Etapa 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

Etapa 5: Execute detecção de objetos, estimativa de pose, classificação e segmentação com YOLO11 usando os scripts abaixo, disponíveis nos 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()

Benchmarks#

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

O que há por dentro?#

Kit de ferramentas de compressão de modelos da Sony (MCT)#

O Kit de Compressão de Modelos (MCT) da Sony é 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 oferece algoritmos avançados para reduzir o tamanho e a complexidade computacional dos modelos sem sacrificar significativamente a precisão. O MCT é especialmente útil para implementar modelos em dispositivos com recursos limitados, garantindo inferência eficiente e menor latência.

Funcionalidades compatíveis com o MCT#

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

1. Otimizações de grafos: transforma modelos em versões mais eficientes ao fundir camadas, como a normalização em lote, nas camadas anteriores.
2. Pesquisa de parâmetros de quantização: minimiza o ruído de quantização usando métricas como erro quadrático médio, sem clipping e erro médio absoluto.
3. Algoritmos avançados de quantização:
   • Correção de deslocamento negativo: resolve problemas de desempenho causados pela quantização simétrica das ativações.
   • Filtragem de valores atípicos: usa o z-score para detetar e remover valores atípicos.
   • Agrupamento: utiliza grelhas de quantização não uniformes para corresponder melhor à distribuição.
   • Pesquisa de precisão mista: atribui larguras de bits de quantização diferentes a cada camada, com base na sensibilidade.
4. Visualização: usa 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 dos modelos 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 a 3 horas de GPU)
3. Treino com reconhecimento de quantização (QAT):
   • Complexidade: alta
   • Custo computacional: alto (12 a 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 tira partido das capacidades de Instrução Única, Dados Múltiplos (SIMD) da plataforma de destino através da poda de grupos SIMD. Isto reduz o tamanho e a complexidade do modelo e otimiza a utilização dos canais, alinhando-se com a arquitetura SIMD para direcionar a utilização dos recursos da memória ocupada pelos pesos. Disponível através das APIs Keras e PyTorch.

Ferramenta de conversão IMX500 (compilador)#

A Ferramenta de conversão IMX500 é uma parte integrante do conjunto de ferramentas IMX500 e permite compilar modelos para implementação no sensor IMX500 da Sony (por exemplo, nas Raspberry Pi AI Cameras). Esta ferramenta facilita a transição dos modelos Ultralytics YOLO11 processados pelo software Ultralytics, garantindo a compatibilidade e um desempenho eficiente no hardware especificado. O processo de exportação, após a quantização do modelo, gera ficheiros binários que contêm dados essenciais e configurações específicas do dispositivo, simplificando a implementação na Raspberry Pi AI Camera.

Casos de uso 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 nas lojas através da implementação de 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 modelos para uma inferência eficiente em câmaras baseadas em IMX500. Ao recorrer a 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.

Perguntas frequentes#