Generieren Sie Modellschnittstellen mithilfe von Metadaten

Mithilfe von 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 von Android Studio ML Model Binding am einfachsten zu verwenden. Wenn Sie weitere Anpassungen benötigen oder Befehlszeilentools verwenden, ist auch TensorFlow Lite Codegen verfügbar.

Verwenden Sie die Android Studio ML-Modellbindung

Für TensorFlow Lite-Modelle, die mit Metadaten erweitert wurden , können Entwickler die Android Studio ML-Modellbindung verwenden, um Einstellungen für das Projekt automatisch zu konfigurieren und Wrapper-Klassen basierend auf den Modellmetadaten zu generieren. Der Wrapper-Code macht die direkte Interaktion mit ByteBuffer . Stattdessen können Entwickler mit dem TensorFlow Lite-Modell mit typisierten Objekten wie Bitmap und Rect interagieren.

Importieren Sie ein TensorFlow Lite-Modell in Android Studio

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 und dann auf New > Other > TensorFlow Lite Model

2. Wählen Sie den Speicherort Ihrer TFLite-Datei. Beachten Sie, dass das Tool die Abhängigkeit des Moduls in Ihrem Namen mit ML- build.gradle konfiguriert und alle Abhängigkeiten automatisch in die build.gradle Datei Ihres Android-Moduls build.gradle werden.

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

3. Klicken Sie auf Finish .

4. Der folgende Bildschirm wird angezeigt, nachdem der Import erfolgreich war. Um das Modell zu verwenden, wählen Sie Kotlin oder Java aus, kopieren Sie den Code und fügen Sie ihn im Abschnitt Sample Code ein. Sie können zu diesem Bildschirm zurückkehren, indem Sie in Android Studio im ml Verzeichnis auf das TFLite-Modell doppelklicken.

Beschleunigung der Modellinferenz

Die ML-Modellbindung bietet Entwicklern die Möglichkeit, ihren Code durch die Verwendung von Delegaten und die Anzahl der Threads zu beschleunigen.

Schritt 1. Überprüfen Sie die Datei build.gradle des Moduls, die 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. Stellen Sie fest, ob die auf dem Gerät ausgeführte GPU mit dem TensorFlow-GPU-Delegaten kompatibel ist, wenn Sie das Modell nicht mit mehreren CPU-Threads ausführen:

    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
      

    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
      

Generieren Sie Modellschnittstellen mit dem TensorFlow Lite-Codegenerator

Für das mit Metadaten erweiterte TensorFlow Lite-Modell können Entwickler den TensorFlow Lite-Android-Wrapper-Codegenerator verwenden, um plattformspezifischen Wrapper-Code zu erstellen. Der Wrapper-Code macht die direkte Interaktion mit ByteBuffer . 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 den relevanten Feldern in metadata_schema.fbs erfahren Sie, wie das Codegen-Tool die einzelnen Felder analysiert.

Generieren Sie Wrapper-Code

Sie müssen die folgenden Werkzeuge 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 Remoteumgebung verwenden, ist es möglicherweise einfacher, das Ergebnis in einem Zip-Archiv zu komprimieren 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')

Verwenden des generierten Codes

Schritt 1: Importieren Sie den generierten Code

Entpacken Sie den generierten Code bei Bedarf in eine Verzeichnisstruktur. Die Wurzel des generierten Codes wird als SRC_ROOT .

Öffnen Sie das Android Studio-Projekt, in dem Sie das TensorFlow Lite-Modell verwenden möchten, und importieren Sie das generierte Modul über: Und Datei -> Neu -> Modul SRC_ROOT -> SRC_ROOT Sie SRC_ROOT

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

Schritt 2: Aktualisieren Sie die build.gradle Datei der App

Im App-Modul, das das generierte Bibliotheksmodul verbraucht:

Fügen Sie im Android-Bereich Folgendes hinzu:

aaptOptions {
   noCompress "tflite"
}

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

implementation project(":classify_wrapper")

Schritt 3: Verwenden des Modells

// 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 durch die Verwendung von Delegaten und die Anzahl der Threads zu beschleunigen. Diese können beim Initiieren des Modellobjekts festgelegt werden, da drei Parameter erforderlich sind:

• Context : Kontext aus der Android-Aktivität oder dem Android-Dienst
• (Optional) Device : TFLite-Beschleunigungsdelegierter, z. B. GPUDelegate oder NNAPIDelegate
• (Optional) numThreads : Anzahl der Threads, die zum Ausführen des Modells verwendet werden - Standard ist eins.

Um beispielsweise einen NNAPI-Delegaten und bis zu drei Threads zu verwenden, können Sie das Modell folgendermaßen initialisieren:

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

Fehlerbehebung

Wenn Sie eine 'java.io.FileNotFoundException' erhalten: Diese Datei kann nicht als Dateideskriptor geöffnet werden. Es ist wahrscheinlich ein komprimierter Fehler. Fügen Sie die folgenden Zeilen unter den Android-Abschnitt des App-Moduls ein, der das Bibliotheksmodul verwendet:

aaptOptions {
   noCompress "tflite"
}