Detecção de Objetos em Tempo Real – Xilinx Vitis AI

A Xilinx lançou recentemente seu novíssimo kit de desenvolvimento de machine learning – Vitis AI. Tivemos a oportunidade de explorar seu ambiente de desenvolvimento de IA e o fluxo de ferramentas. Neste blog, gostaríamos de fornecer aos leitores uma compreensão clara de como desenvolver um sistema de detecção de objetos em tempo real em um dos alvos embarcados da Xilinx. Usaremos o modelo Single Shot Detector (SSD) baseado em VGG para a aplicação de detecção. Como nosso público vem de vários domínios e tem experiências variadas de trabalho com Deep Learning, bem como dispositivos Xilinx, gostaríamos de começar com o básico. Então, não vamos treinar um modelo do zero, mas cobriremos o fluxo de trabalho desde o modelo do framework de Machine Learning até um capaz de ser implantado no Xilinx Zynq UltraScale+ MPSoC ZCU104.

Configuração e Instalação do Ambiente

Para o desenvolvimento do modelo de Machine Learning, estamos usando o framework Caffe. Eu sei, muitos leitores podem perguntar por que Caffe, é antigo e por que não Tensorflow. Sim, você está certo, Caffe é antigo, mas ainda existem pessoas que o usam, como a Xilinx, e pensamos que seria bom para iniciantes entenderem os conceitos de ML com facilidade. Mas não se preocupe, cobriremos um exemplo funcional com Tensorflow no próximo post do blog.

Nota: O tutorial é baseado no Vitis AI 1.1.

Configuração do Host

Então, vamos discutir como podemos configurar o Caffe e se é difícil? Não, é bastante fácil com o novo Vitis AI 1.1, pois ele fornece o Caffe pré-instalado no pacote Docker que está disponível em https://github.com/Xilinx/Vitis-AI. Nesta página, você encontrará todos os detalhes para configurar o Vitis AI em seu PC host (Ubuntu 18.04 no nosso caso). Encorajamos usuários avançados a instalar o container Docker habilitado para GPU, pois isso aceleraria o fluxo de ferramentas de quantização.

Neste ponto, o ambiente está configurado e o ambiente conda do Caffe pode ser instanciado com o seguinte comando

robin@ubuntu:/workspace$ conda activate vitis-ai-caffe

Agora seu terminal exibirá algo semelhante ao seguinte:

(vitis-ai-caffe) robin@ubuntu:/workspace$

Configuração do Host (Usando VART)

O Vitis AI runtime permite que aplicações usem a API de runtime de alto nível unificada tanto para cloud quanto para edge. Portanto, tornando as implantações de cloud para edge perfeitas e eficientes. O procedimento para instalar o sistema de compilação cruzada e configurar a biblioteca glob é claramente explicado aqui: https://github.com/Xilinx/Vitis-AI/tree/master/VART.

Finalmente, você poderá compilar cruzadamente uma amostra, pegue o resnet50 como exemplo.

Se não houver erros, então o VART foi instalado com sucesso no PC host.

Configuração da Vitis AI Library

A Vitis AI Library é um conjunto de bibliotecas e APIs de alto nível construídas para inferência de IA eficiente com a Deep-Learning Processor Unit (DPU). É construída com base no Vitis AI Runtime com APIs Unificadas e suporta totalmente o XRT 2019.2. Elas encapsulam muitas redes neurais de alta qualidade e eficientes, o que simplifica o uso de redes neurais de deep learning sem o conhecimento de deep learning ou FPGAs.

Por favor, siga as instruções para configurar o PC host com a Vitis AI Library na seguinte página: https://github.com/Xilinx/Vitis-AI/tree/master/Vitis-AI-Library. Se você fez a configuração do VART, então não precisa fazer mais instalações, mas certifique-se de que consegue compilar algumas amostras da Vitis AI Library.

Configuração da Placa de Avaliação

A placa de avaliação Xilinx ZCU104 usa o dispositivo Zynq UltraScale+ de médio porte para permitir que você inicie rapidamente suas aplicações de machine learning. Para mais informações sobre a placa ZCU104, consulte o site da Xilinx: https://www.xilinx.com/products/boards-and-kits/zcu104.html. As principais interfaces de conectividade para o ZCU104 são mostradas na figura a seguir.

O primeiro passo é baixar a imagem demo do Linux com o Vitis AI DPU habilitado daqui.

É altamente recomendado executar o patch de gerenciamento de energia executando irps5401 para evitar desligamento ou travamentos do sistema ao executar as amostras. Se você não conseguir encontrar este comando na imagem pré-construída, por favor baixe a imagem atualizada daqui: https://www.xilinx.com/bin/public/openDownload?filename=xilinx-zcu104-dpu-v2019.2-v2.img.gz.

Encorajamos os leitores a percorrer todos os procedimentos (página 20 – 30) para configurar a placa ZCU104 no guia do usuário do Vitis AI: https://www.xilinx.com/support/documentation/sw_manuals/vitis_ai/1_0/ug1414-vitis-ai.pdf.

Ao seguir o recurso acima, por favor certifique-se de instalar os pacotes necessários tanto para o VART quanto para a Vitis AI Library. O guia do usuário menciona apenas a instalação do VART, mas você pode encontrar a instalação da Vitis Library para a placa aqui: https://github.com/Xilinx/Vitis-AI/tree/master/Vitis-AI-Library

Verificação da Instalação do VART

É muito importante verificar a instalação do VART na placa alvo. Na sua placa alvo, mude para o diretório onde as amostras do VART foram baixadas.

#cd ~/VART/samples/resnet50

Execute o exemplo.

#./resnet50 model_dir_for_zcu104

Se o programa executável acima não existir, execute o seguinte comando para compilar e gerar o programa executável correspondente.

#bash -x build.sh

Verificação da Vitis AI Library

Como estaremos aproveitando o poder da Vitis AI Library para certas etapas de pré e pós-processamento durante a inferência, é ótimo executar algumas amostras pré-construídas fornecidas pela Vitis AI Library. Se você seguiu o procedimento mencionado acima para instalar o pacote de modelo de IA para a placa alvo, então todos os modelos serão armazenados em /usr/share/vitis_ai_library/models/. Cada modelo é armazenado em uma pasta separada que é composta de:

• [model_name].elf
• [model_name].prototxt
• meta.json

veremos o que são todos esses arquivos ao discutir a detecção de objetos, fique ligado!!!. Então vamos executar alguns exemplos para verificar a instalação. Executaremos o exemplo de detecção facial e usaremos o modelo dense_640_360.elf. Vá para o seu terminal e digite

#cd /usr/share/vitis_ai_library/models/

#cp -r dense_640_360/ ~/overview/samples/facedetect/

Construa o executável.

#sh -x build.sh

Execute a demo em uma única imagem

#./test_jpeg_facedetect densebox_640_360 sample_facedetect.jpg

Aqui está a saída. Eu sei, o modelo não detectou um daqueles rostos. Como o modelo é pré-treinado e compilado pela Xilinx, não podemos fazer uma conclusão sobre por que o modelo faz isso e está fora do escopo deste blog.

Agora configuramos com sucesso o ambiente (Host e alvo) para as próximas etapas de desenvolvimento

Detecção de Objetos no ZCU104

A detecção de objetos é uma das áreas importantes da Visão Computacional onde muita pesquisa está sendo feita. Pedimos fortemente aos nossos leitores que primeiro obtenham uma compreensão clara entre as várias tarefas de visão computacional, a saber, classificação de imagens, detecção e segmentação. A tarefa de classificação de imagens atribui um rótulo de classe aos objetos correspondentes em uma imagem, enquanto na detecção de objetos, desenhamos uma caixa delimitadora ao redor de cada objeto de interesse e os rotulamos como fazemos na tarefa de classificação. Se você quiser obter uma introdução gentil para todas essas tarefas, visite este excelente blog do famoso Jason Brownlee: https://machinelearningmastery.com/object-recognition-with-deep-learning/

Alguns exemplos para ilustrar a ideia.

Detecção de Objetos Single Shot

O framework Single Shot Object Detection (SSD) foi descrito pela primeira vez por Christian Szegedy et al. no artigo intitulado SSD: Single Shot MultiBox Detector. Para detecção de objetos, temos principalmente dois tipos de detectores: detectores de estado da arte multi-estágio como a família RCNN RCNN, Faster RCNN, etc. e detectores de estágio único como Yolo e SSD. Comparando com os modelos RCNN, detectores de estágio único são mais rápidos, tornando-os adequados para detecção de objetos em tempo real. Como o SSD usa recursos convolucionais multi-escala no topo da rede em vez de uma camada totalmente conectada no Yolo, torna-os mais rápidos e mais precisos. Por favor, veja a comparação entre essas redes para velocidade e precisão.

Como você notou, o SSD vem em diferentes formatos, o que depende do tamanho da imagem de entrada. Na comparação acima, usamos VGG16 como extrator de características, e ao contrário do trabalho real, as dimensões da imagem de entrada são 300 × 300. Recomendamos fortemente ao público que obtenha uma ideia intuitiva de como exatamente o SSD detecta objetos da imagem de entrada. Por favor, visite este excelente tutorial de Sagar Vinodbabu em a-PyTorch-Tutorial-to-Object-Detection.

Esperançosamente, agora entendemos como o SSD funciona, pelo menos o fluxo de trabalho. Para o restante das etapas do blog, forneceremos arquivos associados para aqueles que desejam implementar por conta própria. Isso ajudará você a saber como invocar as ferramentas Vitis AI para aceleração.

Nota: Se você instalou o sistema de runtime Docker Vitis AI em seu host, uma pasta workspace será criada no sistema de runtime Docker. Por favor, copie a pasta raiz dos nossos arquivos associados para /workspace.

Descrição dos arquivos:

1. VAI: Contém os arquivos para quantizar e compilar seu modelo Caffe pré-treinado.
   • "float.prototxt": usado para quantizar/compilar os modelos para implantação no hardware alvo. Nota: Por favor, cuide do caminho especificado para dados de calibração e arquivos de texto para que eles apontem para o local correto. Se você estiver seguindo diretamente o tutorial, nenhuma alteração precisa ser feita.
   • "float.caffemodel": pesos pré-treinados.
   • "quantize_and_compile.sh": script para automatizar a quantização e compilação do nosso modelo. Examinaremos em mais detalhes em breve.
2. data: Aqui temos todos os arquivos associados aos dados de treinamento, como dados de calibração, arquivos de texto, mapas de rótulos, etc., que são exigidos pelo arquivo "float.prototxt" ao quantizar a rede.
3. ZCU104: contém os arquivos para implantar o modelo compilado na placa alvo.

Agora podemos quantizar o modelo com o Vitis AI quantizer e compilar usando o AI Compiler. Você pode executar essas ferramentas executando o seguinte comando (talvez seja necessário tornar o arquivo executável primeiro)

/workspace/SSD$ cd VAI

/workspace/SSD/VAI$ ./quantize_and_compile.sh

Abra o script, se precisar fazer alterações como configuração do ID da GPU, etc. Estive testando com uma máquina apenas com CPU. Para quantização mais rápida, use dispositivos habilitados para GPU.

#!/usr/bin/env bash
#uncomment for GPU usage
#export GPUID=0
net=vgg16_ssd

#working directory
work_dir=$(pwd)
#path of float model
model_dir=quantize
#output directory
output_dir=compile

echo "quantizing network: $(pwd)/float.prototxt"
vai_q_caffe quantize          \
          -model $(pwd)/float.prototxt     \
          -weights $(pwd)/float.caffemodel \
          -calib_iter 100 \
          -output_dir ${model_dir} 2>&1 | tee ${model_dir}/quantize.txt

echo "Compiling network: ${net}"

vai_c_caffe   --prototxt=${model_dir}/deploy.prototxt \
        --caffemodel=${model_dir}/deploy.caffemodel \
        --output_dir=${output_dir} \
        --net_name=${net} \
        --options "{'mode':'normal'}" \
        --arch=/opt/vitis_ai/compiler/arch/dpuv2/ZCU104/ZCU104.json 2>&1 | tee ${output_dir}/compile.txt

O script executa o quantizador em seu modelo float executando o comando vai_q_caffe e você pode encontrar uma saída de exemplo arquivo de log vai_q_caffe do meu console para referência. Após quantizar, obteremos os arquivos "deploy.model" e "deploy.prototxt" necessários pelo processo de compilação que estão armazenados aqui. O quantizador de IA oferece a oportunidade de testar a precisão do modelo quantizado e fornece arquivos de modelo correspondentes que podem ser usados para ajuste adicional.

Finalmente, o comando vai_c_caffe invoca o compilador Vitis AI e compila nosso modelo quantizado para produzir um arquivo de modelo compatível com DPU chamado "dpu_vgg_16_ssd.elf". Para referência, o arquivo de log vai_c_caffe também foi adicionado. Você deve ser capaz de ver algo semelhante a esses arquivos de log. Usaremos o arquivo "elf" gerado para produzir a inferência no ZCU104.

Executando o modelo SSD no ZCU104

Agora podemos implantar nossa detecção de objetos baseada em SSD na placa ZCU104. Para tornar este processo fácil e mais rápido, você pode encontrar todos os arquivos necessários nesta pasta ZCU104. Estaremos aproveitando o poder da Vitis AI Library para as etapas de pré-processamento, implantação do modelo e pós-processamento, como decodificação de caixas delimitadoras, aplicação de supressão não-máxima, etc. Pedimos aos leitores ambiciosos que entrem nos detalhes da Vitis AI Library, onde a maioria de seus componentes são open source e podem ser encontrados aqui. O subdiretório da aplicação inclui os seguintes arquivos e pastas.

• dpu_vgg16_ssd: Este diretório contém o modelo elf compilado e outros arquivos adicionais necessários pela Vitis AI Library para implantar o modelo. Se você estiver usando modelos personalizados, por favor copie os arquivos compilados para este diretório. O arquivo "vgg16_ssd.prototxt" fornece os parâmetros do modelo de detecção e o arquivo meta.json é o arquivo de configuração do modelo. A aplicação obterá as informações do modelo através deste arquivo de configuração.
• vgg16_ssd.prototxt: Este arquivo prototxt de configuração contém as informações de pré e pós-processamento relacionadas ao modelo. Se você encontrar dificuldades em entender os parâmetros, especialmente o prior_box_param, sinta-se à vontade para explorar o arquivo prototxt do modelo ou os arquivos deploy.prototxt para extrair esses parâmetros.
• build.sh: script para construir a aplicação de inferência.
• test_video_ssd.cpp: Esta aplicação implanta o modelo compilado usando a Vitis AI Library e permite que o usuário teste com uma webcam ou gravação de vídeo.
• process_result.hpp: Aqui desenhamos as caixas delimitadoras sobre as detecções.

Agora copie este diretório de aplicação ZCU104 para sua placa ZCU104 através de uma conexão ethernet. O próximo passo requer que os pacotes e ferramentas Vitis AI estejam instalados em sua placa. Se você não fez isso, por favor consulte as seções anteriores para configurar a placa alvo.

Agora na placa,

root@xilinx-zcu104-2019_2:~# cd ZCU104/

root@xilinx-zcu104-2019_2:~/ZCU104# sh -x build.sh

Uma vez que o build estiver concluído, você pode executar a aplicação para uma webcam ou gravação de vídeo junto com a menção do número de threads (t) da seguinte forma

para câmera USB:

./test_video_ssd dpu_vgg16_ssd -t 6 0

para arquivo de vídeo:

./test_video_ssd dpu_vgg16_ssd -t 6 /path/to/video_file

Conclusão

Até agora, descrevemos os vários recursos do ambiente de desenvolvimento Vitis AI e seu fluxo de ferramentas. Embora não tenhamos coberto muitos conceitos de machine learning, este tutorial será um ótimo ponto de partida para todos aqueles que desejam iniciar sua aplicação de inferência de machine learning em dispositivos edge Xilinx. Mostramos o fluxo de trabalho do ponto de vista de um framework de Machine Learning e como utilizar as ferramentas Vitis AI para desenvolver uma aplicação acelerada. Existem muitas amostras e demos disponíveis na página do GitHub do Vitis AI para ajudar os leitores a se familiarizarem com novas ferramentas junto com suas aplicações de deep learning. Publicaremos novos tutoriais com diferentes exemplos em um futuro próximo, até lá fique ligado.