Generowanie interfejsów modelu za pomocą metadanych

Za pomocą metadanych LiteRT programiści mogą generować kodu opakowującego, aby włączyć integrację na Androidzie. W przypadku większości programistów interfejs graficzny Android Studio ML Model Binding to jest najłatwiejsza w użyciu. Jeśli potrzebujesz większych możliwości dostosowania lub korzystasz z wiersza poleceń dostępny jest też LiteRT Codegen.

Używanie powiązania modeli ML w Android Studio

W przypadku modeli LiteRT wzbogaconych o metadane deweloperzy mogą używać powiązania modeli ML w Android Studio do automatycznej konfiguracji ustawień projektu i generuj klasy kodu na podstawie modelu metadanych. Kod opakowania eliminuje potrzebę bezpośredniej interakcji z ByteBuffer Zamiast tego deweloperzy mogą wchodzić w interakcje z modelem LiteRT. z wpisanymi obiektami, takimi jak Bitmap i Rect.

Importowanie modelu LiteRT w Android Studio

  1. Kliknij prawym przyciskiem myszy moduł, w którym chcesz używać modelu TFLite, lub kliknij File, a później New > Other > LiteRT Model

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

    Opcjonalnie: zaznacz drugie pole wyboru do importowania GPU TensorFlow, jeśli chcą używać akceleracji GPU.

  3. Kliknij Finish.

  4. Po zakończeniu importowania zostanie wyświetlony następujący ekran. Na początek za pomocą modelu, wybierz Kotlin lub Java, skopiuj i wklej kod pod Sample Code. Aby wrócić do tego ekranu, kliknij dwukrotnie model TFLite w katalogu ml w Android Studio.

Przyspieszanie wnioskowania modelu

ML Model Binding umożliwia programistom przyspieszenie tworzenia kodu liczbę przedstawicieli i liczbę wątków.

Krok 1. Sprawdź plik build.gradle modułu, aby upewnić się, że zawiera on następujące elementy zależność:

    dependencies {
        ...
        // TFLite GPU delegate 2.3.0 or above is required.
        implementation 'com.google.ai.edge.litert:litert-gpu:2.3.0'
    }

Krok 2. Wykrywanie, czy GPU działający na urządzeniu jest zgodny z GPU TensorFlow przekazać dostęp, jeśli model nie zostanie uruchomiony 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

Generuj interfejsy modelu za pomocą generatora kodu LiteRT

W przypadku modelu LiteRT wzbogaconego o metadane deweloperzy mogą korzystać z generatora kodu opakowań LiteRT na Androida, kod otokowy platformy. Kod otoki eliminuje potrzebę interakcji bezpośrednio w ByteBuffer. Deweloperzy mogą natomiast wchodzić w interakcje z TensorFlow, Model Lite z wpisywanymi obiektami, takimi jak Bitmap i Rect.

Przydatność generatora kodu zależy od kompletności Wpis metadanych modelu LiteRT. Więcej informacji znajdziesz w sekcji <Codegen usage> w odpowiednich polach metadata_schema.fbs, aby zobaczyć, jak narzędzie Codegen analizuje poszczególne pola.

Wygeneruj kod otoki

Musisz zainstalować w terminalu 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 jesteś przy użyciu Google Colab lub innego pilota najlepiej skompresować wyniki do archiwum ZIP i pobrać do projektu w 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 do struktury katalogu. Pierwiastek Przyjmuje się, że wygenerowany kod ma postać SRC_ROOT.

Otwórz projekt Android Studio, w którym chcesz używać LiteRT. model i zaimportuj wygenerowany moduł przez: I plik -> Nowe -> Importuj moduł -> wybierz SRC_ROOT

W podanym wyżej przykładzie zaimportowany katalog i zaimportowany moduł nazywałyby się classify_wrapper

Krok 2. Zaktualizuj plik build.gradle aplikacji

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

W sekcji dotyczącej Androida dodaj te elementy:

aaptOptions {
   noCompress "tflite"
}

W sekcji zależności dodaj te 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 modelu

Wygenerowany kod umożliwia programistom przyspieszenie procesu dzięki delegacjom oraz liczbie osób, . Można je ustawić podczas inicjowania obiektu modelu, ponieważ parametry:

  • Context: kontekst z aktywności lub usługi na Androidzie
  • (Opcjonalnie) Device: przedstawiciel przyspieszenia TFLite. Na przykład: GPUDelegate
  • (Opcjonalnie) numThreads: liczba wątków używanych do uruchomienia modelu – domyślnie wynosi 1.

Aby na przykład użyć delegata GPU i maksymalnie 3 wątków, możesz zainicjować w ten sposób:

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

Rozwiązywanie problemów

W przypadku wystąpienia błędu „java.io.FileNotFoundException: tego pliku nie można otworzyć jako deskryptor pliku; prawdopodobnie jest skompresowany”, wstaw następujące wiersze w sekcji dotyczącej Androida, która będzie korzystać z modułu biblioteki:

aaptOptions {
   noCompress "tflite"
}