Modellschnittstellen mit Metadaten generieren

Mithilfe von LiteRT-Metadaten können Entwickler um die Integration unter Android zu aktivieren. Für die meisten Entwickler Die grafische Benutzeroberfläche der Android Studio ML Model Binding die am einfachsten zu verwenden sind. Wenn Sie weitere Anpassungen benötigen oder die Befehlszeile verwenden LiteRT Codegen ist ebenfalls verfügbar.

Android Studio-ML-Modellbindung verwenden

Bei mit Metadaten verbesserten LiteRT-Modellen: Entwickler können mithilfe der ML-Modellbindung von Android Studio die automatische Konfiguration Einstellungen für das Projekt festlegen und Wrapper-Klassen basierend auf dem Modell generieren Metadaten. Dank des Wrapper-Codes ist keine direkte Interaktion mit ByteBuffer Stattdessen können Entwickelnde mit dem LiteRT-Modell interagieren. mit typisierten Objekten wie Bitmap und Rect.

LiteRT-Modell in Android Studio importieren

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

  2. Wählen Sie den Speicherort Ihrer TFLite-Datei aus. Beachten Sie, dass das Tool die Abhängigkeit des Moduls für Sie mit ML-Modellbindung und automatisch in das Modul Ihres Android-Moduls build.gradle-Datei.

    Optional: Klicken Sie das zweite Kästchen zum Importieren von TensorFlow-GPU an, wenn Sie die GPU-Beschleunigung nutzen möchten.

  3. Klicken Sie auf Finish.

  4. Nach Abschluss des Imports wird der folgende Bildschirm angezeigt. Zu Beginn Wählen Sie mithilfe des Modells Kotlin oder Java aus, kopieren Sie den Code und fügen Sie ihn Sample Code Abschnitt. Du kehrst zu diesem Bildschirm zurück, indem du doppelt Das TFLite-Modell im Verzeichnis ml in Android Studio.

Modellinferenz beschleunigen

ML-Modellbindung bietet Entwicklern die Möglichkeit, ihren Code durch die Verwendung von Bevollmächtigten und die Anzahl der Threads.

Schritt 1: Prüfen Sie, ob die Datei build.gradle des Moduls Folgendes enthält: Abhängigkeit:

    dependencies {
        ...
        // TFLite GPU delegate 2.3.0 or above is required.
        implementation 'com.google.ai.edge.litert:litert-gpu:2.3.0'
    }

Schritt 2: Erkennen, ob die auf dem Gerät ausgeführte GPU mit der TensorFlow-GPU kompatibel ist delegieren, wenn das Modell nicht mit mehreren CPU-Threads ausgeführt wird:

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 LiteRT-Codegenerator generieren

Für ein um Metadaten optimiertes LiteRT-Modell: können Entwickler mit dem Android-Wrapper-Code-Generator LiteRT plattformspezifischen Wrapper-Code. Dank des Wrapper-Codes ist keine Interaktion erforderlich direkt mit ByteBuffer. Stattdessen können Entwickelnde mit dem TensorFlow-Format interagieren, Lite-Modell mit typisierten Objekten wie Bitmap und Rect.

Die Nützlichkeit des Codegenerators hängt von der Vollständigkeit der Metadateneintrag des LiteRT-Modells. Weitere Informationen finden Sie im Abschnitt „<Codegen usage>“. in den relevanten Feldern metadata_schema.fbs um zu sehen, wie das Codegen-Tool jedes Feld parst.

Wrapper-Code generieren

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

pip install tflite-support

Anschließend 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 mit Google Colab oder einer anderen Remote-App ist es vielleicht einfacher, das Ergebnis als ZIP-Datei zu komprimieren an Ihr Android Studio-Projekt an:

# 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 gegebenenfalls in einer Verzeichnisstruktur. Die Wurzel von Es wird davon ausgegangen, dass der generierte Code SRC_ROOT ist.

Öffnen Sie das Android Studio-Projekt, in dem Sie LiteRT verwenden möchten. und importieren Sie das generierte Modul mit: And File -> Neu -> Modul importieren -> SRC_ROOT auswählen

Im obigen Beispiel würden das importierte Verzeichnis und das importierte Modul classify_wrapper

Schritt 2: build.gradle-Datei der App aktualisieren

Führen Sie im App-Modul, das das generierte Bibliotheksmodul verwendet, folgende Schritte aus:

Fügen Sie im Bereich „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 zu beschleunigen. durch die Nutzung von Bevollmächtigten und die Anzahl der Threads. Diese können beim Initialisieren des Modellobjekts festgelegt werden, Parameter:

  • Context: Kontext aus der Android-Aktivität oder dem Android-Dienst
  • (Optional) Device: TFLite-Beschleunigungsdelegat. Hier einige Beispiele: GPUDelegate
  • (Optional) numThreads: Anzahl der Threads, die zum Ausführen des Modells verwendet werden – ist „1“.

Um beispielsweise einen GPU-Delegaten und bis zu drei Threads zu verwenden, können Sie wie folgt aussehen:

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

Fehlerbehebung

Wenn der Fehler „java.io.FileNotFoundException: This file can not be open as a file deskriptor; wahrscheinlich komprimiert.“ Fehler, fügen Sie folgende Zeilen ein: im Android-Abschnitt des App-Moduls, das das Library-Modul verwendet:

aaptOptions {
   noCompress "tflite"
}