Guida per l'utente del software Qualcomm TensorFlow Lite SDK
Cronologia delle revisioni
| Revisione | Data | Descrizione |
| AA | Settembre 2023 | Versione iniziale |
| AB | Ottobre 2023 |
|
Introduzione agli strumenti SDK Qualcomm TFLite
Gli strumenti del kit di sviluppo software Qualcomm TensorFlow Lite (Qualcomm TFLite SDK) forniscono il framework TensorFlow Lite per l'inferenza dell'intelligenza artificiale (AI) sul dispositivo, che facilita gli sviluppatori di applicazioni nello sviluppo o nell'esecuzione di applicazioni AI adeguate.
Questo documento fornisce istruzioni dettagliate per compilare un SDK Qualcomm TFLite autonomo e configurare l'ambiente di sviluppo. Ciò abilita il flusso di lavoro dello sviluppatore, che include:
- impostare l'ambiente di compilazione in cui lo sviluppatore può compilare l'SDK Qualcomm TFLite
- sviluppo di applicazioni SDK Qualcomm TFLite autonome
Per supporto, vedere https://www.qualcomm.com/supporto. La figura seguente fornisce un riepilogo del flusso di lavoro dell'SDK Qualcomm TFLite: "
Figura 1-1 Flusso di lavoro dell'SDK Qualcomm TFLite
Lo strumento richiede un SDK della piattaforma e una configurazione file (formato JSON) per generare gli artefatti dell'SDK Qualcomm TFLite.
Per creare un'applicazione end-to-end utilizzando sottosistemi multimediali, AI e visione artificiale (CV), vedere la Guida introduttiva rapida di Qualcomm Intelligent Multimedia SDK (QIM SDK) (80-50450-51).
La tabella mostra la mappatura della versione dell'SDK Qualcomm TFLite con la versione CodeLinaro tag:
Tabella 1-1 Informazioni sulla versione
| Versione dell'SDK Qualcomm TFLite | Versione CodeLinaro tag |
| V1.0 | Qualcomm TFLITE.SDK.1.0.r1-00200-TFLITE.0 |
Tabella 1-2 Versioni SDK Qualcomm TFLite supportate
| Qualcomm Versione dell'SDK TFLite | Prodotto software supportato | Versione TFLite supportata |
| V1.0 | QCS8550.LE.1.0 |
|
|
||
|
||
|
||
|
||
|
Riferimenti
Tabella 1-3 Documenti correlati
| Titolo | Numero |
| Qualcomm | |
| 00067.1 Nota sulla versione per QCS8550.LE.1.0 | Numero di telefono: RNO-230830225415 |
| Guida introduttiva dell'SDK multimediale intelligente di Qualcomm (SDK QIM). | Numero di telefono: 80-50450-51 |
| Riferimento all'SDK multimediale intelligente di Qualcomm (SDK QIM). | Numero di telefono: 80-50450-50 |
| Risorse | |
| https://source.android.com/docs/setup/start/initializing | – |
Tabella 1-4 Acronimi e definizioni
| Acronimo o termine | Definizione |
| AI | Intelligenza artificiale |
| BIOGRAFIA | Sistema di input/output di base |
| CV | Visione artificiale |
| IPK | È un pacchetto fantastico file |
| SDK QIM | Kit di sviluppo software multimediale intelligente Qualcomm |
| Kit di sviluppo software | Kit di sviluppo software |
| TFlite | TensorFlow Lite |
| XNN | Xth vicino più prossimo |
Configura l'ambiente di compilazione per gli strumenti SDK Qualcomm TFLite
Gli strumenti Qualcomm TFLite SDK vengono rilasciati in formato sorgente; pertanto, stabilire l'ambiente di compilazione per compilarlo è un'impostazione obbligatoria ma una tantum.
Prerequisiti
- Assicurati di avere sudoaccess al computer host Linux.
- Assicurati che la versione dell'host Linux sia Ubuntu 18.04 o Ubuntu 20.04.
- Aumenta il numero massimo di controlli utente e il numero massimo di istanze utente sul sistema host.
- Aggiungere le seguenti righe di comando a/etc/sysctl.conf e riavviare l'host: fs.inotify.max_user_instances=8192 fs.inotify.max_user_watches=542288
Installa i pacchetti host richiesti
I pacchetti host vengono installati sulla macchina host Linux.
Esegui i comandi per installare i pacchetti host: $ sudo apt install -y jq $ sudo apt install -y texinfo chrpath libxml-simple-perl openjdk-8-jdkheadless
Per Ubuntu 18.04 e versioni successive:
$ 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 unzip fontconfig
Per ulteriori informazioni, vedere https://ssource.android.com/docs/setup/start/initializing.
Configura l'ambiente docker
Una finestra mobile è una piattaforma utilizzata per creare, sviluppare, testare e distribuire software. Per compilare l'SDK, la finestra mobile deve essere configurata sul computer host Linux.
Assicurarsi che la virtualizzazione della CPU sia abilitata sul computer host Linux. Se non è abilitato, procedere come segue per abilitarlo dalle impostazioni di configurazione del BIOS (Basic Input/Output System):
- Abilita la virtualizzazione dal BIOS:
a. Premi F1 o F2 durante l'avvio del sistema per accedere al BIOS. Viene visualizzata la finestra del BIOS.
b. Passa alla scheda Avanzate.
c. Nella sezione Configurazione CPU, imposta Tecnologia di virtualizzazione su Abilitato.
a. Premere F12 per salvare ed uscire, quindi riavviare il sistema.
Se questi passaggi non funzionano, seguire le istruzioni specifiche del fornitore del sistema per abilitare la virtualizzazione - Rimuovi eventuali vecchie istanze della finestra mobile:
$ sudo apt rimuovi docker-desktop
$ rm -r $HOME/.docker/desktop
$ sudo rm /usr/local/bin/com.docker.cli
$ sudo apt purge docker-desktop - Configura il repository remoto 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) Signed-by=/etc/apt/ keyrings/ docker.gpg] https:// download.docker.com/linux/ubuntu $ (lsb_release -cs) stabile” | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null - Installa il motore docker:
$ sudo apt-get update $ sudo apt-get install docker-ce docker-ce-cli - Aggiungi utente al gruppo docker:
$ sudo groupadd docker $ sudo usermod -aG docker $USER - Riavviare il sistema.
Genera SDK della piattaforma
L'SDK della piattaforma è un requisito obbligatorio per compilare gli strumenti SDK di Qualcomm TFLite. Fornisce tutte le dipendenze della piattaforma richieste dall'SDK Qualcomm TFLite.
Effettuare le seguenti operazioni per generare l'SDK della piattaforma:
- Creare una build per il prodotto software preferito.
Le istruzioni per creare la versione QCS8550.LE.1.0 sono fornite nelle note sulla versione. Per accedere alle note sulla versione, vedere Riferimenti.
Se le immagini sono state create in precedenza, esegui il passaggio 2, quindi crea una build pulita. - Esegui il comando seguente per creare le immagini dello spazio utente e l'SDK della piattaforma:
Per QCS8550.LE.1.0, aggiungere la funzione macchina qti-tflite-delegate in MACHINE_FEATURES in kalama.conf file e procurarsi l'ambiente di compilazione secondo le istruzioni contenute nelle note di rilascio.
Dopo aver generato le immagini dello spazio utente dalla build, esegui il comando seguente per generare l'SDK della piattaforma.
$ bitbake -fc populate_sdk immagine-qti-robotica
Crea strumenti SDK Qualcomm TFLite: flusso di lavoro per sviluppatori
Il flusso di lavoro degli strumenti dell'SDK Qualcomm TFLite richiede che lo sviluppatore fornisca la configurazione file con voci di input valide. Gli script di shell di supporto del progetto tflite-tools (presenti nell'albero dei sorgenti dell'SDK di Qualcomm TFLite) forniscono funzioni di utilità di supporto per configurare l'ambiente della shell, che può essere utilizzato per il flusso di lavoro dell'SDK di Qualcomm TFLite.
Lo sviluppatore crea i progetti SDK Qualcomm TFLite all'interno del contenitore e genera gli artefatti utilizzando le utilità fornite da tflite-tools.
Dopo aver creato un contenitore SDK Qualcomm TFLite, lo sviluppatore può collegarsi al contenitore e utilizzare le utilità di supporto nell'ambiente della shell del contenitore per lo sviluppo continuo.
- È disponibile una disposizione per installare gli artefatti Qualcomm TFLite SDK su un dispositivo Qualcomm connesso all'host Linux tramite USB/adb.
- È inoltre disponibile la possibilità di copiare gli artefatti dell'SDK Qualcomm TFLite dal contenitore a un computer host diverso a cui è connesso il dispositivo Qualcomm.
La figura seguente elenca l'insieme di utilità disponibili dopo aver configurato l'ambiente di creazione del contenitore utilizzando gli script di supporto per creare l'SDK Qualcomm TFLite.
La figura mostra la sequenza di esecuzione delle utilità:
Figura 4-3 Sequenza di utilità sull'host
Sincronizza e crea l'SDK Qualcomm TFLite
L'SDK Qualcomm TFLite viene compilato quando viene creata l'immagine docker. Per sincronizzare e creare l'SDK Qualcomm TFLite, procedi come segue:
- Creare una directory sull'host file sistema per sincronizzare l'area di lavoro dell'SDK Qualcomm TFLite. Per
exampon: $mkdir $cd - Recupera il codice sorgente dell'SDK Qualcomm TFLite da 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 && sincronizzazione del repository -qc –no-tags -j - Creare una directory sull'host file sistema che può essere montato nella finestra mobile. Per esample: mkdir-p / Questa directory può essere creata ovunque sul computer host Linux e non dipende da dove è sincronizzato il progetto Qualcomm TFLite SDK. Una volta completato il flusso di lavoro all'interno del contenitore, gli artefatti dell'SDK Qualcomm TFLite possono essere trovati nella directory creata in questo passaggio.
- Modifica la configurazione JSON file presente in /tflite-tools/targets/le-tflite-tools-builder.json con le seguenti voci:
“Immagine”: “tflite-tools-builder”, “Device_OS”: “le”, “Additional_tag”: “”, “TFLite_Version”: “2.11.1”, “Delegates”: { “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”: “” }
Per ulteriori informazioni sulle voci menzionate nella configurazione json file, vedere il file Leggimi di Docker.md file in /tflite-tools/.
NOTA Per QCS8550, il delegato DSP Qualcomm® Hexagon™ non è supportato. - Ottieni lo script per configurare l'ambiente:
$cd /tflite-tools $ source ./scripts/host/docker_env_setup.sh - Crea l'immagine docker dell'SDK Qualcomm TFLite: $ tflite-tools-host-build-image ./targets/le-tflite-tools-builder.json Se la configurazione della build non riesce, vedi Risolvere i problemi di configurazione della finestra mobile. Dopo il completamento con successo, viene visualizzato il seguente messaggio: "Stato: creazione immagine completata con successo!!" L'esecuzione di questo passaggio crea anche l'SDK Qualcomm TFLite.
- Eseguire il contenitore docker Qualcomm TFLite SDK. Questo avvia il contenitore con il tags fornito nella configurazione JSON file. $tflite-tools-host-run-container ./targets/le-tflite-tools-builder.json
- Allega al contenitore iniziato dal passaggio precedente.
$ finestra mobile allegata
L'SDK Qualcomm TFLite è stato compilato e gli artefatti sono pronti per essere distribuiti o possono essere ulteriormente implementati
utilizzato per generare il plug-in QIM SDK TFLite.
Connetti il dispositivo all'host e distribuisci gli artefatti]
Dopo la compilazione, esistono due meccanismi per connettere il dispositivo a un host e distribuirlo
Artefatti dell'SDK Qualcomm TFLite.
- Dispositivo connesso a un host Linux locale:
Uno sviluppatore connette il dispositivo a una workstation e installa gli artefatti dell'SDK Qualcomm TFLite dal contenitore direttamente sul dispositivo (QCS8550). - Dispositivo connesso a un host remoto:
Uno sviluppatore connette il dispositivo a una workstation remota e può utilizzare i comandi del programma di installazione di Pack Manager su piattaforme Windows e Linux per installare gli artefatti dell'SDK Qualcomm TFLite sul dispositivo (QCS8550)
Figura 4-4 Collegamento della scheda del dispositivo allo sviluppatore e alla workstation remota
Collega il dispositivo alla workstation
Il dispositivo è connesso alla workstation e il contenitore di sviluppo può accedere al dispositivo tramite USB/adb.
La figura mostra la stages nella sequenza del flusso di lavoro dell'SDK Qualcomm TFLite:
- Esegui i seguenti comandi per installare gli artefatti sul dispositivo:
$ tflite-tools-device-prepare
$ tflite-tools-device-deploy - Per disinstallare gli artefatti, eseguire il comando seguente:
$ tflite-tools-device-packages-remove
Connetti il dispositivo alla macchina remota
Il dispositivo è connesso a un computer remoto e il contenitore Qualcomm TFLite SDK non può accedere al dispositivo tramite USB/annuncio b.
La figura mostra la stages nella sequenza del flusso di lavoro dell'SDK Qualcomm TFLite:
Esegui i comandi seguenti nel contenitore tflite-tools per copiare gli artefatti su un computer remoto
a seconda del gestore pacchetti sul dispositivo:
$ tflite-tools-remote-sync-ipk-rel-pkg
NOTA Le informazioni sulla macchina remota vengono fornite nella configurazione JSON file.
Installa artefatti per la piattaforma Windows
Gli artefatti dell'SDK Qualcomm TFLite possono essere installati sul dispositivo in base al sistema operativo del computer remoto.
Per la piattaforma Windows, procedere come segue:
In PowerShell utilizzare il seguente script: PS C:
> adb root PS C:> adb disattiva-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 il pacchetto è un ipk (per QCS8550.LE.1.0), utilizzare i seguenti comandi: PS C:> adb shell “ opkg –force-depends –force-reinstall –force-overwrite install /tmp/”
Installa artefatti per la piattaforma Linux
Utilizzare i seguenti comandi:
$ adb root $ adb disattiva-verità $ 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 il pacchetto è un ipk (per QCS8550.LE.1.0): $ adb shell “opkg –force-depends –force-reinstall –force-overwrite install /tmp/”
Pulisci l'immagine della finestra mobile
Dopo aver completato il flusso di lavoro dello sviluppatore, l'ambiente docker deve essere pulito per liberare spazio di archiviazione sul disco. La pulizia della finestra mobile rimuove i contenitori e le immagini non utilizzati, liberando così spazio su disco.
Utilizzare i seguenti comandi per pulire l'immagine docker:
- Eseguire il comando seguente sulla workstation Linux:
$cd /tflite-strumenti - Fermare il contenitore:
$ tflite-tools-host-stop-container ./targets/ le-tflite-tools-builder.json - Rimuovere il contenitore:
$ tflite-tools-host-rm-container ./targets/ le-tflite-tools-builder.json - Rimuovi le immagini della finestra mobile più vecchie:
$ tflite-tools-host-images-cleanup
Risolvere i problemi di configurazione della finestra mobile
Se il comando tflite-tools-host-build-image restituisce un messaggio Nospace left on device, sposta la directory docker in/local/mnt. Effettuare le seguenti operazioni per risolvere i problemi di configurazione:
- Eseguire il backup della finestra mobile esistente files:
$ tar -zcC /var/lib docker > /mnt/pd0/var_lib_docker-backup-$(data + %s).tar.gz - Arresta la finestra mobile:
Arresto della finestra mobile del servizio $ - Verifica che nessun processo docker sia in esecuzione:
$ps falso | finestra mobile grep - Controlla la struttura della directory della finestra mobile:
$ sudo ls /var/lib/docker/ - Sposta la directory docker in una nuova partizione:
$ mv /var/lib/docker /local/mnt/docker - Crea un collegamento simbolico alla directory docker nella nuova partizione:
$ ln -s /local/mnt/docker /var/lib/docker - Assicurati che la struttura della directory della finestra mobile rimanga invariata:
$ sudo ls /var/lib/docker/ - Avvia finestra mobile:
Avvio della finestra mobile del servizio $ - Riavvia tutti i contenitori dopo aver spostato la directory docker.
Genera SDK TFLite con workstation Linux
Il flusso di lavoro dell'SDK TFLite può essere abilitato senza contenitori utilizzando la workstation Linux. Questa procedura è un'alternativa all'utilizzo dei contenitori.
Per sincronizzare e creare l'SDK Qualcomm TFLite, procedi come segue:
- Creare una directory sull'host file sistema per sincronizzare l'area di lavoro dell'SDK Qualcomm TFLite. Per esampon:
$mkdir
$cd - Recupera il codice sorgente dell'SDK Qualcomm TFLite da 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 && sincronizzazione del repository -qc –no-tags -j8 && sincronizzazione del repository -qc –no-tags -j8 - 3. Modifica la configurazione JSON file presente in /tflite-tools/targets/le-tflite-tools-builder.json con le seguenti voci
“Immagine”: “tflite-tools-builder”, “Device_OS”: “le”, “Additional_tag”: “”, “TFLite_Version”: “2.11.1”, “Delegates”: { “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”: “”
Per ulteriori informazioni sulle voci menzionate nella configurazione json file, vedere il file Leggimi di Docker.md file A /tflite-tools/.
NOTA Per QCS8550, il delegato Hexagon DSP non è supportato - Ottieni lo script per configurare l'ambiente:
$cd /tflite-strumenti
$ source ./scripts/host/host_env_setup.sh - Costruisci l'SDK Qualcomm TFLite.
$ tflite-tools-setup target/le-tflite-tools-builder.json - Esegui i seguenti comandi dell'utilità nella stessa shell Linux da cui raccogliere gli artefatti dell'SDK TFLite
TFLite_rsync_destinazione.
$ tflite-tools-host-get-rel-package target/le-tflite-tools-builder.json
$ tflite-tools-host-get-dev-package target/le-tflite-tools-builder.json - Installare artefatti in base al sistema operativo
- Per la piattaforma Windows, in PowerShell utilizzare lo script seguente
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 rimontare,rw / PS C:> adb shell “mkdir -p /tmp” PS C:> adb push /tmp
Se il pacchetto è un ipk (per QCS8550.LE.1.0), utilizzare i seguenti comandi:
PS C:> adb shell “opkg –force-depends –force-reinstall –forceoverwrite install /tmp/
Per la piattaforma Linux, utilizzare il seguente script:
$ adb root $ adb disattiva-verità $ 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 il pacchetto è un ipk (per QCS8550.LE.1.0):
$ adb shell “opkg –force-depends –force-reinstall –force-overwrite install /tmp/”
- Per la piattaforma Windows, in PowerShell utilizzare lo script seguente
Genera artefatti Qualcomm TFLite SDK per la build QIM SDK
Per utilizzare gli artefatti generati per abilitare il plug-in Qualcomm TFLite SDK GStreamer in QIM SDK, procedere come segue:
- Completa la procedura in Sync e crea Qualcomm TFLite SDK, quindi esegui il seguente comando: $ tflite-tools-host-get-dev-tar-package ./targets/le-tflite-toolsbuilder.json
Un catrame file è generato. Contiene l'SDK Qualcomm TFLite nel percorso fornito in “TFLite_rsync_destinazione” - Per abilitare il plug-in Qualcomm TFLite SDK GStreamer, utilizzare il file tar file come argomento nella configurazione JSON file per la build dell'SDK QIM.
Per informazioni sulla compilazione dell'SDK QIM, consultare la Guida di avvio rapido dell'SDK Qualcomm Intelligent Multimedia (SDK QIM) (80-50450-51).
Crea l'SDK Qualcomm TFLite in modo incrementale
Se stai creando l'SDK Qualcomm TFLite per la prima volta, vedi Creare strumenti SDK Qualcomm TFLite – flusso di lavoro per sviluppatori. Lo stesso ambiente di compilazione può essere riutilizzato per lo sviluppo incrementale.
Le utilità di supporto (all'interno del contenitore) menzionate nella figura sono a disposizione degli sviluppatori per compilare applicazioni e plug-in modificati.
Figura 5-1 Flusso di lavoro in un contenitore
Una volta completate le modifiche al codice nella directory del codice, procedere come segue:
- Compila il codice modificato:
$ tflite-tools-incremental-build-install - Codice compilato del pacchetto:
$ tflite-tools-ipk-rel-pkg o $ tflite-tools-deb-rel-pkg - Sincronizza i pacchetti di rilascio con l'host file sistema:
$ tflite-tools-remote-sync-ipk-rel-pkg
Or
$ tflite-tools-remote-sync-deb-rel-pkg - Prepara un pacchetto di sviluppo:
$ tflite-tools-ipk-dev-pkg
Gli artefatti compilati si trovano nella cartella TFLite_rsync_destination menzionata nel JSON file, che può essere copiato in qualsiasi directory.
Lavora con il delegato TFLite esterno QNN
Un delegato esterno TFLite ti consente di eseguire i tuoi modelli (parte o intero) su un altro esecutore utilizzando le librerie fornite da una terza parte fidata come QNN di Qualcomm. Questo meccanismo può sfruttare una varietà di acceleratori sul dispositivo come la GPU o il processore Hexagon Tensor (HTP) per l'inferenza. Ciò fornisce agli sviluppatori un metodo flessibile e disaccoppiato dal TFLite predefinito per accelerare l'inferenza.
Prerequisiti:
- Assicurati di utilizzare una workstation Ubuntu per estrarre lo stack AI QNN.
- Assicurati di utilizzare una versione QNN 2.14 da utilizzare insieme all'SDK Qualcomm TFLite
L'SDK Qualcomm TFLite è abilitato per eseguire inferenze su diversi back-end QNN tramite il delegato esterno TFLite per QNN. I modelli TFLite con una rappresentazione flatbuffer comune possono essere eseguiti su GPU e HTP.
Dopo aver installato i pacchetti SDK Qualcomm TFLite sul dispositivo, procedere come segue per installare le librerie QNN sul dispositivo.
- Scarica Qualcomm Package Manager 3 per Ubuntu.
a. Fare clic su https://qpm.qualcomm.com/e fare clic su Strumenti.
b. Nel riquadro sinistro, nel campo Strumenti di ricerca, digitare QPM. Dall'elenco Sistema operativo, seleziona Linux.
I risultati della ricerca mostrano un elenco di gestori di pacchetti Qualcomm.
c. Seleziona Qualcomm Package Manager 3 e scarica il pacchetto Debian Linux. - Installa Qualcomm Package Manager 3 per Linux. Utilizzare il seguente comando:
$ dpkg -i –forza-sovrascrivi /percorso/a/
QualcommPackageManager3.3.0.83.1.Linux-x86.deb - Scarica Qualcomm®
AI Engine Direct SDK sulla workstation Ubuntu.
a. Fare clic su https://qpm.qualcomm.com/ e fare clic su Strumenti.
b. Nel riquadro sinistro, nel campo Strumenti di ricerca, digitare Stack AI. Dall'elenco Sistema operativo, seleziona Linux.
A viene visualizzato l'elenco a discesa contenente vari motori dello stack AI.
c. Fai clic su Qualcomm® AI Engine Direct SDK e scarica il pacchetto Linux v2.14.0. - Installa Qualcomm® AI Engine Direct SDK sulla workstation Ubuntu.
UN. Attiva la licenza:
qpm-cli –license-activate qualcomm_ai_engine_direct
b Installa l'SDK diretto di AI Engine:
$ qpm-cli –extract /percorso/a/ qualcomm_ai_engine_direct.2.14.0.230828.Linux-AnyCPU.qik - Invia le librerie al dispositivo dalla workstation Ubuntu con 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/ unsigned/ 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. quindi /usr/lib/rfsa/adsp
Prova l'SDK Qualcomm TFLite
L'SDK Qualcomm TFLite fornisce alcuni example, che possono essere utilizzate per convalidare, confrontare e ottenere l'accuratezza dei modelli che uno sviluppatore desidera valutare.
Dopo aver installato i pacchetti SDK Qualcomm TFLite sul dispositivo, il runtime è disponibile sul dispositivo per eseguire questi example applicazioni.
Prerequisito
Creare le seguenti directory sul dispositivo:
$ shell adb “mkdir /data/Modelli”
$ adb shell “mkdir /data/Lables”
$ adb shell “mkdir /data/profiling”
Immagine etichetta
Un'immagine etichetta è un'utilità fornita dall'SDK Qualcomm TFLite che mostra come caricare un modello TensorFlow Lite preaddestrato e convertito e utilizzarlo per riconoscere gli oggetti nelle immagini. Prerequisiti:
Scarica sampil modello e l'immagine:
È possibile utilizzare qualsiasi modello compatibile, ma il seguente modello MobileNet v1 offre una buona dimostrazione di un modello addestrato a riconoscere 1000 oggetti diversi.
- Ottieni il modello
$curl https://storage.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/ - Ottieni etichette
$curl https://storage.googleapis.com/download.tensorflow.org/models/ mobilenet_v1_1.0_224_frozen.tgz | tar xzv -C /data mobilenet_v1_1.0_224/etichette.txt
$ mv /data/mobilenet_v1_1.0_224/labels.txt /data/Labels/
Dopo esserti connesso al contenitore docker Qualcomm TFLite SDK, l'immagine può essere trovata all'indirizzo:
“/mnt/tflite/src/tensorflow/tensorflow/lite/examples/label_image/testdata/grace_hopper.bmp”
a. Spingi questo file a/dati/etichette/
b. Esegui il 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”
Segno di riferimento
L'SDK Qualcomm TFLite fornisce lo strumento di benchmarking per calcolare le prestazioni di vari tempi di esecuzione.
Questi strumenti di benchmark attualmente misurano e calcolano statistiche per i seguenti importanti parametri di prestazione:
- Tempo di inizializzazione
- Tempo di inferenza dello stato di riscaldamento
- Tempo di inferenza di stato stazionario
- Utilizzo della memoria durante il tempo di inizializzazione
- Utilizzo complessivo della memoria
Prerequisiti
Invia i modelli da testare da TFLite Model Zoo (https://tfhub.dev/) a/dati/Modelli/. Corri il seguenti script:
- Pacchetto XNN
$ adb shell “benchmark_model –graph=/data/Models/ — abilita_op_profiling=true –use_xnnpack=true –num_threads=4 –max_secs=300 –profiling_output_csv_file=/dati/profilazione/” - Delegato GPU
$ adb shell “benchmark_model –graph=/data/Models/ — abilita_op_profiling=true –use_gpu=true –num_runs=100 –warmup_runs=10 — max_secs=300 –profiling_output_csv_file=/dati/profilazione/” - Delegato Esterno
GPU delegato esterno QNN:
Esegui l'inferenza con il modello a virgola mobile:
$ 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'”
QNN Delegato esterno HTP:
Esegui l'inferenza con il modello quantitativo:
$ 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'”
Strumento di precisione
L'SDK Qualcomm TFLite fornisce uno strumento di precisione per calcolare la precisione dei modelli con vari tempi di esecuzione.
- Classificazione con delegato GPU
I passaggi per scaricare il necessario fileI messaggi da testare possono essere trovati in: “/mnt/tflite/src/tensorflow/tensorflow/lite/tools/evaluation/tasks/imagenet_image_classificatio/README.md”
Il codice binario per l'esecuzione di questo strumento fa già parte dell'SDK, quindi lo sviluppatore non ha bisogno di crearlo nuovamente.
$ shell adb “image_classify_run_eval — model_file=/data/Models/ –ground_truth_images_path=/data/ — ground_truth_labels=/data/ –model_output_labels=/ data/ –delegate=gpu” - Rilevamento oggetti con pacchetto XNN
$ shell adb “inf_diff_run_eval –model_file=/dati/Modelli/ –delegate=xnnpac
INFORMAZIONI LEGALI
L'accesso e l'utilizzo di questo documento, insieme a eventuali specifiche, scheda di riferimento files, disegni, diagnostica e altre informazioni contenute nel presente documento (collettivamente questo "Documentazione"), è soggetto al tuo (inclusa la società o altra entità legale che rappresenti, collettivamente “Tu” o “Tuo”) accettazione dei termini e delle condizioni ("Termini di utilizzo") esposti di seguito. Se non accetti le presenti Condizioni d'uso, non potrai utilizzare la presente Documentazione e dovrai distruggerne immediatamente qualsiasi copia.
- Avviso legale.
La presente Documentazione viene resa disponibile all'Utente esclusivamente per uso interno con i prodotti e le offerte di servizi di Qualcomm Technologies, Inc. ("Qualcomm Technologies") e le sue affiliate descritte nella presente Documentazione e non deve essere utilizzata per altri scopi. La presente Documentazione non può essere alterata, modificata o modificata in alcun modo senza la previa approvazione scritta di Qualcomm Technologies. Uso o divulgazione non autorizzata di questo
La documentazione o le informazioni qui contenute sono severamente vietate e l'utente accetta di risarcire Qualcomm Technologies, le sue affiliate e i suoi licenziatari per eventuali danni o perdite subiti da Qualcomm Technologies, le sue affiliate e i suoi licenziatari per qualsiasi utilizzo o divulgazione non autorizzata di questa Documentazione, nella sua interezza o parte. Qualcomm Technologies, le sue affiliate e i suoi concessori di licenza mantengono tutti i diritti e la proprietà sulla presente Documentazione. Nessuna licenza su marchi, brevetti, diritti d'autore, diritti di protezione del lavoro con maschere o qualsiasi altro diritto di proprietà intellettuale è concessa o implicita da questa Documentazione o da qualsiasi informazione qui divulgata, inclusa, ma non limitata a, qualsiasi licenza per creare, utilizzare, importare o vendere qualsiasi prodotto, servizio o offerta tecnologica che incorpori una qualsiasi delle informazioni contenute nella presente Documentazione.
LA PRESENTE DOCUMENTAZIONE VIENE FORNITA "COSÌ COM'È" SENZA GARANZIA DI ALCUN TIPO, ESPRESSA, IMPLICITA, LEGALE O ALTRIMENTI. NELLA MISURA MASSIMA CONSENTITA DALLA LEGGE, QUALCOMM TECHNOLOGIES, I SUOI AFFILIATI E I LICENZIANTI ESCLUDONO ESPRESSAMENTE OGNI GARANZIA DI PROPRIETÀ, COMMERCIABILITÀ, NON VIOLAZIONE, IDONEITÀ PER UNO SCOPO PARTICOLARE, QUALITÀ SODDISFACENTE, COMPLETEZZA O ACCURATEZZA E TUTTE LE GARANZIE DERIVANTI DA USO COMMERCIALE O FUORI DA UN CORSO DI TRATTATIVE O DA UNA PRESTAZIONE. INOLTRE, NÉ QUALCOMM TECHNOLOGIES, NÉ ALCUNA DELLE SUE AFFILIATE O LICENZIANTI, SARÀ RESPONSABILE NEI CONFRONTI DELL'UTENTE O DI TERZE PARTI PER SPESE, PERDITE, UTILIZZO O AZIONI IN QUALSIASI MODO SOSTENUTE O INTRAPRESE DALL'UTENTE IN BASE ALLA PRESENTE DOCUMENTAZIONE.
Alcuni kit di prodotti, strumenti e materiali a cui si fa riferimento nella presente Documentazione potrebbero richiedere l'accettazione di termini e condizioni aggiuntivi prima di accedere o utilizzare tali articoli.
I dati tecnici specificati nella presente Documentazione potrebbero essere soggetti alle leggi statunitensi e ad altre leggi applicabili sul controllo delle esportazioni. La trasmissione contraria alle leggi statunitensi e a qualsiasi altra legge applicabile è severamente vietata.
Niente nella presente Documentazione costituisce un'offerta di vendita dei componenti o dei dispositivi a cui si fa riferimento nel presente documento.
La presente documentazione è soggetta a modifiche senza ulteriore notifica. In caso di conflitto tra le presenti Condizioni d'Uso e l' WebCondizioni d'uso del sito su www.qualcomm.com o l'Informativa sulla privacy di Qualcomm a cui si fa riferimento www.qualcomm.com, prevarranno le presenti Condizioni d'uso. In caso di conflitto tra le presenti Condizioni d'uso e qualsiasi altro accordo (scritto o tramite clic) stipulato tra l'utente e Qualcomm Technologies o un'affiliata di Qualcomm Technologies in merito all'accesso e all'utilizzo di questa documentazione, l'altro accordo prevarrà .
Le presenti Condizioni d'uso saranno regolate, interpretate e applicate in conformità con le leggi dello Stato della California, esclusa la Convenzione delle Nazioni Unite sulla vendita internazionale di beni, senza riguardo ai principi di conflitto di leggi. Qualsiasi controversia, reclamo o controversia derivante da o relativa alle presenti Condizioni d'uso, o alla violazione o alla validità delle stesse, sarà giudicata solo da un tribunale della giurisdizione competente nella contea di San Diego, Stato della California, e con la presente l'utente acconsente a la giurisdizione personale di tali tribunali a tal fine. - Dichiarazioni di attribuzione di marchi e prodotti.
Qualcomm è un marchio o un marchio registrato di Qualcomm Incorporated. Arm è un marchio registrato di Arm Limited (o delle sue filiali) negli Stati Uniti e/o altrove. Il marchio denominativo Bluetooth® è un marchio registrato di proprietà di Bluetooth SIG, Inc. Altri nomi di prodotti e marchi citati nella presente Documentazione possono essere marchi o marchi registrati dei rispettivi proprietari.
I prodotti a marchio Snapdragon e Qualcomm a cui si fa riferimento nella presente Documentazione sono prodotti di Qualcomm Technologies, Inc. e/o delle sue filiali. Le tecnologie brevettate Qualcomm sono concesse in licenza da Qualcomm Incorporated.
Documenti / Risorse
 |
Software SDK Qualcomm TensorFlow Lite [pdf] Guida utente Software SDK TensorFlow Lite, software SDK Lite, software SDK, software |
