Guia do usuário do software Qualcomm TensorFlow Lite SDK

Guia do usuário do software Qualcomm TensorFlow Lite SDK

Histórico de revisão

Revisão	Data	Descrição
AA	Setembro de 2023	Lançamento inicial
AB	Outubro de 2023	In Gerar SDK da plataforma, atualizou os comandos para construir as imagens do espaço do usuário e o SDK da plataforma Adicionado Gere TFLite SDK com estação de trabalho Linux Adicionado Trabalhe com o delegado TFLite externo da QNN In Referência, atualizou os scripts para Delegado Externo

Introdução às ferramentas Qualcomm TFLite SDK

As ferramentas do kit de desenvolvimento de software Qualcomm TensorFlow Lite (Qualcomm TFLite SDK) fornecem a estrutura TensorFlow Lite para inferência de inteligência artificial (IA) no dispositivo, o que facilita aos desenvolvedores de aplicativos desenvolver ou executar aplicativos de IA adequados.
Este documento fornece instruções passo a passo para compilar um SDK Qualcomm TFLite independente e configurar o ambiente de desenvolvimento. Isso permite o fluxo de trabalho do desenvolvedor, que inclui:

• configurando o ambiente de construção onde o desenvolvedor pode compilar o SDK Qualcomm TFLite
• desenvolvendo aplicativos Qualcomm TFLite SDK independentes

Para suporte, consulte https://www.qualcomm.com/apoiar. A figura a seguir fornece um resumo do fluxo de trabalho do Qualcomm TFLite SDK: ”
Figura 1-1 Fluxo de trabalho do Qualcomm TFLite SDK
A ferramenta requer uma plataforma SDK e uma configuração file (formato JSON) para gerar os artefatos do Qualcomm TFLite SDK.

Para criar um aplicativo de ponta a ponta usando subsistemas de multimídia, IA e visão computacional (CV), consulte o Guia de início rápido do Qualcomm Intelligent Multimedia SDK (QIM SDK) (80-50450-51).
A tabela mostra o mapeamento da versão do Qualcomm TFLite SDK com a versão CodeLinaro tag:
Tabela 1-1 Informações de liberação

Versão do SDK TFLite da Qualcomm	Lançamento do CodeLinaro tag
V1.0	Qualcomm TFLITE.SDK.1.0.r1-00200-TFLITE.0
	TFLITE.SDK.1.0.r1-00500-TFLITE.0.xml

Tabela 1-2 Versões suportadas do Qualcomm TFLite SDK

Qualcomm Versão do SDK TFLite	Produto de software compatível	Versão TFLite suportada
V1.0	QCS8550.LE.1.0	2.6.0
		2.8.0
		2.10.1
		2.11.1
		2.12.1
		2.13.0

Referências
Tabela 1-3 Documentos relacionados

Título	Número
Qualcomm
00067.1 Nota de versão para QCS8550.LE.1.0	RNO-230830225415
Guia de início rápido do Qualcomm Intelligent Multimedia SDK (QIM SDK)	80-50450-51
Referência do SDK multimídia inteligente da Qualcomm (QIM SDK)	80-50450-50
Recursos
https://source.android.com/docs/setup/start/initializing	–

Tabela 1-4 Siglas e definições

Sigla ou termo	Definição
AI	Inteligência artificial
BIOS	Sistema básico de entrada/saída
CV	Visão computacional
IPK	Seu pacote file
SDK do QIM	Kit de desenvolvimento de software multimídia inteligente Qualcomm
SDK	Kit de desenvolvimento de software
TFLite	TensorFlow Lite
XNN	Xth vizinho mais próximo

Configurar o ambiente de compilação para ferramentas Qualcomm TFLite SDK

As ferramentas Qualcomm TFLite SDK são lançadas em formato fonte; portanto, estabelecer o ambiente de construção para compilá-lo é uma configuração obrigatória, mas única.

Pré-requisitos

• Certifique-se de ter sudoaccess na máquina host Linux.
• Certifique-se de que a versão do host Linux seja Ubuntu 18.04 ou Ubuntu 20.04.
• Aumente o máximo de observações de usuários e de instâncias de usuários no sistema host.
• Adicione as seguintes linhas de comando a /etc/sysctl.conf e reinicialize o host: fs.inotify.max_user_instances=8192 fs.inotify.max_user_watches=542288

Instale os pacotes de host necessários

Os pacotes host são instalados na máquina host Linux.
Execute os comandos para instalar os pacotes host: $ sudo apt install -y jq $ sudo apt install -y texinfo chrpath libxml-simple-perl openjdk-8-jdkheadless
Para Ubuntu 18.04 e superior:
$ sudo apt-get install git-core gnupg flex bison build-essential zip curl zlib1g-dev gcc-multilib g++-multilib libc6-dev-i386 libncurses5 lib32ncurses5- dev x11proto-core-dev libx11-dev lib32z1-dev libgl1-mesa-dev libxml2-utils xsltproc descompactar fontconfig
Para mais informações, consulte https://source.android.com/docs/setup/start/initializing.

Configurar o ambiente docker

Um docker é uma plataforma usada para construir, desenvolver, testar e entregar software. Para compilar o SDK, o docker deve ser configurado na máquina host Linux.
Certifique-se de que a virtualização da CPU esteja habilitada na máquina host Linux. Se não estiver habilitado, faça o seguinte para habilitá-lo nas definições de configuração do sistema básico de entrada/saída (BIOS):

1. Habilite a virtualização do BIOS:
   a. Pressione F1 ou F2 quando o sistema estiver inicializando para entrar no BIOS. A janela do BIOS é exibida.
   b. Mude para a guia Avançado.
   c. Na seção Configuração da CPU, defina Tecnologia de Virtualização como Ativada.
   a. Pressione F12 para salvar e sair e reinicie o sistema.
   Se essas etapas não funcionarem, siga as instruções específicas do fornecedor do sistema para ativar a virtualização
2. Remova todas as instâncias antigas da janela de encaixe:
   $ sudo apt remover docker-desktop
   $ rm -r $HOME/.docker/desktop
   $ sudo rm /usr/local/bin/com.docker.cli
   $ sudo apt purge docker-desktop
3.  Configure o repositório remoto do Docker:
   $ sudo apt-get update $ sudo apt-get install ca-certificates curl gnupg lsb-release $ sudo mkdir -p /etc/apt/keyrings $ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg — dearmor -o /etc/apt/keyrings/docker.gpg $ echo “deb [arch=$(dpkg –print-architecture) assinado por=/etc/apt/ keyrings/ docker.gpg] https:// download.docker.com/linux/ubuntu $ (lsb_release -cs) estável” | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
4.  Instale o mecanismo docker:
   $ sudo apt-get update $ sudo apt-get install docker-ce docker-ce-cli
5.  Adicione usuário ao grupo docker:
   $ sudo groupadd docker $ sudo usermod -aG docker $USER
6.  Reinicie o sistema.

Gerar SDK da plataforma

A plataforma SDK é um requisito obrigatório para compilar as ferramentas Qualcomm TFLite SDK. Ele fornece todas as dependências de plataforma exigidas pelo Qualcomm TFLite SDK.
Faça o seguinte para gerar o SDK da plataforma:

1. Crie uma compilação para o produto de software preferido.
   As instruções para construir a versão QCS8550.LE.1.0 são fornecidas nas notas de versão. Para acessar as notas de versão, consulte Referências.
   Se as imagens foram criadas anteriormente, execute a etapa 2 e crie uma compilação limpa.
2. Execute o seguinte comando para criar as imagens do espaço do usuário e o SDK da plataforma:
   Para QCS8550.LE.1.0, adicione o recurso de máquina qti-tflite-delegate em MACHINE_FEATURES no kalama.conf file e forneça o ambiente de construção de acordo com as instruções das notas de versão.
   Depois de gerar imagens de espaço do usuário a partir do build, execute o comando a seguir para gerar o SDK da plataforma.
   $ bitbake -fc populate_sdk qti-robotics-image

Crie ferramentas Qualcomm TFLite SDK – fluxo de trabalho do desenvolvedor

O fluxo de trabalho das ferramentas Qualcomm TFLite SDK exige que o desenvolvedor forneça a configuração file com entradas de entrada válidas. Os scripts de shell auxiliar do projeto tflite-tools (presentes na árvore de origem do SDK do Qualcomm TFLite) fornecem funções de utilitário auxiliar para configurar o ambiente de shell, que pode ser usado para o fluxo de trabalho do SDK do Qualcomm TFLite.
O desenvolvedor cria os projetos Qualcomm TFLite SDK dentro do contêiner e gera os artefatos usando os utilitários fornecidos pelo tflite-tools.
Depois que um contêiner Qualcomm TFLite SDK é criado, o desenvolvedor pode anexar ao contêiner e usar os utilitários auxiliares no ambiente shell do contêiner para desenvolvimento contínuo.

• Há uma disposição para instalar os artefatos Qualcomm TFLite SDK em um dispositivo Qualcomm conectado ao host Linux via USB/adb.
• Também existe uma disposição para copiar os artefatos do Qualcomm TFLite SDK do contêiner para uma máquina host diferente onde o dispositivo Qualcomm está conectado.
  

A figura a seguir lista o conjunto de utilitários disponíveis após a configuração do ambiente de construção de contêiner usando os scripts auxiliares para a construção do SDK Qualcomm TFLite.

A figura mostra a sequência de execução das utilidades:
Figura 4-3 Sequência de utilitários no host

Sincronize e crie o Qualcomm TFLite SDK
O Qualcomm TFLite SDK é compilado quando a imagem do docker é criada. Para sincronizar e criar o SDK Qualcomm TFLite, faça o seguinte:

1. Crie um diretório no host file sistema para sincronizar o espaço de trabalho do Qualcomm TFLite SDK. Para
   exampem: $mkdir $cd
2. Obtenha o código-fonte do Qualcomm TFLite SDK em CodeLinaro:
   $ repo init -u https://git.codelinaro.org/clo/le/sdktflite/tflite/ manifest.git –repo-branch=qc/stable –repo-url=git://git.quicinc.com/tools/repo.git -m TFLITE.SDK.1.0.r1-00200-TFLITE.0.xml -b release && repo sync -qc –no-tags -j
3. Crie um diretório no host file sistema que pode ser montado no docker. Para example: mkdir-p / Este diretório pode ser criado em qualquer lugar na máquina host Linux e não depende de onde o projeto Qualcomm TFLite SDK está sincronizado. Depois que o fluxo de trabalho for concluído no contêiner, os artefatos do Qualcomm TFLite SDK poderão ser encontrados no diretório criado nesta etapa.
4. Edite a configuração JSON file presente em /tflite-tools/targets/le-tflite-tools-builder.json com as seguintes entradas:
   “Imagem”: “tflite-tools-builder”, “Device_OS”: “le”, “Additional_tag”: “”, “TFLite_Version”: “2.11.1”, “Delegados”: { “Hexagon_delegate”: “OFF”, “Gpu_delegate”: “ON”, “Xnnpack_delegate”: “ON” }, “TFLite_rsync_destination”: “ /”, “SDK_path”: “/build-qti-distro-fullstack-perf/tmpglibc/deploy/sdk>”, “SDK_shell_file”: “”, “Base_Dir_Location”: “” }
   Para obter mais informações sobre as entradas mencionadas na configuração json file, consulte o leia-me do Docker.md file em /tflite-tools/.
   OBSERVAÇÃO Para QCS8550, o delegado Qualcomm® Hexagon™ DSP não é suportado.
5. Obtenha o script para configurar o ambiente:
   $cd /tflite-tools $ source./scripts/host/docker_env_setup.sh
6.  Crie a imagem do docker do Qualcomm TFLite SDK: $ tflite-tools-host-build-image ./targets/le-tflite-tools-builder.json Se a configuração do build falhar, consulte Solucionar problemas de configuração do docker. Após a conclusão bem-sucedida, a seguinte mensagem será exibida: “Status:Build image concluído com sucesso!!” A execução desta etapa também cria o SDK Qualcomm TFLite.
7.  Execute o contêiner docker Qualcomm TFLite SDK. Isso inicia o contêiner com o tags fornecido na configuração JSON file. $tflite-tools-host-run-container./targets/le-tflite-tools-builder.json
8. Anexe ao contêiner iniciado na etapa anterior.
   $ docker anexar

O Qualcomm TFLite SDK está compilado e os artefatos estão prontos para serem implantados ou podem ser posteriormente
usado para gerar o plug-in QIM SDK TFLite.

Conecte o dispositivo para hospedar e implantar artefatos]

Após a compilação, existem dois mecanismos para conectar o dispositivo a um host e implantar o
Artefatos do SDK TFLite da Qualcomm.

• Dispositivo conectado a um host Linux local:
  Um desenvolvedor conecta o dispositivo a uma estação de trabalho e instala os artefatos Qualcomm TFLite SDK do contêiner diretamente no dispositivo (QCS8550).
• Dispositivo conectado a um host remoto:
  Um desenvolvedor conecta o dispositivo a uma estação de trabalho remota e pode usar os comandos do instalador do gerenciador de pacotes nas plataformas Windows e Linux para instalar os artefatos do Qualcomm TFLite SDK no dispositivo (QCS8550)

Figura 4-4 Conexão da placa do dispositivo ao desenvolvedor e à estação de trabalho remota

Conecte o dispositivo à estação de trabalho

O dispositivo está conectado à estação de trabalho e o contêiner de desenvolvimento pode acessar o dispositivo via USB/adb.
A figura mostra o stages na sequência do fluxo de trabalho do Qualcomm TFLite SDK:

1. Execute os seguintes comandos para instalar os artefatos no dispositivo:
   $ tflite-tools-device-prepare
   $ tflite-tools-device-deploy
2. Para desinstalar os artefatos, execute o seguinte comando:
   $ tflite-tools-device-packages-remove

Conecte o dispositivo à máquina remota

O dispositivo está conectado a uma máquina remota e o contêiner Qualcomm TFLite SDK não pode acessar o dispositivo por USB/ad b.
A figura mostra o stages na sequência do fluxo de trabalho do Qualcomm TFLite SDK:

Execute os seguintes comandos no contêiner tflite-tools para copiar os artefatos para uma máquina remota
dependendo do gerenciador de pacotes no dispositivo:
$ tflite-tools-remote-sync-ipk-rel-pkg
OBSERVAÇÃO As informações da máquina remota são fornecidas na configuração JSON file.
Instalar artefatos para plataforma Windows
Os artefatos Qualcomm TFLite SDK podem ser instalados no dispositivo com base no sistema operacional da máquina remota.

Para a plataforma Windows, faça o seguinte:
No PowerShell, use o seguinte script: PS C:
> adb root PS C:> adb disable-verity PS C:> adb reboot PS C:> adb wait-for-device PS C:> adb root PS C:> adb remount PS C:> adb shell mount -o remount, rw / PS C:> adb shell “mkdir -p /tmp” PS C:> adb push /tmp Se o pacote for um ipk (para QCS8550.LE.1.0), use os seguintes comandos: PS C:> adb shell “ opkg –force-depends –force-reinstall –force-overwrite install /tmp/”

Instalar artefatos para plataforma Linux
Use os seguintes comandos:
$ adb root $ adb disable-verity $ adb reboot $ adb wait-for-device $ adb root $ adb remount $ adb shell mount -o remount,rw / $ adb shell “mkdir -p /tmp” $ adb push /tmp If o pacote é um ipk (para QCS8550.LE.1.0): $ adb shell “opkg –force-depends –force-reinstall –force-overwrite install /tmp/”

Limpar imagem do Docker
Depois de concluir o fluxo de trabalho do desenvolvedor, o ambiente docker deve ser limpo para liberar armazenamento no disco. Limpar a janela de encaixe remove os contêineres e imagens não utilizados, liberando espaço em disco.
Use os seguintes comandos para limpar a imagem do Docker:

1. Execute o seguinte comando na estação de trabalho Linux:
   $cd /tflite-ferramentas
2. Pare o contêiner:
   $ tflite-tools-host-stop-container ./targets/ le-tflite-tools-builder.json
3. Remova o recipiente:
   $ tflite-tools-host-rm-container ./targets/ le-tflite-tools-builder.json
4. Remova as imagens mais antigas do Docker:
   $ tflite-tools-host-images-limpeza

Solucionar problemas de configuração do docker

Se o comando tflite-tools-host-build-image retornar uma mensagem Nospace left on device, mova o diretório docker para/local/mnt. Faça o seguinte para solucionar problemas de configuração:

1. Faça backup da janela de encaixe existente files:
   $ tar -zcC /var/lib docker > /mnt/pd0/var_lib_docker-backup-$(data + %s).tar.gz
2. Pare a janela de encaixe:
   $ serviço docker parar
3. Verifique se nenhum processo docker está em execução:
   $ ps falso | janela de encaixe grep
4. Verifique a estrutura do diretório do docker:
   $ sudo ls /var/lib/docker/
5. Mova o diretório docker para uma nova partição:
   $ mv /var/lib/docker /local/mnt/docker
6. Faça um link simbólico para o diretório docker na nova partição:
   $ ln -s /local/mnt/docker /var/lib/docker
7. Certifique-se de que a estrutura de diretórios do docker permaneça inalterada:
   $ sudo ls /var/lib/docker/
8. Inicie a janela de encaixe:
   $ início do docker de serviço
9. Reinicie todos os contêineres após mover o diretório docker.

Gere TFLite SDK com estação de trabalho Linux

O fluxo de trabalho do TFLite SDK pode ser habilitado sem contêineres usando a estação de trabalho Linux. Este procedimento é uma alternativa ao uso de containers.
Para sincronizar e criar o SDK Qualcomm TFLite, faça o seguinte:

1. Crie um diretório no host file sistema para sincronizar o espaço de trabalho do Qualcomm TFLite SDK. Para exampem:
   $mkdir
   $cd
2. Obtenha o código-fonte do Qualcomm TFLite SDK em CodeLinaro:
   $ repo init -u https://git.codelinaro.org/clo/le/sdktflite/tflite/ manifest.git –repo-branch=qc/stable –repo-url=git://git.quicinc.com/tools/repo.git -m TFLITE.SDK.1.0.r1-00200-TFLITE.0.xml -b release && repo sync -qc –no-tags -j8 && sincronização de repositório -qc –no-tags -j8
3. 3. Edite a configuração JSON file presente em /tflite-tools/targets/le-tflite-tools-builder.json com as seguintes entradas
   “Imagem”: “tflite-tools-builder”, “Device_OS”: “le”, “Additional_tag”: “”, “TFLite_Version”: “2.11.1”, “Delegados”: { “Hexagon_delegate”: “OFF”, “Gpu_delegate”: “ON”, “Xnnpack_delegate”: “ON” }, “TFLite_rsync_destination”: “ ”, “SDK_path”: “/build-qti-distro-fullstack-perf/tmpglibc/deploy/sdk>”, “SDK_shell_file”: “”, “Base_Dir_Location”: “”
   Para obter mais informações sobre as entradas mencionadas na configuração json file, consulte o leia-me do Docker.md file no /tflite-tools/.
   OBSERVAÇÃO Para QCS8550, o delegado Hexagon DSP não é suportado
4. Obtenha o script para configurar o ambiente:
   $cd /tflite-ferramentas
   $ fonte./scripts/host/host_env_setup.sh
5. Crie o SDK TFLite da Qualcomm.
   $ tflite-tools-setup alvos/le-tflite-tools-builder.json
6.  Execute os seguintes comandos utilitários no mesmo shell do Linux para coletar os artefatos do TFLite SDK de 
   TFLite_rsync_destination.
   $ tflite-tools-host-get-rel-package alvos/le-tflite-tools-builder.json
   $ tflite-tools-host-get-dev-package alvos/le-tflite-tools-builder.json
7. Instale artefatos com base no sistema operacional
   • Para a plataforma Windows, no PowerShell, use o seguinte script
     PS C:> adb root PS C:> adb disable-verity PS C:> adb reboot PS C:> adb wait-for-device PS C:> adb root PS C:> adb remount PS C:> adb shell mount - o remontar,rw / PS C:> adb shell “mkdir -p /tmp” PS C:> adb push /tmp
     Se o pacote for um ipk (para QCS8550.LE.1.0), use os seguintes comandos:
     PS C:> adb shell “opkg –force-depends –force-reinstall –forceoverwrite install /tmp/
     Para a plataforma Linux, use o seguinte script:
     $ adb root $ adb disable-verity $ adb reboot $ adb wait-for-device $ adb root $ adb remount $ adb shell mount -o remount,rw / $ adb shell “mkdir -p /tmp” $ adb push /tmp Se o pacote for um ipk (para QCS8550.LE.1.0):
     $ adb shell “opkg –force-depends –force-reinstall –force-overwrite install /tmp/”

Gerar artefatos Qualcomm TFLite SDK para construção do QIM SDK

Para usar os artefatos gerados para ativar o plug-in Qualcomm TFLite SDK GStreamer no QIM SDK, faça o seguinte:

1. Conclua o procedimento em Sincronizar e criar o SDK TFLite da Qualcomm e, em seguida, execute o seguinte comando: $ tflite-tools-host-get-dev-tar-package ./targets/le-tflite-toolsbuilder.json
   Um alcatrão file é gerado. Ele contém o SDK Qualcomm TFLite no caminho fornecido em “TFLite_rsync_destination”
2. Para ativar o plug-in Qualcomm TFLite SDK GStreamer, use o tar file como argumento na configuração JSON file para a construção do QIM SDK.
   Para obter informações sobre como compilar o QIM SDK, consulte o Guia de início rápido do Qualcomm Intelligent Multimedia SDK (QIM SDK) (80-50450-51).

Crie o SDK Qualcomm TFLite de forma incremental

Se você estiver criando o SDK do Qualcomm TFLite pela primeira vez, consulte Criar ferramentas do SDK do Qualcomm TFLite – fluxo de trabalho do desenvolvedor. O mesmo ambiente de construção pode ser reutilizado para desenvolvimento incremental.
Os utilitários auxiliares (dentro do contêiner) mencionados na figura estão disponíveis para desenvolvedores compilarem aplicativos e plug-ins modificados.
Figura 5-1 Fluxo de trabalho em um contêiner

Depois que as alterações de código forem concluídas no diretório de códigos, faça o seguinte:

1. Compile o código modificado:
   $ tflite-tools-incremental-build-install
2. Código compilado do pacote:
   $ tflite-tools-ipk-rel-pkg ou $ tflite-tools-deb-rel-pkg
3. Sincronize pacotes de lançamento com o host file sistema:
   $ tflite-tools-remote-sync-ipk-rel-pkg
   Or
   $ tflite-tools-remote-sync-deb-rel-pkg
4. Prepare um pacote de desenvolvimento:
   $ tflite-tools-ipk-dev-pkg
   Os artefatos compilados são encontrados na pasta TFLite_rsync_destination mencionada no JSON file, que pode ser copiado para qualquer diretório.

Trabalhe com o delegado TFLite externo da QNN

Um delegado externo TFLite permite que você execute seus modelos (parte ou todo) em outro executor usando bibliotecas fornecidas por terceiros confiáveis, como QNN da Qualcomm. Esse mecanismo pode aproveitar uma variedade de aceleradores no dispositivo, como GPU ou Hexagon Tensor Processor (HTP) para inferência. Isso fornece aos desenvolvedores um método flexível e desacoplado do TFLite padrão para acelerar a inferência.

Pré-requisitos:

• Certifique-se de usar uma estação de trabalho Ubuntu para extrair a pilha QNN AI.
• Certifique-se de usar um QNN versão 2.14 para estar em conjunto com o Qualcomm TFLite SDK

O Qualcomm TFLite SDK está habilitado para executar inferências em vários back-ends QNN por meio do delegado externo TFLite para QNN. Os modelos TFLite com uma representação flatbuffer comum podem ser executados em GPU e HTP.
Depois que os pacotes Qualcomm TFLite SDK forem instalados no dispositivo, faça o seguinte para instalar as bibliotecas QNN no dispositivo.

1. Baixe o Qualcomm Package Manager 3 para Ubuntu.
   a. Clique em https://qpm.qualcomm.com/ e clique em Ferramentas.
   b. No painel esquerdo, no campo Ferramentas de pesquisa, digite QPM. Na lista Sistema operacional, selecione Linux.
   Os resultados da pesquisa exibem uma lista de gerenciadores de pacotes Qualcomm.
   c. Selecione Qualcomm Package Manager 3 e baixe o pacote debian do Linux.
2. Instale o Qualcomm Package Manager 3 para Linux. Use o seguinte comando:
   $ dpkg -i –force-overwrite /caminho/para/
   QualcommPackageManager3.3.0.83.1.Linux-x86.deb
3. Baixe o Qualcomm®
   AI Engine Direct SDK na estação de trabalho Ubuntu.
   a. Clique em https://qpm.qualcomm.com/ e clique em Ferramentas.
   b. No painel esquerdo, no campo Ferramentas de pesquisa, digite Pilha AI. Na lista Sistema operacional, selecione Linux.
   A uma lista suspensa contendo vários mecanismos de pilha de IA é exibida.
   c. Clique em Qualcomm® AI Engine Direct SDK e baixe o pacote Linux v2.14.0.
4. Instale o Qualcomm® AI Engine Direct SDK na estação de trabalho Ubuntu.
   a. Ative a licença:
   qpm-cli –license-activate qualcomm_ai_engine_direct
   b Instale o SDK direto do AI Engine:
   $ qpm-cli –extrair /caminho/para/ qualcomm_ai_engine_direct.2.14.0.230828.Linux-AnyCPU.qik
5. Envie bibliotecas para o dispositivo a partir da estação de trabalho Ubuntu com adb push.
   $ cd /opt/qcom/aistack/qnn/2.14.0.230828 $ adb push ./lib/aarch64-oe-linux-gcc11.2/ libQnnDsp.so /usr/lib/ $ adb push ./lib/aarch64-oe- linux-gcc11.2/ libQnnDspV66Stub.so /usr/lib/ $ adb push ./lib/aarch64-oe-linux-gcc11.2/ libQnnGpu.so /usr/lib/ $ adb push ./lib/aarch64-oe- linux-gcc11.2/ libQnnHtpPrepare.so /usr/lib/ $ adb push ./lib/aarch64-oe-linux-gcc11.2/ libQnnHtp.so /usr/lib/ $ adb push ./lib/aarch64-oe- linux-gcc11.2/ libQnnHtpV68Stub.so /usr/lib/ $ adb push ./lib/aarch64-oe-linux-gcc11.2/ libQnnSaver.so /usr/lib/ $ adb push ./lib/aarch64-oe- linux-gcc11.2/ libQnnSystem.so /usr/lib/ $ adb push ./lib/aarch64-oe-linux-gcc11.2/ libQnnTFLiteDelegate.so /usr/lib/ $ adb push ./lib/hexagon-v65/ não assinado/ libQnnDspV65Skel.so /usr/lib/rfsa/adsp $ adb push ./lib/hexagon-v66/unsigned/ libQnnDspV66Skel.so /usr/lib/rfsa/adsp $ adb push ./lib/hexagon-v68/unsigned/ libQnnHtpV68Skel.so /usr/lib/rfsa/adsp $ adb push ./lib/hexagon-v69/unsigned/ libQnnHtpV69Skel.so /usr/lib/rfsa/adsp $ adb push ./lib/hexagon-v73/unsigned/ libQnnHtpV73Skel. então /usr/lib/rfsa/adsp

Teste o SDK TFLite da Qualcomm

O Qualcomm TFLite SDK fornece certos example aplicativos, que podem ser usados ​​para validar, comparar e obter a precisão dos modelos que um desenvolvedor deseja avaliar.
Depois que os pacotes Qualcomm TFLite SDK forem instalados no dispositivo, o tempo de execução estará disponível no dispositivo para executar esses example aplicações.
Pré-requisito
Crie os seguintes diretórios no dispositivo:
$ adb shell “mkdir /data/Modelos”
$ adb shell “mkdir /data/Lables”
$ adb shell “mkdir /data/profiling”

Imagem do rótulo

Uma imagem de rótulo é um utilitário fornecido pelo Qualcomm TFLite SDK que mostra como você pode carregar um modelo TensorFlow Lite pré-treinado e convertido e usá-lo para reconhecer objetos em imagens. Pré-requisitos:
Baixar sampmodelo e imagem:
Você pode usar qualquer modelo compatível, mas o modelo MobileNet v1 a seguir oferece uma boa demonstração de um modelo treinado para reconhecer 1000 objetos diferentes.

• Obter modelo
  $curl https://armazenamento.googleapis.com/download.tensorflow.org/models/ mobilenet_v1_2018_02_22/mobilenet_v1_1.0_224.tgz | tar xzv -C /data $ mv /data/mobilenet_v1_1.0_224.tflite /data/Models/
• Obter rótulos
  $curl https://armazenamento.googleapis.com/download.tensorflow.org/models/ mobilenet_v1_1.0_224_frozen.tgz | tar xzv -C /data mobilenet_v1_1.0_224/ rótulos.txt
  $ mv /data/mobilenet_v1_1.0_224/labels.txt /data/Labels/
  Depois de se conectar ao contêiner docker Qualcomm TFLite SDK, a imagem pode ser encontrada em:
  “/mnt/tflite/src/tensorflow/tensorflow/lite/examparquivos/label_image/testdata/grace_hopper.bmp”
  a. Empurre isso file para/dados/rótulos/
  b. Execute o comando:
  $ adb shell “label_image -l /data/Labels/labels.txt -i /data/Labels/ grace_hopper.bmp -m /data/Models/mobilenet_v1_1.0_224.tflite -c 10 -j 1 -p 1”

Referência

O Qualcomm TFLite SDK fornece a ferramenta de benchmarking para calcular o desempenho de vários tempos de execução.
Atualmente, essas ferramentas de benchmark medem e calculam estatísticas para as seguintes métricas de desempenho importantes:

• Tempo de inicialização
• Tempo de inferência do estado de aquecimento
• Tempo de inferência de estado estacionário
• Uso de memória durante o tempo de inicialização
• Uso geral de memória

Pré-requisitos

Envie os modelos a serem testados no TFLite Model Zoo (https://tfhub.dev/) para/dados/Modelos/. Execute o seguintes roteiros:  

• Pacote XNN
  $ adb shell “benchmark_model –graph=/data/Models/ — enable_op_profiling=true –use_xnnpack=true –num_threads=4 –max_secs=300 –profiling_output_csv_file=/dados/perfil/”
• Delegado da GPU
  $ adb shell “benchmark_model –graph=/data/Models/ — enable_op_profiling=true –use_gpu=true –num_runs=100 –warmup_runs=10 — max_secs=300 –profiling_output_csv_file=/dados/perfil/”
• Delegado Externo
  GPU Delegada Externa QNN:
  Execute a inferência com o modelo de ponto flutuante:
  $ adb shell-command “benchmark_model –graph=/data/Models/ .tflite –external_delegate_path=libQnnTFLiteDelegate.so — external_delegate_options='backend_type:gpu;library_path:/usr/lib/ libQnnGpu.so;skel_library_dir:/usr/lib/rfsa /adsp’”
  HTP do Delegado Externo QNN:
  Execute a inferência com o modelo quântico:
  $ adb shell-command “benchmark_model –graph=/data/Models/ .tflite –external_delegate_path=libQnnTFLiteDelegate.so — external_delegate_options='backend_type:htp;library_path:/usr/lib/ libQnnHtp.so;skel_library_dir:/usr/lib/rfsa /adsp’”

Ferramenta de precisão

O Qualcomm TFLite SDK fornece uma ferramenta de precisão para calcular a precisão de modelos com vários tempos de execução.

• Classificação com delegado GPU
  As etapas para baixar o necessário files para testar podem ser encontrados em: “/mnt/tflite/src/tensorflow/tensorflow/lite/tools/evaluation/tasks/ imagenet_image_classificatio/README.md”
  O binário para executar esta ferramenta já faz parte do SDK, portanto o desenvolvedor não precisa compilá-lo novamente.
  $ adb shell “image_classify_run_eval – modelo_file=/dados/Modelos/ –ground_truth_images_path=/data/ — ground_truth_labels=/data/ –model_output_labels=/ dados/ –delegate=gpu”
• Detecção de objetos com pacote XNN
  $ adb shell “inf_diff_run_eval –model_file=/dados/Modelos/ –delegate=xnnpac

INFORMAÇÕES LEGAIS

Seu acesso e uso deste documento, juntamente com quaisquer especificações, quadro de referência files, desenhos, diagnósticos e outras informações contidas neste documento (coletivamente, este "Documentação"), está sujeito ao seu (incluindo a corporação ou outra entidade legal que você representa, coletivamente “Você” ou “Seu”) aceitação dos termos e condições ("Termos de uso") definido abaixo. Se Você não concordar com estes Termos de Uso, você não poderá usar esta Documentação e deverá destruir imediatamente qualquer cópia dela.

1. Notícia legal.
   Esta Documentação está sendo disponibilizada a Você exclusivamente para Seu uso interno com as ofertas de produtos e serviços da Qualcomm Technologies, Inc. (“Qualcomm Technologies”) e suas afiliadas descritas nesta Documentação, e não deve ser usada para quaisquer outros fins. Esta Documentação não pode ser alterada, editada ou modificada de qualquer forma sem a aprovação prévia por escrito da Qualcomm Technologies. O uso ou divulgação não autorizada deste
   A documentação ou as informações aqui contidas são estritamente proibidas, e Você concorda em indenizar a Qualcomm Technologies, suas afiliadas e licenciadores por quaisquer danos ou perdas sofridas pela Qualcomm Technologies, suas afiliadas e licenciadores por quaisquer usos não autorizados ou divulgações desta Documentação, no todo ou papel. A Qualcomm Technologies, suas afiliadas e licenciadores detêm todos os direitos e propriedade desta Documentação. Nenhuma licença para qualquer marca registrada, patente, direito autoral, direito de proteção de máscara ou qualquer outro direito de propriedade intelectual é concedida ou implícita por esta Documentação ou qualquer informação aqui divulgada, incluindo, mas não limitado a, qualquer licença para fazer, usar, importar ou vender qualquer oferta de produto, serviço ou tecnologia que incorpore qualquer informação nesta Documentação.
   ESTA DOCUMENTAÇÃO É FORNECIDA “NO ESTADO EM QUE SE ENCONTRA”, SEM GARANTIA DE QUALQUER TIPO, SEJA EXPRESSA, IMPLÍCITA, ESTATUTÁRIA OU OUTRA. NA MEDIDA MÁXIMA PERMITIDA POR LEI, A QUALCOMM TECHNOLOGIES, SUAS AFILIADAS E LICENCIADORES ESPECIFICAMENTE SE ISENTAM DE TODAS AS GARANTIAS DE TÍTULO, COMERCIALIZAÇÃO, NÃO VIOLAÇÃO, ADEQUAÇÃO A UM DETERMINADO FIM, QUALIDADE SATISFATÓRIA, INTEGRIDADE OU PRECISÃO, E TODAS AS GARANTIAS DECORRENTES DO USO COMERCIAL OU FORA DE UM CURSO DE NEGOCIAÇÃO OU CURSO DE DESEMPENHO. ALÉM DISSO, NEM A QUALCOMM TECHNOLOGIES, NEM QUALQUER DE SUAS AFILIADAS OU LICENCIADORES SERÃO RESPONSÁVEIS PERANTE VOCÊ OU QUALQUER TERCEIRO POR QUAISQUER DESPESAS, PERDAS, USO OU AÇÕES INCORRIDAS OU REALIZADAS POR VOCÊ COM CONFIANÇA NESTA DOCUMENTAÇÃO.
   Certos kits de produtos, ferramentas e materiais mencionados nesta Documentação podem exigir que Você aceite termos e condições adicionais antes de acessar ou usar esses itens.
   Os dados técnicos especificados nesta Documentação podem estar sujeitos às leis dos EUA e outras leis de controle de exportação aplicáveis. A transmissão contrária aos EUA e qualquer outra lei aplicável é estritamente proibida.
   Nada nesta Documentação representa uma oferta de venda de qualquer um dos componentes ou dispositivos aqui mencionados.
   Esta Documentação está sujeita a alterações sem notificação adicional. Em caso de conflito entre estes Termos de Uso e o Webtermos de uso do site em www.qualcomm.com ou a Política de Privacidade da Qualcomm mencionada em www.qualcomm.com, estes Termos de Uso prevalecerão. No caso de conflito entre estes Termos de Uso e qualquer outro contrato (escrito ou por meio de clique) executado por Você e pela Qualcomm Technologies ou por uma afiliada da Qualcomm Technologies com relação ao Seu acesso e uso desta Documentação, o outro contrato controlará .
   Estes Termos de Uso serão regidos, interpretados e aplicados de acordo com as leis do Estado da Califórnia, excluindo a Convenção das Nações Unidas sobre Venda Internacional de Mercadorias, sem levar em conta conflitos de princípios legais. Qualquer disputa, reclamação ou controvérsia decorrente ou relacionada a estes Termos de Uso, ou à violação ou validade destes, será julgada apenas por um tribunal de jurisdição competente no condado de San Diego, Estado da Califórnia, e Você, por meio deste, concorda em a jurisdição pessoal de tais tribunais para esse fim.
2. Declarações de atribuição de marca registrada e produto.
   Qualcomm é uma marca comercial ou marca registrada da Qualcomm Incorporated. Arm é uma marca registrada da Arm Limited (ou de suas subsidiárias) nos EUA e/ou em outros lugares. A marca Bluetooth® é uma marca registrada de propriedade da Bluetooth SIG, Inc. Outros produtos e nomes de marcas mencionados nesta documentação podem ser marcas comerciais ou marcas registradas de seus respectivos proprietários.
   Os produtos das marcas Snapdragon e Qualcomm mencionados nesta documentação são produtos da Qualcomm Technologies, Inc. e/ou de suas subsidiárias. As tecnologias patenteadas da Qualcomm são licenciadas pela Qualcomm Incorporated.