Wybierz operatory TensorFlow

Biblioteka wbudowanych operatorów LiteRT obsługuje tylko ograniczoną liczbę operatorów TensorFlow, więc nie każdy model można przekonwertować. Szczegółowe informacje znajdziesz w sekcji zgodność z operatorami.

Aby umożliwić konwersję, użytkownicy mogą włączyć w modelu LiteRT używanie określonych operacji TensorFlow. Uruchamianie modeli LiteRT z operacjami TensorFlow wymaga jednak pobrania podstawowego środowiska wykonawczego TensorFlow, co zwiększa rozmiar pliku binarnego interpretera LiteRT. W przypadku Androida możesz tego uniknąć, tworząc tylko wymagane operacje TensorFlow. Szczegółowe informacje znajdziesz w artykule Zmniejszanie rozmiaru pliku binarnego.

W tym dokumencie opisujemy, jak przekonwertować i uruchomić model LiteRT zawierający operacje TensorFlow na wybranej platformie. Omówiono w nim też dane o skuteczności i rozmiarze oraz znane ograniczenia.

Konwertowanie modelu

Poniższy przykład pokazuje, jak wygenerować model LiteRT z wybranymi operacjami TensorFlow.

import tensorflow as tf

converter = tf.lite.TFLiteConverter.from_saved_model(saved_model_dir)
converter.target_spec.supported_ops = [
  tf.lite.OpsSet.TFLITE_BUILTINS, # enable LiteRT ops.
  tf.lite.OpsSet.SELECT_TF_OPS # enable TensorFlow ops.
]
tflite_model = converter.convert()
open("converted_model.tflite", "wb").write(tflite_model)

Uruchom wnioskowanie

Jeśli używasz modelu LiteRT przekonwertowanego z obsługą wybranych operacji TensorFlow, klient musi też używać środowiska wykonawczego LiteRT, które zawiera niezbędną bibliotekę operacji TensorFlow.

Android AAR

Aby zmniejszyć rozmiar pliku binarnego, utwórz własne niestandardowe pliki AAR zgodnie z instrukcjami w następnej sekcji. Jeśli rozmiar pliku binarnego nie jest istotny, zalecamy używanie gotowego pliku AAR z operacjami TensorFlow hostowanego w MavenCentral.

Możesz to określić w build.gradle zależnościach, dodając ją obok standardowego pliku AAR LiteRT w ten sposób:

dependencies {
    implementation 'org.tensorflow:tensorflow-lite:0.0.0-nightly-SNAPSHOT'
    // This dependency adds the necessary TF op support.
    implementation 'org.tensorflow:tensorflow-lite-select-tf-ops:0.0.0-nightly-SNAPSHOT'
}

Aby korzystać z nocnych migawek, musisz dodać repozytorium migawek Sonatype.

Po dodaniu zależności niezbędny delegat do obsługi operacji TensorFlow w grafie powinien zostać automatycznie zainstalowany w przypadku grafów, które go wymagają.

Uwaga: zależność od operacji TensorFlow jest stosunkowo duża, więc prawdopodobnie warto odfiltrować niepotrzebne interfejsy ABI x86 w pliku .gradle, konfigurując abiFilters.

android {
    defaultConfig {
        ndk {
            abiFilters 'armeabi-v7a', 'arm64-v8a'
        }
    }
}

Tworzenie pliku AAR na Androida

Aby zmniejszyć rozmiar pliku binarnego lub w innych zaawansowanych przypadkach, możesz też ręcznie skompilować bibliotekę. Zakładając, że masz działające środowisko kompilacji LiteRT, skompiluj plik AAR na Androida z wybranymi operacjami TensorFlow w ten sposób:

sh tensorflow/lite/tools/build_aar.sh \
  --input_models=/a/b/model_one.tflite,/c/d/model_two.tflite \
  --target_archs=x86,x86_64,arm64-v8a,armeabi-v7a

Spowoduje to wygenerowanie pliku AAR bazel-bin/tmp/tensorflow-lite.aar dla wbudowanych i niestandardowych operacji LiteRT oraz pliku AAR bazel-bin/tmp/tensorflow-lite-select-tf-ops.aar dla operacji TensorFlow. Jeśli nie masz działającego środowiska kompilacji, możesz też skompilować powyższe pliki za pomocą Dockera.

Możesz zaimportować pliki AAR bezpośrednio do projektu lub opublikować niestandardowe pliki AAR w lokalnym repozytorium Maven:

mvn install:install-file \
  -Dfile=bazel-bin/tmp/tensorflow-lite.aar \
  -DgroupId=org.tensorflow \
  -DartifactId=tensorflow-lite -Dversion=0.1.100 -Dpackaging=aar
mvn install:install-file \
  -Dfile=bazel-bin/tmp/tensorflow-lite-select-tf-ops.aar \
  -DgroupId=org.tensorflow \
  -DartifactId=tensorflow-lite-select-tf-ops -Dversion=0.1.100 -Dpackaging=aar

Na koniec w build.gradleaplikacji upewnij się, że masz zależność mavenLocal() i zastąp standardową zależność LiteRT zależnością, która obsługuje wybrane operacje TensorFlow:

allprojects {
    repositories {
        mavenCentral()
        maven {  // Only for snapshot artifacts
            name 'ossrh-snapshot'
            url 'https://oss.sonatype.org/content/repositories/snapshots'
        }
        mavenLocal()
    }
}

dependencies {
    implementation 'org.tensorflow:tensorflow-lite:0.1.100'
    implementation 'org.tensorflow:tensorflow-lite-select-tf-ops:0.1.100'
}

iOS

Korzystanie z CocoaPods

LiteRT udostępnia wstępnie skompilowane wybrane operacje TF w CocoaPods na potrzeby arm64, od których możesz być zależny wraz z CocoaPods TensorFlowLiteSwift lub TensorFlowLiteObjC.

Uwaga: jeśli chcesz używać wybranych operacji TF w x86_64 symulatorze, możesz samodzielnie utworzyć framework wybranych operacji. Więcej informacji znajdziesz w sekcji Korzystanie z Bazel i Xcode.

# In your Podfile target:
  pod 'TensorFlowLiteSwift'   # or 'TensorFlowLiteObjC'
  pod 'TensorFlowLiteSelectTfOps', '~> 0.0.1-nightly'

Po uruchomieniu polecenia pod install musisz podać dodatkową flagę linkera, aby wymusić załadowanie do projektu wybranego frameworka operacji TF. W projekcie Xcode kliknij kolejno Build Settings -> Other Linker Flags i dodaj:

W przypadku wersji ≥ 2.9.0:

-force_load $(SRCROOT)/Pods/TensorFlowLiteSelectTfOps/Frameworks/TensorFlowLiteSelectTfOps.xcframework/ios-arm64/TensorFlowLiteSelectTfOps.framework/TensorFlowLiteSelectTfOps

W przypadku wersji wcześniejszych niż 2.9.0:

-force_load $(SRCROOT)/Pods/TensorFlowLiteSelectTfOps/Frameworks/TensorFlowLiteSelectTfOps.framework/TensorFlowLiteSelectTfOps

Następnie w aplikacji na iOS możesz uruchamiać dowolne modele przekonwertowane za pomocą SELECT_TF_OPS. Możesz na przykład zmodyfikować aplikację do klasyfikacji obrazów na iOS, aby przetestować funkcję wybierania operacji TF.

• Zastąp plik modelu plikiem przekonwertowanym z włączoną funkcją SELECT_TF_OPS.
• Dodaj zależność TensorFlowLiteSelectTfOps do Podfile zgodnie z instrukcjami.
• Dodaj dodatkową flagę linkera w sposób opisany powyżej.
• Uruchom przykładową aplikację i sprawdź, czy model działa prawidłowo.

Korzystanie z Bazel i Xcode

LiteRT z wybranymi operacjami TensorFlow na iOS można utworzyć za pomocą Bazela. Najpierw postępuj zgodnie z instrukcjami kompilacji na iOS, aby prawidłowo skonfigurować obszar roboczy Bazel i plik .bazelrc.

Po skonfigurowaniu obszaru roboczego z włączoną obsługą iOS możesz użyć tego polecenia, aby utworzyć wybraną strukturę dodatku TF Ops, którą można dodać do zwykłego TensorFlowLiteC.framework. Pamiętaj, że platformy select TF ops nie można utworzyć dla architektury i386, więc musisz wyraźnie podać listę docelowych architektur z wyłączeniem i386.

bazel build -c opt --config=ios --ios_multi_cpus=arm64,x86_64 \
  //tensorflow/lite/ios:TensorFlowLiteSelectTfOps_framework

Spowoduje to wygenerowanie platformy w katalogu bazel-bin/tensorflow/lite/ios/. Aby dodać tę nową platformę do projektu Xcode, wykonaj podobne czynności opisane w sekcji Ustawienia projektu Xcode w przewodniku po kompilacji na iOS.

Po dodaniu platformy do projektu aplikacji w projekcie aplikacji należy określić dodatkową flagę linkera, aby wymusić wczytanie wybranej platformy operacji TF. W projekcie Xcode kliknij Build Settings -> Other Linker Flags i dodaj:

-force_load <path/to/your/TensorFlowLiteSelectTfOps.framework/TensorFlowLiteSelectTfOps>

Kod C/C++

Jeśli do tworzenia interpretera LiteRT używasz narzędzia Bazel lub CMake, możesz włączyć delegata Flex, łącząc bibliotekę współdzieloną delegata LiteRT Flex. Możesz go utworzyć za pomocą Bazela, używając tego polecenia:

bazel build -c opt --config=monolithic tensorflow/lite/delegates/flex:tensorflowlite_flex

To polecenie generuje w bazel-bin/tensorflow/lite/delegates/flex następującą bibliotekę współdzieloną:

Pamiętaj, że niezbędne TfLiteDelegate zostaną zainstalowane automatycznie podczas tworzenia interpretera w czasie działania programu, o ile biblioteka współdzielona jest połączona. Nie musisz wyraźnie instalować instancji delegata, jak to zwykle jest wymagane w przypadku innych typów delegatów.

Uwaga: ta funkcja jest dostępna od wersji 2.7.

Python

LiteRT z wybranymi operacjami TensorFlow zostanie zainstalowany automatycznie wraz z pakietem pip TensorFlow. Możesz też zainstalować tylko pakiet pip interpretera LiteRT.

Dane

Wyniki

Jeśli używasz zarówno wbudowanych, jak i wybranych operacji TensorFlow, wszystkie optymalizacje LiteRT i zoptymalizowane operacje wbudowane będą dostępne i można ich będzie używać w przypadku przekonwertowanego modelu.

W tabeli poniżej podano średni czas wnioskowania w przypadku modelu MobileNet na Pixelu 2. Podane czasy są średnią ze 100 przejazdów. Te elementy docelowe zostały utworzone na potrzeby Androida przy użyciu tych flag: --config=android_arm64 -c opt.

Wartość atrybutu size pliku binarnego

W tabeli poniżej podano rozmiar binarny LiteRT w przypadku poszczególnych kompilacji. Te elementy docelowe zostały utworzone na Androida za pomocą --config=android_arm -c opt.

(1) Te biblioteki są tworzone selektywnie dla modelu i3d-kinetics-400 z 8 wbudowanymi operacjami TFLite i 3 operacjami TensorFlow. Więcej informacji znajdziesz w sekcji Zmniejszanie rozmiaru pliku binarnego LiteRT.

Znane ograniczenia

• Nieobsługiwane typy: niektóre operacje TensorFlow mogą nie obsługiwać pełnego zestawu typów wejściowych/wyjściowych, które są zwykle dostępne w TensorFlow.

Aktualizacje

• Wersja 2.6
  • Ulepszyliśmy obsługę operatorów opartych na atrybutach GraphDef i inicjowania zasobów HashTable.
• Wersja 2.5
  • Możesz zastosować optymalizację znaną jako kwantyzacja po trenowaniu.
• Wersja 2.4
  • Zwiększyliśmy zgodność z delegatami akcelerowanymi sprzętowo.