Generowanie interfejsów modelu za pomocą metadanych

Za pomocą metadanych TensorFlow Lite deweloperzy mogą wygenerować kod otoki umożliwiający integrację na Androidzie. Dla większości deweloperów najłatwiejszym w użyciu jest interfejsem graficznym Android Studio ML Model Binding. Jeśli potrzebujesz większych możliwości dostosowywania lub korzystasz z narzędzi wiersza poleceń, dostępny jest również TensorFlow Lite Codegen.

Użyj powiązania modelu ML Android Studio

W przypadku modeli TensorFlow Lite udoskonalonych za pomocą metadanych deweloperzy mogą za pomocą powiązań modeli ML Android Studio automatycznie konfigurować ustawienia projektu i generować klasy opakowań na podstawie metadanych modelu. Kod towarzyszący eliminuje konieczność bezpośredniej interakcji z elementem ByteBuffer. Zamiast tego programiści mogą wchodzić w interakcje z modelem TensorFlow Lite z typami obiektów, takimi jak Bitmap i Rect.

Importowanie modelu TensorFlow Lite w Android Studio

  1. Kliknij prawym przyciskiem myszy moduł, w którym chcesz używać modelu TFLite, lub kliknij File, a następnie New > Other > TensorFlow Lite Model.

  2. Wybierz lokalizację pliku TFLite. Pamiętaj, że to narzędzie skonfiguruje zależność modułu w Twoim imieniu za pomocą powiązania modelu ML, a wszystkie zależności zostaną automatycznie wstawione do pliku build.gradle modułu Androida.

    Opcjonalnie: zaznacz drugie pole wyboru importu GPU TensorFlow, jeśli chcesz używać akceleracji GPU.

  3. Kliknij Finish.

  4. Po pomyślnym zaimportowaniu pojawi się następujący ekran. Aby zacząć używać modelu, wybierz Kotlin lub Java, a następnie skopiuj kod i wklej go w sekcji Sample Code. Aby wrócić do tego ekranu, kliknij dwukrotnie model TFLite w katalogu ml w Android Studio.

Przyspieszanie wnioskowania modelu

Powiązanie modelu ML umożliwia programistom przyspieszenie tworzenia kodu przez wykorzystanie przedstawicieli i liczby wątków.

Krok 1. Sprawdź, czy plik modułu build.gradle zawiera tę zależność:

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

Krok 2. Ustal, czy procesor graficzny działający na urządzeniu jest zgodny z delegowaniem GPU TensorFlow, a jeśli nie zostanie uruchomiony model z użyciem wielu wątków procesora:

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

Generowanie interfejsów modelu za pomocą generatora kodu TensorFlow Lite

W przypadku modelu TensorFlow Lite ulepszonego za pomocą metadanych programiści mogą użyć generatora kodów opakowań na Androida TensorFlow Lite, aby utworzyć kod otoki specyficzny dla platformy. Kod towarzyszący eliminuje konieczność bezpośredniej interakcji z elementem ByteBuffer. Zamiast tego programiści mogą wchodzić w interakcje z modelem TensorFlow Lite z wpisanymi obiektami, takimi jak Bitmap i Rect.

Przydatność generatora kodu zależy od kompletności wpisu metadanych modelu TensorFlow Lite. Aby dowiedzieć się, jak narzędzie do generowania kodu analizuje poszczególne pola, zajrzyj do sekcji <Codegen usage> w sekcji dotyczącej odpowiednich pól w schemacie metadata_schema.fbs.

Wygeneruj kod otoki

W terminalu musisz zainstalować te narzędzia:

pip install tflite-support

Gdy skończysz, możesz użyć generatora kodu, korzystając z tej składni:

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

Powstały kod będzie się znajdować w katalogu docelowym. Jeśli używasz Google Colab lub innego środowiska zdalnego, być może łatwiej będzie spakować wynik do archiwum ZIP i pobrać go do projektu Android Studio:

# 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')

Używanie wygenerowanego kodu

Krok 1. Zaimportuj wygenerowany kod

W razie potrzeby rozpakuj wygenerowany kod w strukturze katalogów. Przyjmuje się, że rdzeniem wygenerowanego kodu jest SRC_ROOT.

Otwórz projekt Android Studio, w którym chcesz użyć modelu uproszczonego TensorFlow, i zaimportuj wygenerowany moduł. W tym celu wybierz opcję Plik -> Nowy -> Importuj moduł -> wybierz SRC_ROOT.

W powyższym przykładzie zaimportowany katalog i moduł będą miały nazwę classify_wrapper.

Krok 2. Zaktualizuj plik build.gradle aplikacji

W module aplikacji, który będzie korzystać z wygenerowanego modułu biblioteki:

W sekcji „Android” dodaj:

aaptOptions {
   noCompress "tflite"
}

W sekcji zależności dodaj:

implementation project(":classify_wrapper")

Krok 3. Używanie modelu

// 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();
}

Przyspieszanie wnioskowania modelu

Wygenerowany kod pozwala deweloperom przyspieszyć tworzenie kodu przez zastosowanie przedstawicieli i zwiększenie liczby wątków. Można je ustawić podczas inicjowania obiektu modelu, ponieważ wymaga on 3 parametrów:

  • Context: kontekst z aktywności lub usługi Androida
  • (Opcjonalnie) Device: osoba z przekazanym dostępem do akceleracji TFLite. Na przykład: GPUDelegate
  • (Opcjonalnie) numThreads: liczba wątków użytych do uruchomienia modelu. Wartość domyślna to 1.

Aby np. użyć delegata GPU i maksymalnie 3 wątków, możesz zainicjować model w ten sposób:

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

Rozwiązywanie problemów

Jeśli pojawi się błąd „java.io.FileNotFoundException: tego pliku nie można otworzyć jako deskryptora pliku; prawdopodobnie jest on skompresowany”, wstaw te wiersze w sekcji „android” modułu aplikacji, który będzie używał modułu biblioteki:

aaptOptions {
   noCompress "tflite"
}