Pilih operator TensorFlow

Karena library operator bawaan LiteRT hanya mendukung sejumlah kecil operator TensorFlow, tidak semua model dapat dikonversi. Untuk mengetahui detailnya, lihat kompatibilitas operator.

Untuk mengizinkan konversi, pengguna dapat mengaktifkan penggunaan ops TensorFlow tertentu dalam model LiteRT mereka. Namun, menjalankan model LiteRT dengan operasi TensorFlow memerlukan penarikan runtime TensorFlow inti, yang meningkatkan ukuran biner penafsir LiteRT. Untuk Android, Anda dapat menghindari hal ini dengan membangun secara selektif hanya operasi Tensorflow yang diperlukan. Untuk mengetahui detailnya, lihat mengurangi ukuran biner.

Dokumen ini menguraikan cara mengonversi dan menjalankan model LiteRT yang berisi operasi TensorFlow di platform pilihan Anda. Dokumen ini juga membahas metrik performa dan ukuran serta keterbatasan yang diketahui.

Mengonversi model

Contoh berikut menunjukkan cara membuat model LiteRT dengan operasi TensorFlow tertentu.

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)

Menjalankan Inferensi

Saat menggunakan model LiteRT yang telah dikonversi dengan dukungan untuk operasi TensorFlow tertentu, klien juga harus menggunakan runtime LiteRT yang menyertakan library operasi TensorFlow yang diperlukan.

AAR Android

Untuk mengurangi ukuran biner, buat file AAR kustom Anda sendiri seperti yang dijelaskan di bagian berikutnya. Jika ukuran biner tidak terlalu menjadi masalah, sebaiknya gunakan AAR bawaan dengan operasi TensorFlow yang dihosting di MavenCentral.

Anda dapat menentukannya dalam dependensi build.gradle dengan menambahkannya bersama AAR LiteRT standar sebagai berikut:

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'
}

Untuk menggunakan snapshot malam, pastikan Anda telah menambahkan repositori snapshot Sonatype.

Setelah menambahkan dependensi, delegasi yang diperlukan untuk menangani operasi TensorFlow grafik akan otomatis diinstal untuk grafik yang memerlukannya.

Catatan: Dependensi operasi TensorFlow relatif besar, jadi sebaiknya Anda memfilter ABI x86 yang tidak diperlukan dalam file .gradle dengan menyiapkan abiFilters.

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

Membangun AAR Android

Untuk mengurangi ukuran biner atau kasus lanjutan lainnya, Anda juga dapat membuat pustaka secara manual. Dengan asumsi lingkungan build LiteRT yang berfungsi, build AAR Android dengan memilih operasi TensorFlow sebagai berikut:

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

Langkah ini akan menghasilkan file AAR bazel-bin/tmp/tensorflow-lite.aar untuk operasi bawaan dan kustom LiteRT; serta menghasilkan file AAR bazel-bin/tmp/tensorflow-lite-select-tf-ops.aar untuk operasi TensorFlow. Jika Anda tidak memiliki lingkungan build yang berfungsi, Anda juga dapat membangun file di atas dengan docker.

Dari sana, Anda dapat mengimpor file AAR langsung ke project, atau memublikasikan file AAR kustom ke repositori Maven lokal:

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

Terakhir, di build.gradle aplikasi Anda, pastikan Anda memiliki dependensi mavenLocal() dan ganti dependensi LiteRT standar dengan dependensi yang memiliki dukungan untuk operasi TensorFlow tertentu:

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

Menggunakan CocoaPods

LiteRT menyediakan CocoaPods TF ops pilihan yang telah dibuat sebelumnya setiap malam untuk arm64, yang dapat Anda gunakan bersama dengan CocoaPods TensorFlowLiteSwift atau TensorFlowLiteObjC.

Catatan: Jika Anda perlu menggunakan operasi TF tertentu di simulator x86_64, Anda dapat membuat framework operasi pemilihan sendiri. Lihat bagian Menggunakan Bazel + Xcode untuk mengetahui detail selengkapnya.

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

Setelah menjalankan pod install, Anda perlu memberikan flag linker tambahan untuk memuat paksa framework operasi TF yang dipilih ke dalam project Anda. Di project Xcode Anda, buka Build Settings -> Other Linker Flags, lalu tambahkan:

Untuk versi >= 2.9.0:

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

Untuk versi < 2.9.0:

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

Kemudian, Anda dapat menjalankan model apa pun yang dikonversi dengan SELECT_TF_OPS di aplikasi iOS Anda. Misalnya, Anda dapat mengubah aplikasi Image Classification iOS untuk menguji fitur operasi TF yang dipilih.

• Ganti file model dengan file yang dikonversi dengan mengaktifkan SELECT_TF_OPS.
• Tambahkan dependensi TensorFlowLiteSelectTfOps ke Podfile seperti yang diinstruksikan.
• Tambahkan tanda linker tambahan seperti di atas.
• Jalankan aplikasi contoh dan lihat apakah model berfungsi dengan benar.

Menggunakan Bazel + Xcode

LiteRT dengan operasi TensorFlow tertentu untuk iOS dapat dibangun menggunakan Bazel. Pertama, ikuti petunjuk build iOS untuk mengonfigurasi ruang kerja Bazel dan file .bazelrc dengan benar.

Setelah mengonfigurasi ruang kerja dengan dukungan iOS yang diaktifkan, Anda dapat menggunakan perintah berikut untuk membuat framework add-on operasi TF pilihan, yang dapat ditambahkan di atas TensorFlowLiteC.framework reguler. Perhatikan bahwa framework operasi TF yang dipilih tidak dapat dibuat untuk arsitektur i386, jadi Anda harus memberikan daftar arsitektur target secara eksplisit, tidak termasuk i386.

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

Tindakan ini akan membuat framework di direktori bazel-bin/tensorflow/lite/ios/. Anda dapat menambahkan framework baru ini ke project Xcode dengan mengikuti langkah-langkah serupa yang dijelaskan di bagian Setelan project Xcode dalam panduan build iOS.

Setelah menambahkan framework ke project aplikasi, tanda linker tambahan harus ditentukan di project aplikasi untuk memuat paksa framework operasi TF yang dipilih. Di project Xcode, buka Build Settings -> Other Linker Flags, lalu tambahkan:

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

C/C++

Jika Anda menggunakan Bazel atau CMake untuk membuat interpreter LiteRT, Anda dapat mengaktifkan delegasi Flex dengan menautkan library bersama delegasi Flex LiteRT. Anda dapat mem-build-nya dengan Bazel sebagai perintah berikut.

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

Perintah ini akan menghasilkan library bersama berikut di bazel-bin/tensorflow/lite/delegates/flex.

Perhatikan bahwa TfLiteDelegate yang diperlukan akan diinstal secara otomatis saat membuat interpreter pada waktu proses selama library bersama ditautkan. Anda tidak perlu menginstal instance delegasi secara eksplisit seperti yang biasanya diperlukan dengan jenis delegasi lainnya.

Catatan: Fitur ini tersedia sejak versi 2.7.

Python

LiteRT dengan operasi TensorFlow tertentu akan diinstal secara otomatis dengan paket pip TensorFlow. Anda juga dapat memilih untuk hanya menginstal paket pip LiteRT Interpreter.

Metrik

Performa

Saat menggunakan campuran operasi TensorFlow bawaan dan pilihan, semua pengoptimalan LiteRT dan operasi bawaan yang dioptimalkan yang sama akan tersedia dan dapat digunakan dengan model yang dikonversi.

Tabel berikut menjelaskan waktu rata-rata yang diperlukan untuk menjalankan inferensi pada MobileNet di Pixel 2. Waktu yang tercantum adalah rata-rata dari 100 kali proses. Target ini dibuat untuk Android menggunakan tanda: --config=android_arm64 -c opt.

Ukuran biner

Tabel berikut menjelaskan ukuran biner LiteRT untuk setiap build. Target ini dibuat untuk Android menggunakan --config=android_arm -c opt.

(1) Library ini dibuat secara selektif untuk model i3d-kinetics-400 dengan 8 operasi bawaan TFLite dan 3 operasi Tensorflow. Untuk mengetahui detail selengkapnya, lihat bagian Mengurangi ukuran biner LiteRT.

Batasan umum

• Jenis yang tidak didukung: Operasi TensorFlow tertentu mungkin tidak mendukung kumpulan lengkap jenis input/output yang biasanya tersedia di TensorFlow.

Update

• Versi 2.6
  • Dukungan untuk operator berbasis atribut GraphDef dan inisialisasi resource HashTable telah ditingkatkan.
• Versi 2.5
  • Anda dapat menerapkan pengoptimalan yang dikenal sebagai kuantisasi pasca-pelatihan
• Versi 2.4
  • Kompatibilitas dengan delegasi yang dipercepat hardware telah ditingkatkan