Generuj interfejsy modelu za pomocą metadanych

Korzystając z metadanych TensorFlow Lite , programiści mogą generować kod opakowania, aby umożliwić integrację z systemem Android. Dla większości programistów interfejs graficzny Android Studio ML Model Binding jest najłatwiejszy w użyciu. Jeśli potrzebujesz większego dostosowania lub używasz narzędzi wiersza poleceń, dostępny jest również TensorFlow Lite Codegen .

Użyj powiązania modelu Android Studio ML

W przypadku modeli TensorFlow Lite wzbogaconych o metadane programiści mogą używać powiązania modelu Android Studio ML w celu automatycznego konfigurowania ustawień projektu i generowania klas opakowań na podstawie metadanych modelu. Kod opakowania eliminuje potrzebę bezpośredniej interakcji z ByteBuffer . Zamiast tego programiści mogą wchodzić w interakcję z modelem TensorFlow Lite za pomocą obiektów wpisanych, takich jak Bitmap i Rect .

Zaimportuj model TensorFlow Lite w Android Studio

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

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

    Opcjonalnie: Zaznacz drugie pole wyboru importowania procesora graficznego TensorFlow, jeśli chcesz używać akceleracji GPU.

  3. Kliknij Finish .

  4. Po pomyślnym zakończeniu importu pojawi się następujący ekran. Aby rozpocząć korzystanie z modelu, wybierz Kotlin lub Java, skopiuj i wklej kod w sekcji Sample Code . Możesz wrócić do tego ekranu, klikając dwukrotnie model TFLite w katalogu ml w Android Studio.

Przyspieszanie wnioskowania o modelu

Powiązanie modelu ML umożliwia deweloperom przyspieszenie kodu poprzez użycie delegatów i liczby wątków.

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

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

Krok 2. Sprawdź, czy procesor graficzny działający na urządzeniu jest kompatybilny z delegatem GPU TensorFlow, jeśli nie, uruchom model przy użyciu wielu wątków procesora:

Kotlina

    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

Jawa

    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

Generuj interfejsy modeli za pomocą generatora kodu TensorFlow Lite

W przypadku modelu TensorFlow Lite wzbogaconego o metadane programiści mogą użyć generatora kodu opakowania TensorFlow Lite dla systemu Android, aby utworzyć kod opakowania specyficzny dla platformy. Kod opakowania eliminuje potrzebę bezpośredniej interakcji z ByteBuffer . Zamiast tego programiści mogą wchodzić w interakcję z modelem TensorFlow Lite za pomocą obiektów wpisanych, takich jak Bitmap i Rect .

Przydatność generatora kodu zależy od kompletności wpisu metadanych modelu TensorFlow Lite. Zapoznaj się z sekcją <Codegen usage> w odpowiednich polach w metadata_schema.fbs , aby zobaczyć, jak narzędzie codegen analizuje każde pole.

Wygeneruj kod opakowania

Będziesz musiał zainstalować następujące narzędzia w swoim terminalu:

pip install tflite-support

Po zakończeniu generator kodu może być używany przy użyciu następującej 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

Wynikowy kod będzie znajdować się w katalogu docelowym. Jeśli korzystasz z Google Colab lub innego środowiska zdalnego, być może łatwiej będzie spakować wynik w 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')

Korzystanie z wygenerowanego kodu

Krok 1: Zaimportuj wygenerowany kod

W razie potrzeby rozpakuj wygenerowany kod do struktury katalogów. Zakłada się, że katalogiem głównym wygenerowanego kodu jest SRC_ROOT .

Otwórz projekt Android Studio, w którym chcesz użyć modelu TensorFlow lite i zaimportuj wygenerowany moduł poprzez: And File -> New -> Import Module -> wybierz SRC_ROOT

Korzystając z powyższego przykładu, 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 następujące informacje:

aaptOptions {
   noCompress "tflite"
}

W sekcji zależności dodaj następujące elementy:

implementation project(":classify_wrapper")

Krok 3: Korzystanie z 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 o modelu

Wygenerowany kod umożliwia programistom przyspieszenie kodu poprzez użycie delegatów i liczby wątków. Można je ustawić podczas inicjowania obiektu modelu, ponieważ przyjmuje on trzy parametry:

  • Context : kontekst z działania lub usługi systemu Android
  • (Opcjonalnie) Device : Delegat akceleracji TFLite, na przykład GPUDelegate lub NNAPIDelegate
  • (Opcjonalnie) numThreads : Liczba wątków używanych do uruchomienia modelu — wartość domyślna to jeden.

Na przykład, aby użyć delegata NNAPI i maksymalnie trzech wątków, możesz zainicjować model w następujący sposób:

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

Rozwiązywanie problemów

Jeśli otrzymasz wyjątek „java.io.FileNotFoundException: tego pliku nie można otworzyć jako deskryptora pliku; prawdopodobnie jest to błąd skompresowany, wstaw następujące wiersze w sekcji Android modułu aplikacji, która będzie korzystać z modułu bibliotecznego:

aaptOptions {
   noCompress "tflite"
}