Generuj interfejsy modelu za pomocą metadanych

Korzystając z TensorFlow Lite Metadata , 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ększej personalizacji lub korzystasz z 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 do automatycznego konfigurowania ustawień projektu i generowania klas otoki na podstawie metadanych modelu. Kod opakowania eliminuje potrzebę bezpośredniej interakcji z ByteBuffer . Zamiast tego programiści mogą wchodzić w interakcje z modelem TensorFlow Lite z typowanymi obiektami, takimi jak Bitmap i Rect .

Importuj model TensorFlow Lite w Android Studio

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

2. Wybierz lokalizację pliku TFLite. Pamiętaj, że oprzyrządowanie 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 do importowania GPU TensorFlow, jeśli chcesz użyć akceleracji GPU.

3. Kliknij Finish .

4. Po udanym imporcie 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.

Przyspieszenie wnioskowania modelu

Powiązanie modelu ML umożliwia deweloperom przyspieszenie kodu za pomocą delegatów i liczby wątków.

Krok 1. Sprawdź, czy plik build.gradle modułu 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. Wykryj, czy procesor graficzny działający na urządzeniu jest zgodny z delegatem GPU TensorFlow, jeśli nie, uruchom model przy użyciu wielu wątków procesora:

    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
      

Generuj interfejsy modeli za pomocą generatora kodu TensorFlow Lite

W przypadku modelu TensorFlow Lite wzbogaconego o metadane programiści mogą używać generatora kodu opakowania TensorFlow Lite Android do tworzenia kodu opakowania specyficznego dla platformy. Kod opakowania eliminuje potrzebę bezpośredniej interakcji z ByteBuffer . Zamiast tego programiści mogą wchodzić w interakcje z modelem TensorFlow Lite z typowanymi obiektami, takimi 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

Otrzymany kod zostanie umieszczony w katalogu docelowym. Jeśli korzystasz z Google Colab lub innego środowiska zdalnego, może być łatwiej 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')

Korzystanie z wygenerowanego kodu

Krok 1: Zaimportuj wygenerowany kod

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

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

Korzystając z powyższego przykładu, katalog i importowany moduł będą nazywane classify_wrapper .

Krok 2: Zaktualizuj plik build.gradle aplikacji

W module aplikacji, który będzie zużywał wygenerowany moduł biblioteki:

W sekcji Android dodaj następujące elementy:

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

Przyspieszenie wnioskowania modelu

Wygenerowany kod umożliwia deweloperom przyspieszenie ich kodu dzięki użyciu delegatów i liczby wątków. Można je ustawić podczas inicjowania obiektu modelu, ponieważ przyjmuje on trzy parametry:

• Context : kontekst z aktywności lub usługi Androida
• (Opcjonalnie) Device : delegat przyspieszenia TFLite, na przykład GPUDelegate lub NNAPIDelegate
• (Opcjonalnie) numThreads : Liczba wątków używanych do uruchomienia modelu — domyślnie 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: Ten plik nie może zostać otwarty jako deskryptor pliku; prawdopodobnie jest to błąd skompresowany”, wstaw następujące wiersze pod sekcją android modułu aplikacji, który będzie używał modułu biblioteki:

aaptOptions {
   noCompress "tflite"
}