Pilih operator TensorFlow

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

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

Dokumen ini menjelaskan cara mengonversi dan menjalankan model LiteRT yang berisi operasi TensorFlow pada platform pilihan Anda. Artikel ini juga membahas performa dan ukuran metrik dan batasan umum.

Mengonversi model

Contoh berikut menunjukkan cara membuat model LiteRT dengan Operasi 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)

Jalankan Inferensi

Saat menggunakan model LiteRT yang telah dikonversi dengan dukungan untuk memilih TensorFlow, 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 dipandu bagian berikutnya. Jika ukuran biner bukan kekhawatiran yang cukup besar, sebaiknya gunakan AAR bawaan dengan operasi TensorFlow dihosting di MavenCentral.

Anda dapat menentukan ini 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 setiap malam, pastikan Anda telah menambahkan snapshot Sonatype repositori Anda.

Setelah Anda menambahkan dependensi, delegasi yang diperlukan untuk menangani operasi TensorFlow grafik harus otomatis diinstal untuk grafik yang memerlukan mereka.

Catatan: Dependensi operasi TensorFlow relatif besar, jadi Anda mungkin akan ingin memfilter ABI x86 yang tidak diperlukan di file .gradle dengan menyiapkan abiFilters Anda.

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

Membangun AAR Android

Untuk mengurangi ukuran biner atau kasus lanjutan lainnya, Anda juga dapat membangun library secara manual. Dengan asumsi build LiteRT yang berfungsi , build AAR Android dengan operasi TensorFlow tertentu sebagai berikut ini:

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

Tindakan ini akan menghasilkan file AAR bazel-bin/tmp/tensorflow-lite.aar untuk Operasi kustom dan bawaan LiteRT; dan membuat 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 Anda, atau publikasikan file AAR kustom ke repositori Maven lokal Anda:

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, pastikan Anda memiliki mavenLocal() dan mengganti dependensi LiteRT standar dengan 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 tertentu bawaan per malam untuk arm64, yang dapat Anda andalkan bersama TensorFlowLiteSwift atau TensorFlowLiteObjC CocoaPods.

Catatan: Jika perlu menggunakan TF Ops tertentu dalam simulator x86_64, Anda dapat membangun pilih sendiri framework ops. Lihat Menggunakan Bazel + Xcode untuk detail selengkapnya.

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

Setelah menjalankan pod install, Anda harus memberikan tanda penaut tambahan untuk memuat paksa kerangka kerja operasi TF yang dipilih ke dalam proyek 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

Anda kemudian dapat menjalankan model apa pun yang dikonversi dengan SELECT_TF_OPS di aplikasi iOS Anda. Misalnya, Anda dapat memodifikasi Klasifikasi Gambar iOS aplikasi untuk menguji fitur TF Ops yang dipilih.

• Ganti file model dengan file yang dikonversi dengan SELECT_TF_OPS yang diaktifkan.
• Tambahkan dependensi TensorFlowLiteSelectTfOps ke Podfile seperti yang ditunjukkan.
• Tambahkan tanda penaut tambahan seperti di atas.
• Jalankan aplikasi contoh dan lihat apakah model tersebut 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 diaktifkan, Anda dapat menggunakan perintah berikut untuk membangun framework add-on operasi TF yang dipilih, yang dapat ditambahkan selain TensorFlowLiteC.framework reguler. Perhatikan bahwa operasi TF tertentu framework tidak dapat dibuat untuk arsitektur i386, jadi Anda harus secara eksplisit menyediakan daftar arsitektur target, kecuali i386.

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

Tindakan ini akan membuat framework di bazel-bin/tensorflow/lite/ios/ saat ini. Anda dapat menambahkan kerangka kerja baru ini ke proyek Xcode Anda dengan mengikuti langkah-langkah serupa yang dijelaskan dalam proyek Xcode bagian setelan di Panduan build iOS.

Setelah menambahkan framework ke project aplikasi Anda, flag penaut tambahan harus ditentukan dalam project aplikasi Anda untuk memuat paksa operasi TF yang dipilih Google Workspace for Education. Di project Xcode Anda, 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 LiteRT penerjemah, Anda dapat mengaktifkan delegasi Flex dengan menautkan LiteRT Flex mendelegasikan pustaka bersama. Anda dapat membuatnya dengan Bazel sebagai perintah berikut.

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

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

Perhatikan bahwa TfLiteDelegate yang diperlukan akan otomatis diinstal saat membuat penafsir saat runtime selama library bersama ditautkan. Ini tidak perlu menginstal instance delegasi secara eksplisit seperti yang biasa dengan jenis delegasi lainnya.

Catatan: Fitur ini tersedia mulai versi 2.7.

Python

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

Metrik

Performa

Saat menggunakan kombinasi operasi TensorFlow bawaan dan tertentu, Pengoptimalan LiteRT dan operasi bawaan yang dioptimalkan akan tersedia dan dapat digunakan dengan model yang dikonversi.

Tabel berikut menjelaskan waktu rata-rata yang dibutuhkan untuk menjalankan inferensi pada MobileNet di Pixel 2. Waktu yang tercantum adalah rata-rata 100 sesi. Ini target 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 dibangun secara selektif untuk i3d-kinetics-400 model dengan 8 operasi bawaan TFLite dan 3 operasi Tensorflow. Untuk detail selengkapnya, lihat Bagian Kurangi ukuran biner LiteRT.

Batasan umum

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

Pembaruan

• Versi 2.6
  • Mendukung operator berbasis atribut GraphDef dan resource HashTable inisialisasi telah diperbaiki.
• Versi 2.5
  • Anda dapat menerapkan pengoptimalan yang dikenal sebagai pascapelatihan kuantisasi
• Versi 2.4
  • Kompatibilitas dengan delegasi yang diakselerasi hardware telah meningkat