Ti presentiamo LiteRT: il runtime ad alte prestazioni di Google per l'IA on-device, precedentemente noto come TensorFlow Lite.

Questa pagina è stata tradotta dall'API Cloud Translation.

Crea LiteRT per Android

In questo documento viene descritto come creare la libreria LiteRT per Android sul tuo personali. Normalmente, non è necessario creare localmente la libreria LiteRT per Android. Se vuoi solo utilizzarlo, consulta le Guida rapida di Android per ulteriori dettagli su come utilizzare. nei tuoi progetti Android.

Usa istantanee notturne

Per usare le istantanee notturne, aggiungi il seguente repository alla build Gradle principale .

allprojects {
    repositories {      // should be already there
        mavenCentral()  // should be already there
        maven {         // add this repo to use snapshots
          name 'ossrh-snapshot'
          url 'https://oss.sonatype.org/content/repositories/snapshots'
        }
    }
}

aggiungi snapshot notturni alle dipendenze (o modificali in base alle esigenze) al file build.gradle

...
dependencies {
    ...
    implementation 'org.tensorflow:tensorflow-lite:0.0.0-nightly-SNAPSHOT'
    implementation 'com.google.ai.edge.litert:litert-gpu:0.0.0-nightly-SNAPSHOT'
    implementation 'com.google.ai.edge.litert:litert-support:0.0.0-nightly-SNAPSHOT'
    ...
}
...

Crea LiteRT in locale

In alcuni casi, potresti voler utilizzare una build locale di LiteRT. Per potresti creare un file binario personalizzato che include operative selezionate da TensorFlow, o apportare modifiche locali a LiteRT.

configura l'ambiente di build utilizzando Docker

Scarica il file Docker. Se scarichi il file Docker, accetti che il i seguenti termini di servizio regolano il tuo utilizzo:

Se fai clic sul pulsante di accettazione, accetti che tutti gli utilizzi di Android Studio e Android Native Development Kit sarà regolato dal Software Android Il Contratto di licenza del kit di sviluppo è disponibile all'indirizzo https://developer.android.com/studio/terms (questo URL potrebbe essere aggiornato o modificato da Google di tanto in tanto).

Devi accettare i Termini di servizio per scaricare l'app .

Facoltativamente, puoi modificare la versione dell'SDK Android o NDK. Inserisci l'oggetto scaricato Docker in una cartella vuota e crea la tua immagine Docker eseguendo:

docker build . -t tflite-builder -f tflite-android.Dockerfile

Avvia il container Docker in modo interattivo montando la cartella corrente su /host_dir all'interno del container (tieni presente che /tensorflow_src è TensorFlow repository all'interno del container):

docker run -it -v $PWD:/host_dir tflite-builder bash

Se utilizzi PowerShell su Windows, sostituisci "$PWD" con "pwd".

Se vuoi utilizzare un repository TensorFlow sull'host, montalo (-v hostDir:/host_dir).

Una volta all'interno del container, puoi eseguire il comando seguente per librerie e strumenti Android aggiuntivi (tieni presente che potresti dover accettare i licenza):

sdkmanager \
  "build-tools;${ANDROID_BUILD_TOOLS_VERSION}" \
  "platform-tools" \
  "platforms;android-${ANDROID_API_LEVEL}"

Ora devi passare alla sezione Configura WORKSPACE e .bazelrc per configurare le impostazioni di build.

Dopo aver completato la creazione delle librerie, puoi copiarle in /host_dir all'interno del container, in modo da potervi accedere sull'host.

configura l'ambiente di build senza Docker

Prerequisiti per installare Bazel e Android

Bazel è il sistema di compilazione principale per TensorFlow. Per utilizzarlo, devi avere installato sul sistema Android NDK e l'SDK.

Installa la versione più recente del sistema di build Bazel.
L'NDK di Android è necessario per sviluppare il modello LiteRT nativo (C/C++) le API nel tuo codice. L'attuale versione consigliata è la 25b, che puoi trovare qui
È possibile ottenere l'SDK e gli strumenti di creazione qui oppure in alternativa nell'ambito di Android Studio. Costruire Tools API >= 23 è la versione consigliata per la creazione di LiteRT.

Configura WORKSPACE e .bazelrc

Si tratta di un passaggio di configurazione una tantum necessario per creare il file LiteRT librerie. Esegui lo script ./configure nel pagamento principale di TensorFlow e rispondi "Sì" quando lo script chiede di configurare in modo interattivo ./WORKSPACE per le build Android. Lo script tenterà di configurare le impostazioni utilizzando il metodo le seguenti variabili di ambiente:

ANDROID_SDK_HOME
ANDROID_SDK_API_LEVEL
ANDROID_NDK_HOME
ANDROID_NDK_API_LEVEL

Se queste variabili non sono impostate, devono essere fornite in modo interattivo nello script . La configurazione corretta dovrebbe restituire voci simili alle seguenti nel file .tf_configure.bazelrc nella cartella principale:

build --action_env ANDROID_NDK_HOME="/usr/local/android/android-ndk-r25b"
build --action_env ANDROID_NDK_API_LEVEL="21"
build --action_env ANDROID_BUILD_TOOLS_VERSION="30.0.3"
build --action_env ANDROID_SDK_API_LEVEL="30"
build --action_env ANDROID_SDK_HOME="/usr/local/android/android-sdk-linux"

Crea e installa

Dopo aver configurato correttamente Bazel, puoi creare l'AR LiteRT da nella directory di pagamento principale:

bazel build -c opt --cxxopt=--std=c++17 --config=android_arm64 \
  --fat_apk_cpu=x86,x86_64,arm64-v8a,armeabi-v7a \
  --define=android_dexmerger_tool=d8_dexmerger \
  --define=android_incremental_dexing_tool=d8_dexbuilder \
  //tensorflow/lite/java:tensorflow-lite

Verrà generato un file AAR in bazel-bin/tensorflow/lite/java/. Nota che questo dà un "grasso" AAR con diverse architetture; se non ne servono tutte, usa il sottoinsieme appropriato per il tuo ambiente di deployment.

Puoi creare file AAR più piccoli destinati solo a un insieme di modelli, come indicato di seguito:

bash tensorflow/lite/tools/build_aar.sh \
  --input_models=model1,model2 \
  --target_archs=x86,x86_64,arm64-v8a,armeabi-v7a

Lo script precedente genererà il file tensorflow-lite.aar e, facoltativamente, il valore tensorflow-lite-select-tf-ops.aar se uno dei modelli usa Operazioni TensorFlow. Per ulteriori dettagli, consulta Sezione Riduci le dimensioni binarie LiteRT.

Aggiungi AAR direttamente al progetto

Sposta il file tensorflow-lite.aar in una directory denominata libs nel tuo progetto. Modifica il file build.gradle dell'app in modo che faccia riferimento alla nuova directory e sostituisco la dipendenza LiteRT esistente con la nuova libreria locale, e.g.:

allprojects {
    repositories {
        mavenCentral()
        maven {  // Only for snapshot artifacts
            name 'ossrh-snapshot'
            url 'https://oss.sonatype.org/content/repositories/snapshots'
        }
        flatDir {
            dirs 'libs'
        }
    }
}

dependencies {
    compile(name:'tensorflow-lite', ext:'aar')
}

Installa AAR nel Repository Maven locale

Esegui questo comando dalla directory di pagamento principale:

mvn install:install-file \
  -Dfile=bazel-bin/tensorflow/lite/java/tensorflow-lite.aar \
  -DgroupId=org.tensorflow \
  -DartifactId=tensorflow-lite -Dversion=0.1.100 -Dpackaging=aar

Nell'build.gradle dell'app, assicurati di avere la dipendenza mavenLocal() e sostituire la dipendenza LiteRT standard con quella che supporta per operazioni TensorFlow selezionate:

allprojects {
    repositories {
        mavenCentral()
        maven {  // Only for snapshot artifacts
            name 'ossrh-snapshot'
            url 'https://oss.sonatype.org/content/repositories/snapshots'
        }
        mavenLocal()
    }
}

dependencies {
    implementation 'org.tensorflow:tensorflow-lite:0.1.100'
}

Tieni presente che la versione 0.1.100 qui è solo per amore di test/sviluppo. Con il componente AAR locale installato, puoi utilizzare lo standard API di inferenza Java LiteRT nel codice dell'app.