Modellschnittstellen mit Metadaten generieren

Mit LiteRT-Metadaten können Entwickler Wrapper-Code generieren, um die Integration in Android zu ermöglichen. Für die meisten Entwickler ist die grafische Benutzeroberfläche von Android Studio ML Model Binding am einfachsten zu verwenden. Wenn Sie mehr Anpassungsmöglichkeiten benötigen oder Befehlszeilentools verwenden, ist auch LiteRT Codegen verfügbar.

Android Studio ML Model Binding verwenden

Für LiteRT-Modelle, die mit Metadaten optimiert wurden, können Entwickler das Android Studio ML Model Binding verwenden, um Einstellungen für das Projekt automatisch zu konfigurieren und Wrapper-Klassen basierend auf den Modellmetadaten zu generieren. Durch den Wrapper-Code ist es nicht mehr erforderlich, direkt mit ByteBuffer zu interagieren. Stattdessen können Entwickler mit dem LiteRT-Modell über typisierte Objekte wie Bitmap und Rect interagieren.

LiteRT-Modell in Android Studio importieren

  1. Klicken Sie mit der rechten Maustaste auf das Modul, für das Sie das TFLite-Modell verwenden möchten, oder klicken Sie auf File, dann auf New > Other > LiteRT Model.

  2. Wählen Sie den Speicherort Ihrer TFLite-Datei aus. Die Tools konfigurieren die Abhängigkeit des Moduls in Ihrem Namen mit der ML-Modellbindung und alle Abhängigkeiten werden automatisch in die build.gradle-Datei Ihres Android-Moduls eingefügt.

    Optional: Wählen Sie das zweite Kästchen aus, um TensorFlow GPU zu importieren, wenn Sie die GPU-Beschleunigung verwenden möchten.

  3. Klicken Sie auf Finish.

  4. Nach dem erfolgreichen Import wird der folgende Bildschirm angezeigt. Um das Modell zu verwenden, wählen Sie Kotlin oder Java aus und kopieren Sie den Code unter dem Abschnitt Sample Code. Sie können zu diesem Bildschirm zurückkehren, indem Sie in Android Studio im Verzeichnis ml auf das TFLite-Modell doppelklicken.

Modellinferenz beschleunigen

Mit der ML-Modellbindung können Entwickler ihren Code durch die Verwendung von Delegates und der Anzahl der Threads beschleunigen.

Schritt 1: Prüfen Sie, ob die Moduldatei build.gradle die folgende Abhängigkeit enthält:

    dependencies {
        ...
        // For the LiteRT GPU delegate, we need
        // 'com.google.ai.edge.litert:litert-gpu' version 1.*.
        implementation 'com.google.ai.edge.litert:litert-gpu:1.4.1'
    }

Schritt 2: Erkennen, ob die auf dem Gerät ausgeführte GPU mit dem TensorFlow-GPU-Delegate kompatibel ist. Wenn nicht, das Modell mit mehreren CPU-Threads ausführen:

Kotlin

    import org.tensorflow.lite.gpu.CompatibilityList
    import org.tensorflow.lite.gpu.GpuDelegate

    val compatList = CompatibilityList()

    val options = if(compatList.isDelegateSupportedOnThisDevice) {
        // if the device has a supported GPU, add the GPU delegate
        Model.Options.Builder().setDevice(Model.Device.GPU).build()
    } else {
        // if the GPU is not supported, run on 4 threads
        Model.Options.Builder().setNumThreads(4).build()
    }

    // Initialize the model as usual feeding in the options object
    val myModel = MyModel.newInstance(context, options)

    // Run inference per sample code

Java

    import org.tensorflow.lite.support.model.Model
    import org.tensorflow.lite.gpu.CompatibilityList;
    import org.tensorflow.lite.gpu.GpuDelegate;

    // Initialize interpreter with GPU delegate
    Model.Options options;
    CompatibilityList compatList = CompatibilityList();

    if(compatList.isDelegateSupportedOnThisDevice()){
        // if the device has a supported GPU, add the GPU delegate
        options = Model.Options.Builder().setDevice(Model.Device.GPU).build();
    } else {
        // if the GPU is not supported, run on 4 threads
        options = Model.Options.Builder().setNumThreads(4).build();
    }

    MyModel myModel = new MyModel.newInstance(context, options);

    // Run inference per sample code

Modellschnittstellen mit dem LiteRT-Code-Generator generieren

Für LiteRT-Modelle, die mit Metadaten erweitert wurden, können Entwickler den LiteRT Android-Wrapper-Code-Generator verwenden, um plattformspezifischen Wrapper-Code zu erstellen. Durch den Wrapper-Code ist keine direkte Interaktion mit ByteBuffer erforderlich. Stattdessen können Entwickler mit dem TensorFlow Lite-Modell über typisierte Objekte wie Bitmap und Rect interagieren.

Die Nützlichkeit des Codegenerators hängt von der Vollständigkeit des Metadateneintrags des LiteRT-Modells ab. Im Abschnitt <Codegen usage> unter den relevanten Feldern in metadata_schema.fbs erfahren Sie, wie das Codegen-Tool die einzelnen Felder parst.

Wrapper-Code generieren

Sie müssen die folgenden Tools in Ihrem Terminal installieren:

pip install tflite-support

Nach Abschluss kann der Codegenerator mit der folgenden Syntax verwendet werden:

tflite_codegen --model=./model_with_metadata/mobilenet_v1_0.75_160_quantized.tflite \
    --package_name=org.tensorflow.lite.classify \
    --model_class_name=MyClassifierModel \
    --destination=./classify_wrapper

Der resultierende Code befindet sich im Zielverzeichnis. Wenn Sie Google Colab oder eine andere Remote-Umgebung verwenden, ist es möglicherweise einfacher, das Ergebnis in einem ZIP-Archiv zu zippen und in Ihr Android Studio-Projekt herunterzuladen:

# Zip up the generated code
!zip -r classify_wrapper.zip classify_wrapper/

# Download the archive
from google.colab import files
files.download('classify_wrapper.zip')

Generierten Code verwenden

Schritt 1: Generierten Code importieren

Entpacken Sie den generierten Code bei Bedarf in eine Verzeichnisstruktur. Das Stammverzeichnis des generierten Codes wird als SRC_ROOT angenommen.

Öffnen Sie das Android Studio-Projekt, in dem Sie das LiteRT-Modell verwenden möchten, und importieren Sie das generierte Modul über „File“ -> „New“ -> „Import Module“ -> wählen Sie SRC_ROOT aus.

Im obigen Beispiel würden das Verzeichnis und das importierte Modul classify_wrapper heißen.

Schritt 2: build.gradle-Datei der App aktualisieren

Im App-Modul, das das generierte Bibliotheksmodul verwendet:

Fügen Sie unter dem Abschnitt „android“ Folgendes hinzu:

aaptOptions {
   noCompress "tflite"
}

Fügen Sie im Abschnitt „Abhängigkeiten“ Folgendes hinzu:

implementation project(":classify_wrapper")

Schritt 3: Modell verwenden

// 1. Initialize the model
MyClassifierModel myImageClassifier = null;

try {
    myImageClassifier = new MyClassifierModel(this);
} catch (IOException io){
    // Error reading the model
}

if(null != myImageClassifier) {

    // 2. Set the input with a Bitmap called inputBitmap
    MyClassifierModel.Inputs inputs = myImageClassifier.createInputs();
    inputs.loadImage(inputBitmap));

    // 3. Run the model
    MyClassifierModel.Outputs outputs = myImageClassifier.run(inputs);

    // 4. Retrieve the result
    Map<String, Float> labeledProbability = outputs.getProbability();
}

Modellinferenz beschleunigen

Der generierte Code bietet Entwicklern die Möglichkeit, ihren Code durch die Verwendung von Delegaten und der Anzahl der Threads zu beschleunigen. Diese können beim Initialisieren des Modellobjekts festgelegt werden, da es drei Parameter akzeptiert:

  • Context: Kontext aus der Android-Aktivität oder dem Android-Dienst
  • (Optional) Device: TFLite-Beschleunigungs-Delegate. Beispiel: GPUDelegate
  • (Optional) numThreads: Anzahl der Threads, die zum Ausführen des Modells verwendet werden. Der Standardwert ist 1.

Wenn Sie beispielsweise einen GPU-Delegate und bis zu drei Threads verwenden möchten, können Sie das Modell so initialisieren:

try {
    myImageClassifier = new MyClassifierModel(this, Model.Device.GPU, 3);
} catch (IOException io){
    // Error reading the model
}

Fehlerbehebung

Wenn Sie den Fehler „java.io.FileNotFoundException: This file can not be opened as a file descriptor; it is probably compressed“ erhalten, fügen Sie die folgenden Zeilen unter dem Abschnitt „android“ des App-Moduls ein, das das Bibliotheksmodul verwendet:

aaptOptions {
   noCompress "tflite"
}