Brukerveiledning for Qualcomm TensorFlow Lite SDK-programvare

Brukerveiledning for Qualcomm TensorFlow Lite SDK-programvare

Revisjonshistorikk

Revisjon	Dato	Beskrivelse
AA	september 2023	Første utgivelse
AB	oktober 2023	In Generer plattform SDK, oppdaterte kommandoene for å bygge brukerromsbildene og plattformens SDK Lagt til Generer TFLite SDK med Linux arbeidsstasjon Lagt til Arbeid med QNN ekstern TFLite Delegate In Benchmark, oppdaterte skriptene for ekstern delegat

Introduksjon til Qualcomm TFLite SDK-verktøy

Qualcomm TensorFlow Lite-programvareutviklingssettet (Qualcomm TFLite SDK) gir TensorFlow Lite-rammeverket for inferencing av kunstig intelligens (AI) på enheten, som gjør det lettere for applikasjonsutviklere å utvikle eller kjøre passende AI-applikasjoner.
Dette dokumentet gir trinnvise instruksjoner for å kompilere en frittstående Qualcomm TFLite SDK og sette opp utviklingsmiljøet. Dette aktiverer arbeidsflyten for utviklere, som inkluderer:

• sette opp byggemiljøet der utvikleren kan kompilere Qualcomm TFLite SDK
• utvikle frittstående Qualcomm TFLite SDK-applikasjoner

For støtte, se https://www.qualcomm.com/støtte. Følgende figur gir et sammendrag av Qualcomm TFLite SDK-arbeidsflyten: ”
Figur 1-1 Qualcomm TFLite SDK arbeidsflyt
Verktøyet krever en plattform SDK og en konfigurasjon file (JSON-format) for å generere Qualcomm TFLite SDK-artefakter.

For å bygge en ende-til-ende-applikasjon ved hjelp av multimedia, AI og computer vision (CV) subsystemer, se Qualcomm Intelligent Multimedia SDK (QIM SDK) Quick Start Guide (80-50450-51).
Tabellen viser Qualcomm TFLite SDK-versjonskartlegging med CodeLinaro-utgivelse tag:
Tabell 1-1 Utgivelsesinformasjon

Qualcomm TFLite SDK-versjon	CodeLinaro utgivelse tag
V1.0	Qualcomm TFLITE.SDK.1.0.r1-00200-TFLITE.0
	TFLITE.SDK.1.0.r1-00500-TFLITE.0.xml

Tabell 1-2 Støttede Qualcomm TFLite SDK-versjoner

Qualcomm TFLite SDK-versjon	Støttet programvareprodukt	Støttet TFLite-versjon
V1.0	QCS8550.LE.1.0	2.6.0
		2.8.0
		2.10.1
		2.11.1
		2.12.1
		2.13.0

Referanser
Tabell 1-3 Relaterte dokumenter

Tittel	Tall
Qualcomm
00067.1 versjonsmerknad for QCS8550.LE.1.0	RNO-230830225415
Qualcomm Intelligent Multimedia SDK (QIM SDK) Hurtigstartveiledning	80-50450-51
Qualcomm Intelligent Multimedia SDK (QIM SDK) Referanse	80-50450-50
Ressurser
https://source.android.com/docs/setup/start/initializing	–

Tabell 1-4 Akronymer og definisjoner

Akronym eller begrep	Definisjon
AI	Kunstig intelligens
BIOS	Grunnleggende input/output system
CV	Datasyn
IPK	Itsy-pakken file
QIM SDK	Qualcomm Intelligent multimedia programvareutviklingssett
SDK	Programvareutviklingssett
TFLite	TensorFlow Lite
XNN	Xth nærmeste nabo

Sett opp byggemiljø for Qualcomm TFLite SDK-verktøy

Qualcomm TFLite SDK-verktøyene er utgitt i kildeform; Derfor er etablering av byggemiljøet for å kompilere det et obligatorisk men engangsoppsett.

Forutsetninger

• Sørg for at du har sudo-tilgang til Linux-vertsmaskinen.
• Sørg for at Linux-vertsversjonen er Ubuntu 18.04 eller Ubuntu 20.04.
• Øk antallet brukerovervåkinger og maksimale brukerforekomster på vertssystemet.
• Legg til følgende kommandolinjer til/etc/sysctl.conf og start verten på nytt: fs.inotify.max_user_instances=8192 fs.inotify.max_user_watches=542288

Installer nødvendige vertspakker

Vertspakkene er installert på Linux-vertsmaskinen.
Kjør kommandoene for å installere vertspakkene: $ sudo apt install -y jq $ sudo apt install -y texinfo chrpath libxml-simple-perl openjdk-8-jdkheadless
For Ubuntu 18.04 og høyere:
$ 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 fontconfig unzip xsltproc
For mer informasjon, se https://source.android.com/docs/setup/start/initialisering.

Sett opp docker-miljø

En docker er en plattform som brukes til å bygge, utvikle, teste og levere programvare. For å kompilere SDK, må docker være konfigurert på Linux-vertsmaskinen.
Sørg for at CPU-virtualisering er aktivert på Linux-vertsmaskinen. Hvis den ikke er aktivert, gjør du følgende for å aktivere den fra konfigurasjonsinnstillingene for grunnleggende input/output system (BIOS):

1. Aktiver virtualisering fra BIOS:
   a. Trykk F1 eller F2 når systemet starter opp for å gå inn i BIOS. BIOS-vinduet vises.
   b. Bytt til fanen Avansert.
   c. I delen CPU-konfigurasjon, sett Virtualization Technology til Enabled.
   a. Trykk F12 for å lagre og avslutte, og start deretter systemet på nytt.
   Hvis disse trinnene ikke fungerer, følg de spesifikke instruksjonene fra systemleverandøren for å aktivere virtualiseringen
2. Fjern eventuelle gamle forekomster av docker:
   $ sudo apt fjerne docker-desktop
   $ rm -r $HOME/.docker/desktop
   $ sudo rm /usr/local/bin/com.docker.cli
   $ sudo apt purge docker-desktop
3.  Sett opp docker-fjernlageret:
   $ sudo apt-get update $ sudo apt-get install ca-sertifikater 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) stabil" | sudo tee /etc/apt/sources.list.d/ docker.list > /dev/null
4.  Installer docker-motor:
   $ sudo apt-get update $ sudo apt-get install docker-ce docker-ce-cli
5.  Legg til bruker i docker-gruppen:
   $ sudo groupadd docker $ sudo usermod -aG docker $USER
6.  Start systemet på nytt.

Generer plattform SDK

Plattformens SDK er et obligatorisk krav for å kompilere Qualcomm TFLite SDK-verktøyene. Den gir alle nødvendige plattformavhengigheter som kreves av Qualcomm TFLite SDK.
Gjør følgende for å generere plattformens SDK:

1. Lag en build for det foretrukne programvareproduktet.
   Instruksjonene for å bygge QCS8550.LE.1.0-utgaven er gitt i utgivelsesnotatene. For å få tilgang til versjonsnotatene, se Referanser.
   Hvis bildene ble bygget tidligere, utfør trinn 2, og lag deretter en ren build.
2. Kjør følgende kommando for å bygge brukerplassbildene og plattformens SDK:
   For QCS8550.LE.1.0, legg til maskinfunksjonen qti-tflite-delegate i MACHINE_FEATURES i kalama.conf file og kilde byggemiljøet i henhold til instruksjonene fra versjonsnotatene.
   Etter å ha generert brukerplassbilder fra build, kjør følgende kommando for å generere plattformens SDK.
   $ bitbake -fc populate_sdk qti-robotics-image

Bygg Qualcomm TFLite SDK-verktøy – utviklerarbeidsflyt

Arbeidsflyten for Qualcomm TFLite SDK-verktøy krever at utvikleren oppgir konfigurasjonen file med gyldige inndata. Hjelperskallskriptene fra tflite-tools-prosjektet (tilstede i Qualcomm TFLite SDK-kildetreet) gir hjelpeverktøyfunksjoner for å sette opp skallmiljøet, som kan brukes for Qualcomm TFLite SDK-arbeidsflyten.
Utvikleren bygger Qualcomm TFLite SDK-prosjektene i containeren og genererer artefaktene ved hjelp av verktøyene levert av tflite-tools.
Etter at en Qualcomm TFLite SDK-beholder er bygget, kan utvikleren feste til beholderen og bruke hjelpeverktøyene i beholderskallmiljøet for kontinuerlig utvikling.

• Det er en bestemmelse om å installere Qualcomm TFLite SDK-artefakter til en Qualcomm-enhet koblet til Linux-verten via USB/adb.
• Det er også en bestemmelse om å kopiere Qualcomm TFLite SDK-artefakter fra beholderen til en annen vertsmaskin der Qualcomm-enheten er tilkoblet.
  

Følgende figur viser settet med verktøy som er tilgjengelige etter å ha satt opp containerbyggmiljøet ved å bruke hjelpeskriptene for å bygge Qualcomm TFLite SDK.

Figuren viser sekvensen for utførelse av verktøyene:
Figur 4-3 Sekvens av verktøy på vert

Synkroniser og bygg Qualcomm TFLite SDK
Qualcomm TFLite SDK kompileres når docker-bildet opprettes. For å synkronisere og bygge Qualcomm TFLite SDK, gjør følgende:

1. Opprett en katalog på verten file system for å synkronisere Qualcomm TFLite SDK-arbeidsområdet. Til
   exampde: $mkdir $cd
2. Hent Qualcomm TFLite SDK-kildekoden fra 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. Opprett en katalog på verten file system som kan monteres i docker. For eksample: mkdir-p / Denne katalogen kan opprettes hvor som helst på Linux-vertsmaskinen, og den avhenger ikke av hvor Qualcomm TFLite SDK-prosjektet er synkronisert. Etter at arbeidsflyten er fullført i beholderen, kan Qualcomm TFLite SDK-artefakter bli funnet i katalogen som ble opprettet i dette trinnet.
4. Rediger JSON-konfigurasjonen file tilstede i /tflite-tools/ targets/le-tflite-tools-builder.json med følgende oppføringer:
   “Image”: “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”: “” }
   For mer informasjon om oppføringene nevnt i json-konfigurasjonen file, se Docker.md readme file på /tflite-tools/.
   NOTE For QCS8550 støttes ikke Qualcomm® Hexagon™ DSP-delegaten.
5. Kjøp skriptet for å sette opp miljøet:
   $ cd /tflite-tools $ source ./scripts/host/docker_env_setup.sh
6.  Bygg Qualcomm TFLite SDK docker-bilde: $ tflite-tools-host-build-image ./targets/le-tflite-tools-builder.json Hvis byggeoppsettet mislykkes, se Feilsøke docker-oppsett. Etter vellykket fullføring vises følgende melding: "Status: Byggebilde fullført!!" Å kjøre dette trinnet bygger også Qualcomm TFLite SDK.
7.  Kjør Qualcomm TFLite SDK docker-beholderen. Dette starter beholderen med tags gitt i JSON-konfigurasjonen file. $tflite-tools-host-run-container ./targets/le-tflite-tools-builder.json
8. Fest til beholderen startet fra forrige trinn.
   $ docker vedlegg

Qualcomm TFLite SDK er kompilert, og artefaktene er klare til å distribueres eller videre kan
brukes til å generere QIM SDK TFLite-plugin-modulen.

Koble enheten til vert og distribuer artefakter]

Etter kompilering er det to mekanismer for å koble enheten til en vert og distribuere
Qualcomm TFLite SDK-artefakter.

• Enhet koblet til en lokal Linux-vert:
  En utvikler kobler enheten til en arbeidsstasjon og installerer Qualcomm TFLite SDK-artefakter fra beholderen direkte på enheten (QCS8550).
• Enhet koblet til en ekstern vert:
  En utvikler kobler enheten til en ekstern arbeidsstasjon, og de kan bruke installasjonskommandoer for pakkebehandling på Windows- og Linux-plattformer for å installere Qualcomm TFLite SDK-artefakter på enheten (QCS8550)

Figur 4-4 Kobling av enhetskort til utvikler og ekstern arbeidsstasjon

Koble enheten til arbeidsstasjonen

Enheten er koblet til arbeidsstasjonen og utviklingsbeholderen kan få tilgang til enheten over USB/adb.
Figuren viser stages i sekvensen av Qualcomm TFLite SDK-arbeidsflyten:

1. Kjør følgende kommandoer for å installere artefakter på enheten:
   $ tflite-tools-device-prepare
   $ tflite-tools-device-deploy
2. For å avinstallere artefaktene, kjør følgende kommando:
   $ tflite-tools-device-packages-remove

Koble enheten til den eksterne maskinen

Enheten er koblet til en ekstern maskin, og Qualcomm TFLite SDK-beholderen kan ikke få tilgang til enheten via USB/ad b.
Figuren viser stages i sekvensen av Qualcomm TFLite SDK-arbeidsflyten:

Kjør følgende kommandoer i tflite-tools-beholderen for å kopiere artefaktene til en ekstern maskin
avhengig av pakkebehandlingen på enheten:
$ tflite-tools-remote-sync-ipk-rel-pkg
NOTE Den eksterne maskininformasjonen er gitt i JSON-konfigurasjonen file.
Installer artefakter for Windows-plattformen
Qualcomm TFLite SDK-artefakter kan installeres på enheten basert på operativsystemet til den eksterne maskinen.

For Windows-plattformen, gjør følgende:
På PowerShell bruker du følgende skript: PS C:
> adb root PS C:> adb disable-verity PS C:> adb reboot PS C:> adb vente-på-enhet 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 Hvis pakken er en ipk (for QCS8550.LE.1.0), bruk følgende kommandoer: PS C:> adb shell “ opkg –force-depends –force-reinstall –force-overwrite install /tmp/”

Installer artefakter for Linux-plattformen
Bruk følgende kommandoer:
$ adb root $ adb disable-verity $ adb reboot $ adb vente-på-enhet $ adb root $ adb remount $ adb shell mount -o remount,rw / $ adb shell “mkdir -p /tmp” $ adb push /tmp Hvis pakken er en ipk (for QCS8550.LE.1.0): $ adb-skall “opkg –force-depends –force-reinstall –force-overwrite install /tmp/”

Rydd opp i docker-bilde
Etter å ha fullført utviklerarbeidsflyten, bør docker-miljøet renses for å frigjøre lagringen på disken. Rengjøring av docker fjerner ubrukte beholdere og bilder, og frigjør dermed diskplass.
Bruk følgende kommandoer for å rydde opp i docker-bildet:

1. Kjør følgende kommando på Linux-arbeidsstasjonen:
   $ cd /tflite-verktøy
2. Stopp beholderen:
   $ tflite-tools-host-stop-container ./targets/ le-tflite-tools-builder.json
3. Fjern beholderen:
   $ tflite-tools-host-rm-container ./targets/ le-tflite-tools-builder.json
4. Fjern de eldre docker-bildene:
   $ tflite-tools-host-images-cleanup

Feilsøk docker-oppsett

Hvis kommandoen tflite-tools-host-build-image returnerer en Nospace left on device-melding, flytter du docker-katalogen til/local/mnt. Gjør følgende for å feilsøke oppsettet:

1. Sikkerhetskopier eksisterende docker files:
   $ tar -zcC /var/lib docker > /mnt/pd0/var_lib_docker-backup-$(dato + %s).tar.gz
2. Stopp havnearbeideren:
   $ service docker stopp
3. Bekreft at ingen docker-prosess kjører:
   $ ps faux | grep docker
4. Sjekk docker-katalogstrukturen:
   $ sudo ls /var/lib/docker/
5. Flytt docker-katalogen til en ny partisjon:
   $ mv /var/lib/docker /local/mnt/docker
6. Lag en symbolkobling til docker-katalogen i den nye partisjonen:
   $ ln -s /local/mnt/docker /var/lib/docker
7. Sørg for at docker-katalogstrukturen forblir uendret:
   $ sudo ls /var/lib/docker/
8. Start docker:
   $ service docker start
9. Start alle beholderne på nytt etter å ha flyttet docker-katalogen.

Generer TFLite SDK med Linux arbeidsstasjon

TFLite SDK-arbeidsflyten kan aktiveres uten containere ved å bruke Linux-arbeidsstasjonen. Denne prosedyren er et alternativ til å bruke beholdere.
For å synkronisere og bygge Qualcomm TFLite SDK, gjør følgende:

1. Opprett en katalog på verten file system for å synkronisere Qualcomm TFLite SDK-arbeidsområdet. For eksampde:
   $mkdir
   $cd
2. Hent Qualcomm TFLite SDK-kildekoden fra 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 && repo sync -qc –no-tags -j8
3. 3. Rediger JSON-konfigurasjonen file tilstede i /tflite-tools/ targets/le-tflite-tools-builder.json med følgende oppføringer
   “Image”: “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": ""
   For mer informasjon om oppføringene nevnt i json-konfigurasjonen file, se Docker.md readme file på /tflite-tools/.
   NOTE For QCS8550 støttes ikke Hexagon DSP-delegat
4. Kjøp skriptet for å sette opp miljøet:
   $ cd /tflite-verktøy
   $ kilde ./scripts/host/host_env_setup.sh
5. Bygg Qualcomm TFLite SDK.
   $ tflite-tools-setup targets/le-tflite-tools-builder.json
6.  Kjør følgende verktøykommandoer i det samme Linux-skallet for å samle TFLite SDK-artefakter fra 
   TFLite_rsync_destination.
   $ tflite-tools-host-get-rel-package targets/le-tflite-tools-builder.json
   $ tflite-tools-host-get-dev-package targets/le-tflite-tools-builder.json
7. Installer artefakter basert på operativsystemet
   • For Windows-plattformen, på PowerShell, bruk følgende skript
     PS C:> adb root PS C:> adb disable-verity PS C:> adb reboot PS C:> adb vente-på-enhet PS C:> adb root PS C:> adb remount PS C:> adb shell mount - o remonter,rw / PS C:> adb-skall "mkdir -p /tmp" PS C:> adb push /tmp
     Hvis pakken er en ipk (for QCS8550.LE.1.0), bruk følgende kommandoer:
     PS C:> adb-skall “opkg –force-depends –force-reinstall –forceoverwrite install /tmp/
     For Linux-plattformen, bruk følgende skript:
     $ adb root $ adb disable-verity $ adb reboot $ adb vente-på-enhet $ adb root $ adb remount $ adb shell mount -o remount,rw / $ adb shell “mkdir -p /tmp” $ adb push /tmp Hvis pakken er en ipk (for QCS8550.LE.1.0):
     $ adb-skall “opkg –force-depends –force-reinstall –force-overwrite install /tmp/”

Generer Qualcomm TFLite SDK-artefakter for QIM SDK-bygg

For å bruke artefaktene som er generert for å aktivere Qualcomm TFLite SDK GStreamer-plugin-modulen i QIM SDK, gjør du følgende:

1. Fullfør prosedyren i Sync og bygg Qualcomm TFLite SDK, og kjør deretter følgende kommando: $ tflite-tools-host-get-dev-tar-package ./targets/le-tflite-toolsbuilder.json
   En tjære file er generert. Den inneholder Qualcomm TFLite SDK på banen som er oppgitt på «TFLite_rsync_destination»
2. For å aktivere Qualcomm TFLite SDK GStreamer-plugin-modulen, bruk tar file som et argument i JSON-konfigurasjonen file for QIM SDK-bygget.
   For informasjon om kompilering av QIM SDK, se Qualcomm Intelligent Multimedia SDK (QIM SDK) Quick Start Guide (80-50450-51).

Bygg Qualcomm TFLite SDK trinnvis

Hvis du bygger Qualcomm TFLite SDK for første gang, se Bygg Qualcomm TFLite SDK-verktøy – utviklerarbeidsflyt. Det samme byggemiljøet kan gjenbrukes for inkrementell utvikling.
Hjelpeverktøyene (i beholderen) nevnt i figuren er tilgjengelige for utviklere for å kompilere modifiserte applikasjoner og plug-ins.
Figur 5-1 Arbeidsflyt i en beholder

Etter at kodeendringene er fullført i kodekatalogen, gjør du følgende:

1. Kompiler modifisert kode:
   $ tflite-tools-incremental-build-install
2. Pakkekompilert kode:
   $ tflite-tools-ipk-rel-pkg eller $ tflite-tools-deb-rel-pkg
3. Synkroniser utgivelsespakker med verten file system:
   $ tflite-tools-remote-sync-ipk-rel-pkg
   Or
   $ tflite-tools-remote-sync-deb-rel-pkg
4. Forbered en utviklerpakke:
   $ tflite-tools-ipk-dev-pkg
   De kompilerte artefaktene finnes i mappen TFLite_rsync_destination nevnt i JSON file, som kan kopieres til hvilken som helst katalog.

Arbeid med QNN ekstern TFLite Delegate

En TFLite External Delegate lar deg kjøre modellene dine (del eller hele) på en annen eksekutør ved å bruke biblioteker levert av en pålitelig tredjepart som QNN av Qualcomm. Denne mekanismen kan utnytte en rekke akseleratorer på enheten som GPU eller Hexagon Tensor Processor (HTP) for slutninger. Dette gir utviklere en fleksibel og frakoblet metode fra standard TFLite for å fremskynde slutninger.

Forutsetninger:

• Sørg for at du bruker en Ubuntu-arbeidsstasjon for å trekke ut QNN AI-stack.
• Sørg for at du bruker en QNN versjon 2.14 for å være sammen med Qualcomm TFLite SDK

Qualcomm TFLite SDK er aktivert for å kjøre slutninger på flere QNN-backends gjennom TFLite ekstern delegat for QNN. TFLite-modellene med en felles flatbuffer-representasjon kan kjøres på GPU og HTP.
Etter at Qualcomm TFLite SDK-pakkene er installert på enheten, gjør du følgende for å installere QNN-bibliotekene på enheten.

1. Last ned Qualcomm Package Manager 3 for Ubuntu.
   a. Klikk https://qpm.qualcomm.com/, og klikk Verktøy.
   b. I den venstre ruten, i feltet Søkeverktøy, skriver du inn QPM. Fra System OS-listen velger du Linux.
   Søkeresultatene viser en liste over Qualcomm Package Managers.
   c. Velg Qualcomm Package Manager 3 og last ned Linux debian-pakken.
2. Installer Qualcomm Package Manager 3 for Linux. Bruk følgende kommando:
   $ dpkg -i –force-overwrite /path/to/
   QualcommPackageManager3.3.0.83.1.Linux-x86.deb
3. Last ned Qualcomm®
   AI Engine Direct SDK på Ubuntu-arbeidsstasjonen.
   a. Klikk https://qpm.qualcomm.com/ og klikk Verktøy.
   b. I den venstre ruten, i Søkeverktøy-feltet, skriver du AI-stack. Fra System OS-listen velger du Linux.
   A rullegardinlisten som inneholder forskjellige AI-stackmotorer vises.
   c. Klikk på Qualcomm® AI Engine Direct SDK og last ned Linux v2.14.0-pakken.
4. Installer Qualcomm® AI Engine Direct SDK på Ubuntu-arbeidsstasjonen.
   en. Aktiver lisensen:
   qpm-cli –license-activate qualcomm_ai_engine_direct
   b Installer AI Engine Direct SDK:
   $ qpm-cli –extract /path/to/ qualcomm_ai_engine_direct.2.14.0.230828.Linux-AnyCPU.qik
5. Push biblioteker til enheten fra Ubuntu-arbeidsstasjonen med 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/ libQnnHkelt. så /usr/lib/rfsa/adsp

Test Qualcomm TFLite SDK

Qualcomm TFLite SDK gir visse eksample-applikasjoner, som kan brukes til å validere, benchmarke og få nøyaktigheten til modellene som en utvikler ønsker å vurdere.
Etter at Qualcomm TFLite SDK-pakkene er installert på enheten, er kjøretiden tilgjengelig på enheten for å kjøre disse eks.ample applikasjoner.
Forutsetning
Opprett følgende kataloger på enheten:
$ adb-skall "mkdir /data/Models"
$ adb-skall "mkdir /data/Lables"
$ adb-skall "mkdir /data/profiling"

Etikettbilde

Et etikettbilde er et verktøy levert av Qualcomm TFLite SDK som viser hvordan du kan laste inn en forhåndstrent og konvertert TensorFlow Lite-modell og bruke den til å gjenkjenne objekter i bilder. Forutsetninger:
Last ned sampmodell og bilde:
Du kan bruke hvilken som helst kompatibel modell, men følgende MobileNet v1-modell tilbyr en god demonstrasjon av en modell som er trent til å gjenkjenne 1000 forskjellige objekter.

• Få modell
  $ 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/
• Få etiketter
  $ 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/ labels.txt
  $ mv /data/mobilenet_v1_1.0_224/labels.txt /data/Labels/
  Etter at du har koblet til Qualcomm TFLite SDK docker-beholderen, kan bildet bli funnet på:
  “/mnt/tflite/src/tensorflow/tensorflow/lite/examples/label_image/ testdata/grace_hopper.bmp"
  a. Skyv dette file til/data/Etiketter/
  b. Kjør kommandoen:
  $ adb-skall "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"

Benchmark

Qualcomm TFLite SDK gir benchmarking-verktøyet for å beregne ytelsen til ulike kjøretider.
Disse referanseverktøyene måler og beregner for øyeblikket statistikk for følgende viktige resultatmålinger:

• Initialiseringstid
• Konklusjonstid for oppvarmingstilstand
• Inferenstid for steady state
• Minnebruk under initialiseringstid
• Generell minnebruk

Forutsetninger

Skyv modellene som skal testes fra TFLite Model Zoo (https://tfhub.dev/) til/data/Modeller/. Kjør følgende skript:  

• XNN-pakke
  $ adb shell “benchmark_model –graph=/data/Models/ — enable_op_profiling=true –use_xnnpack=true –num_threads=4 –max_secs=300 –profiling_output_csv_file=/data/profilering/”
• GPU-delegat
  $ 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=/data/profilering/”
• Ekstern delegat
  QNN ekstern delegat GPU:
  Kjør slutning med flyttallsmodell:
  $ 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/lib:rfussarary_dir: /adsp'"
  QNN ekstern delegat HTP:
  Kjør slutning med kvantmodell:
  $ 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:/fussarary/dir /adsp'"

Nøyaktighetsverktøy

Qualcomm TFLite SDK gir et nøyaktighetsverktøy for å beregne nøyaktigheten til modeller med ulike kjøretider.

• Klassifisering med GPU-delegat
  Trinnene for å laste ned de nødvendige files å teste kan bli funnet på: "/mnt/tflite/src/tensorflow/tensorflow/lite/tools/evaluation/tasks/ imagenet_image_classificatio/README.md"
  Binæren for å kjøre dette verktøyet er allerede en del av SDK-en, så utvikleren trenger ikke å bygge den på nytt.
  $ adb-skall "image_classify_run_eval — model_file=/data/Models/ –ground_truth_images_path=/data/ — ground_truth_labels=/data/ –model_output_labels=/ data/ –delegate=gpu”
• Objektdeteksjon med XNN-pakke
  $ adb-skall “inf_diff_run_eval –model_file=/data/Models/ –delegate=xnnpac

JURIDISK INFORMASJON

Din tilgang til og bruk av dette dokumentet, sammen med eventuelle spesifikasjoner, referansetavle files, tegninger, diagnostikk og annen informasjon som finnes her (samlet dette "Dokumentasjon"), er underlagt ditt (inkludert selskapet eller annen juridisk enhet du representerer, kollektivt "Du" eller "Din") aksept av vilkårene og betingelsene ("Vilkår for bruk") angitt nedenfor. Hvis du ikke godtar disse vilkårene for bruk, kan du ikke bruke denne dokumentasjonen og skal umiddelbart ødelegge enhver kopi av den.

1. Juridisk varsel.
   Denne dokumentasjonen gjøres tilgjengelig for deg kun for intern bruk med de produktene og tjenestetilbudene til Qualcomm Technologies, Inc. ("Qualcomm Technologies") og dets tilknyttede selskaper beskrevet i denne dokumentasjonen, og skal ikke brukes til andre formål. Denne dokumentasjonen kan ikke endres, redigeres eller modifiseres på noen måte uten skriftlig forhåndsgodkjenning fra Qualcomm Technologies. Uautorisert bruk eller avsløring av dette
   Dokumentasjon eller informasjonen heri er strengt forbudt, og du samtykker i å holde Qualcomm Technologies, dets tilknyttede selskaper og lisensgivere skadesløs for eventuelle skader eller tap påført av Qualcomm Technologies, dets tilknyttede selskaper og lisensgivere for slik uautorisert bruk eller avsløring av denne dokumentasjonen, i sin helhet eller del. Qualcomm Technologies, dets tilknyttede selskaper og lisensgivere beholder alle rettigheter og eierskap i og til denne dokumentasjonen. Ingen lisens til varemerker, patenter, opphavsrettigheter, rettigheter til beskyttelse av maskearbeid eller andre immaterielle rettigheter er verken gitt eller underforstått av denne dokumentasjonen eller informasjon som er avslørt heri, inkludert, men ikke begrenset til, lisens til å lage, bruke, importere eller selge ethvert produkt, tjeneste eller teknologitilbud som inneholder informasjonen i denne dokumentasjonen.
   DENNE DOKUMENTASJONEN LEVERES "SOM DEN ER" UTEN GARANTI AV NOEN SLAG, ENTEN UTTRYKKELIG, UNDERFORSTÅT, LOVBESTILLET ELLER ANNET. I DEN MAKSIMALE OMRÅDET LOVEN TILLATER, FRASKRIVER QUALCOMM TECHNOLOGIES, DETS TILKNYTTEDE SELSKAPER OG LISENSGIVERE SPESIKKELT ALLE GARANTIER OM ETTIGHET, SALGBARHET, IKKE-KRENKELSE, EGNETHET FOR EN SPESIFIKERT, SIKKERHET, SIKKERHET, OG ALLE GARANTIER SOM STÅR VED HANDELSBRUK ELLER UTENFOR ET HANDLINGSFORLØP ELLER YTELSESKURS. VERKEN QUALCOMM TECHNOLOGIES, ELLER NOEN AV DETS TILKNYTTEDE SELSKAPER ELLER LISENSGIVERE, SKAL VÆRE ANSVARLIG OVERFOR DEG ELLER TREDJEPART FOR NOEN KOSTNADER, TAP, BRUK ELLER HANDLINGER HVORDAN DEG DET ER ELLER GJØR DET ER ANSVARLIG.
   Visse produktsett, verktøy og materialer som det refereres til i denne dokumentasjonen, kan kreve at du godtar ytterligere vilkår og betingelser før du får tilgang til eller bruker disse elementene.
   Tekniske data spesifisert i denne dokumentasjonen kan være underlagt amerikanske og andre gjeldende eksportkontrolllover. Overføring i strid med USA og annen gjeldende lov er strengt forbudt.
   Ingenting i denne dokumentasjonen er et tilbud om å selge noen av komponentene eller enhetene det refereres til her.
   Denne dokumentasjonen kan endres uten ytterligere varsel. I tilfelle en konflikt mellom disse vilkårene for bruk og Webnettstedet Vilkår for bruk på www.qualcomm.com eller Qualcomms personvernerklæring det henvises til www.qualcomm.com, vil disse vilkårene for bruk kontrollere. I tilfelle en konflikt mellom disse vilkårene for bruk og enhver annen avtale (skrevet eller gjennomklikk) utført av deg og Qualcomm Technologies eller en Qualcomm Technologies-tilknyttet selskap med hensyn til din tilgang til og bruk av denne dokumentasjonen, vil den andre avtalen kontrollere .
   Disse bruksvilkårene skal styres av og tolkes og håndheves i samsvar med lovene i staten California, unntatt FNs konvensjon om internasjonalt salg av varer, uten hensyn til lovkonflikter. Enhver tvist, krav eller uenighet som oppstår som følge av eller relatert til disse vilkårene for bruk, eller bruddet eller gyldigheten av disse, skal kun avgjøres av en domstol med kompetent jurisdiksjon i fylket San Diego, delstaten California, og du samtykker herved til den personlige jurisdiksjonen til slike domstoler for dette formålet.
2. Varemerke- og produktattribusjonserklæringer.
   Qualcomm er et varemerke eller registrert varemerke for Qualcomm Incorporated. Arm er et registrert varemerke for Arm Limited (eller dets datterselskaper) i USA og/eller andre steder. Bluetooth®-ordmerket er et registrert varemerke som eies av Bluetooth SIG, Inc. Andre produkt- og merkenavn referert til i denne dokumentasjonen kan være varemerker eller registrerte varemerker for deres respektive eiere.
   Snapdragon- og Qualcomm-merkede produkter referert til i denne dokumentasjonen er produkter fra Qualcomm Technologies, Inc. og/eller dets datterselskaper. Qualcomm patenterte teknologier er lisensiert av Qualcomm Incorporated.