Modellschnittstellen mit Metadaten generieren

Mit TensorFlow Lite-Metadaten können Entwickler Wrapper-Code generieren, um die Integration unter Android zu ermöglichen. Für die meisten Entwickler ist die grafische Oberfläche der Android Studio ML-Modellbindung am einfachsten zu verwenden. Falls Sie mehr Anpassungen benötigen oder Befehlszeilentools verwenden, steht Ihnen auch TensorFlow Lite Codegen zur Verfügung.

Android Studio ML-Modellbindung verwenden

Bei mit Metadaten erweiterten TensorFlow Lite-Modellen können Entwickler mithilfe der ML-Modellbindung von Android Studio automatisch Einstellungen für das Projekt konfigurieren und Wrapper-Klassen basierend auf den Modellmetadaten generieren. Dank des Wrapper-Codes ist keine direkte Interaktion mit ByteBuffer mehr erforderlich. Stattdessen können Entwickler mit dem TensorFlow Lite-Modell mit typisierten Objekten wie Bitmap und Rect interagieren.

TensorFlow Lite-Modell in Android Studio importieren

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

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

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

  3. Klicken Sie auf Finish.

  4. Nach dem Import wird der folgende Bildschirm angezeigt. Wählen Sie Kotlin oder Java aus, kopieren Sie den Code und fügen Sie ihn unter dem Abschnitt Sample Code ein, um mit der Verwendung des Modells zu beginnen. Sie können zu diesem Bildschirm zurückkehren, indem Sie in Android Studio im Verzeichnis ml auf das TFLite-Modell doppelklicken.

Beschleunigung der Modellinferenz

Mit ML-Modellbindungen können Entwickler ihren Code durch die Verwendung von Bevollmächtigten und die Anzahl der Threads beschleunigen.

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

    dependencies {
        ...
        // TFLite GPU delegate 2.3.0 or above is required.
        implementation 'org.tensorflow:tensorflow-lite-gpu:2.3.0'
    }

Schritt 2: Erkennen Sie, ob die auf dem Gerät ausgeführte GPU mit dem TensorFlow-GPU-Delegat kompatibel ist. Falls das Modell nicht mit mehreren CPU-Threads ausgeführt wird, führen Sie die folgenden Schritte aus:

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 TensorFlow Lite-Codegenerator generieren

Bei einem mit Metadaten erweiterten TensorFlow Lite-Modell können Entwickler den Android-Wrapper-Codegenerator von TensorFlow Lite verwenden, um plattformspezifischen Wrapper-Code zu erstellen. Dank des Wrapper-Codes ist keine direkte Interaktion mit ByteBuffer mehr erforderlich. Stattdessen können Entwickler mit dem TensorFlow Lite-Modell mit typisierten Objekten wie Bitmap und Rect interagieren.

Die Nützlichkeit des Codegenerators hängt von der Vollständigkeit des Metadateneintrags des TensorFlow Lite-Modells ab. Im Abschnitt <Codegen usage> unter relevanten Feldern in metadata_schema.fbs finden Sie Informationen dazu, wie das Codegen-Tool jedes Feld analysiert.

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 Google Colab oder eine andere Remote-Umgebung verwenden, ist es möglicherweise einfacher, das Ergebnis in einem ZIP-Archiv zu komprimieren und es 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. Als Stamm des generierten Codes wird SRC_ROOT angenommen.

Öffnen Sie das Android Studio-Projekt, in dem Sie das TensorFlow Lite-Modell verwenden möchten, und importieren Sie das generierte Modul über „Datei“ -> „Neu“ -> „Modul importieren“ -> wählen Sie SRC_ROOT aus.

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

Schritt 2: Datei build.gradle der App aktualisieren

Führen Sie im App-Modul, das das generierte Bibliotheksmodul nutzen, 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();
}

Beschleunigung der Modellinferenz

Der generierte Code bietet Entwicklern die Möglichkeit, ihren Code mithilfe von Delegierten und der Anzahl der Threads zu beschleunigen. Diese können beim Initialisieren des Modellobjekts festgelegt werden, da dafür drei Parameter erforderlich sind:

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

Wenn Sie beispielsweise einen GPU-Delegaten 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 open as a file deskriptor; es ist wahrscheinlich komprimiert“ erhalten, fügen Sie die folgenden Zeilen unter dem Android-Bereich des App-Moduls ein, das das Bibliotheksmodul verwendet:

aaptOptions {
   noCompress "tflite"
}