Pustaka Tugas TensorFlow Lite

Pustaka Tugas TensorFlow Lite berisi kumpulan pustaka khusus tugas yang andal dan mudah digunakan bagi pengembang aplikasi untuk menciptakan pengalaman ML dengan TFLite. Ini menyediakan antarmuka model out-of-box yang dioptimalkan untuk tugas pembelajaran mesin populer, seperti klasifikasi gambar, pertanyaan dan jawaban, dll. Antarmuka model dirancang khusus untuk setiap tugas untuk mencapai kinerja dan kegunaan terbaik. Pustaka Tugas bekerja lintas platform dan didukung di Java, C++, dan Swift.

Apa yang diharapkan dari Perpustakaan Tugas

• API yang bersih dan terdefinisi dengan baik yang dapat digunakan oleh non-ahli ML
  Inferensi dapat dilakukan hanya dalam 5 baris kode. Gunakan API yang andal dan mudah digunakan di pustaka Tugas sebagai blok penyusun untuk membantu Anda mengembangkan ML dengan TFLite dengan mudah di perangkat seluler.

• Pemrosesan data yang kompleks tetapi umum
  Mendukung visi umum dan logika pemrosesan bahasa alami untuk mengonversi antara data Anda dan format data yang diperlukan oleh model. Menyediakan logika pemrosesan yang sama dan dapat dibagikan untuk pelatihan dan inferensi.

• Keuntungan kinerja tinggi
  Pemrosesan data tidak lebih dari beberapa milidetik, memastikan pengalaman inferensi cepat menggunakan TensorFlow Lite.

• Ekstensibilitas dan kustomisasi
  Anda dapat memanfaatkan semua manfaat yang disediakan infrastruktur Perpustakaan Tugas dan dengan mudah membangun API inferensi Android/iOS Anda sendiri.

Tugas yang didukung

Di bawah ini adalah daftar jenis tugas yang didukung. Daftar ini diperkirakan akan bertambah seiring kami terus mengaktifkan lebih banyak kasus penggunaan.

• API Visi

  • Pengklasifikasi Gambar
  • Detektor Objek
  • Segmen Gambar
  • Pencari Gambar
  • GambarEmbedder

• API Bahasa Alami (NL)

  • NLClassifier
  • BertNLClassifier
  • BertPertanyaanPenjawab
  • Pencari Teks
  • TeksEmbedder

• API Audio

  • Pengklasifikasi Audio

• API Khusus

  • Perluas infrastruktur Task API dan bangun API yang disesuaikan .

Jalankan Perpustakaan Tugas dengan Delegasi

Delegasi mengaktifkan akselerasi perangkat keras model TensorFlow Lite dengan memanfaatkan akselerator di perangkat seperti GPU dan TPU Coral Edge . Memanfaatkannya untuk operasi jaringan saraf memberikan manfaat besar dalam hal latensi dan efisiensi daya. Misalnya, GPU dapat memberikan kecepatan hingga 5x dalam latensi pada perangkat seluler, dan inferensi TPU Coral Edge 10x lebih cepat daripada CPU desktop.

Pustaka Tugas menyediakan konfigurasi yang mudah dan opsi mundur bagi Anda untuk mengatur dan menggunakan delegasi. Akselerator berikut sekarang didukung di Task API:

• Android
  • GPU : Java / C++
  • NNAPI : Java / C++
  • Segi enam : C++
• Linux / Mac
  • TPU Tepi Karang : C++
• iOS
  • Delegasi ML inti : C++

Dukungan akselerasi di Task Swift / Web API akan segera hadir.

Contoh penggunaan GPU pada Android di Java

Langkah 1. Tambahkan pustaka plugin delegasi GPU ke file build.gradle modul Anda:

dependencies {
    // Import Task Library dependency for vision, text, or audio.

    // Import the GPU delegate plugin Library for GPU inference
    implementation 'org.tensorflow:tensorflow-lite-gpu-delegate-plugin'
}

Catatan: NNAPI dilengkapi dengan target Perpustakaan Tugas untuk penglihatan, teks, dan audio secara default.

Langkah 2. Konfigurasikan delegasi GPU dalam opsi tugas melalui BaseOptions . Misalnya, Anda dapat mengatur GPU di ObjectDetecor sebagai berikut:

// Turn on GPU delegation.
BaseOptions baseOptions = BaseOptions.builder().useGpu().build();
// Configure other options in ObjectDetector
ObjectDetectorOptions options =
    ObjectDetectorOptions.builder()
        .setBaseOptions(baseOptions)
        .setMaxResults(1)
        .build();

// Create ObjectDetector from options.
ObjectDetector objectDetector =
    ObjectDetector.createFromFileAndOptions(context, modelFile, options);

// Run inference
List<Detection> results = objectDetector.detect(image);

Contoh penggunaan GPU pada Android di C++

Langkah 1. Tergantung pada plugin delegasi GPU di target build bazel Anda, seperti:

deps = [
  "//tensorflow_lite_support/acceleration/configuration:gpu_plugin", # for GPU
]

Catatan: target gpu_plugin terpisah dari target delegasi GPU . gpu_plugin membungkus target delegasi GPU, dan dapat memberikan penjaga keamanan, yaitu mundur ke jalur CPU TFLite pada kesalahan delegasi.

Opsi delegasi lainnya termasuk:

"//tensorflow_lite_support/acceleration/configuration:nnapi_plugin", # for NNAPI
"//tensorflow_lite_support/acceleration/configuration:hexagon_plugin", # for Hexagon

Langkah 2. Konfigurasikan delegasi GPU di opsi tugas. Misalnya, Anda dapat mengatur GPU di BertQuestionAnswerer sebagai berikut:

// Initialization
BertQuestionAnswererOptions options;
// Load the TFLite model.
auto base_options = options.mutable_base_options();
base_options->mutable_model_file()->set_file_name(model_file);
// Turn on GPU delegation.
auto tflite_settings = base_options->mutable_compute_settings()->mutable_tflite_settings();
tflite_settings->set_delegate(Delegate::GPU);
// (optional) Turn on automatical fallback to TFLite CPU path on delegation errors.
tflite_settings->mutable_fallback_settings()->set_allow_automatic_fallback_on_execution_error(true);

// Create QuestionAnswerer from options.
std::unique_ptr<QuestionAnswerer> answerer = BertQuestionAnswerer::CreateFromOptions(options).value();

// Run inference on GPU.
std::vector<QaAnswer> results = answerer->Answer(context_of_question, question_to_ask);

Jelajahi pengaturan akselerator lebih lanjut di sini .

Contoh penggunaan TPU Coral Edge dengan Python

Konfigurasikan Coral Edge TPU di opsi dasar tugas. Misalnya, Anda dapat mengatur TPU Coral Edge di ImageClassifier sebagai berikut:

# Imports
from tflite_support.task import vision
from tflite_support.task import core

# Initialize options and turn on Coral Edge TPU delegation.
base_options = core.BaseOptions(file_name=model_path, use_coral=True)
options = vision.ImageClassifierOptions(base_options=base_options)

# Create ImageClassifier from options.
classifier = vision.ImageClassifier.create_from_options(options)

# Run inference on Coral Edge TPU.
image = vision.TensorImage.create_from_file(image_path)
classification_result = classifier.classify(image)

Contoh penggunaan TPU Coral Edge di C++

Langkah 1. Bergantung pada plugin delegasi TPU Coral Edge di target build bazel Anda, seperti:

deps = [
  "//tensorflow_lite_support/acceleration/configuration:edgetpu_coral_plugin", # for Coral Edge TPU
]

Langkah 2. Konfigurasikan Coral Edge TPU di opsi tugas. Misalnya, Anda dapat mengatur TPU Coral Edge di ImageClassifier sebagai berikut:

// Initialization
ImageClassifierOptions options;
// Load the TFLite model.
options.mutable_base_options()->mutable_model_file()->set_file_name(model_file);
// Turn on Coral Edge TPU delegation.
options.mutable_base_options()->mutable_compute_settings()->mutable_tflite_settings()->set_delegate(Delegate::EDGETPU_CORAL);
// Create ImageClassifier from options.
std::unique_ptr<ImageClassifier> image_classifier = ImageClassifier::CreateFromOptions(options).value();

// Run inference on Coral Edge TPU.
const ClassificationResult result = image_classifier->Classify(*frame_buffer).value();

Langkah 3. Instal paket libusb-1.0-0-dev seperti di bawah ini. Jika sudah terinstal, lewati ke langkah berikutnya.

# On the Linux
sudo apt-get install libusb-1.0-0-dev

# On the macOS
port install libusb
# or
brew install libusb

Langkah 4. Kompilasi dengan konfigurasi berikut di perintah bazel Anda:

# On the Linux
--define darwinn_portable=1 --linkopt=-lusb-1.0

# On the macOS, add '--linkopt=-lusb-1.0 --linkopt=-L/opt/local/lib/' if you are
# using MacPorts or '--linkopt=-lusb-1.0 --linkopt=-L/opt/homebrew/lib' if you
# are using Homebrew.
--define darwinn_portable=1 --linkopt=-L/opt/local/lib/ --linkopt=-lusb-1.0

# Windows is not supported yet.

Cobalah alat demo CLI Perpustakaan Tugas dengan perangkat TPU Coral Edge Anda. Jelajahi lebih lanjut tentang model TPU Edge yang telah dilatih sebelumnya dan pengaturan Edge TPU tingkat lanjut .

Contoh penggunaan Core ML Delegate di C++

Contoh lengkap dapat ditemukan di Image Classifier Core ML Delegate Test .

Langkah 1. Bergantung pada plugin delegasi Core ML di target build bazel Anda, seperti:

deps = [
  "//tensorflow_lite_support/acceleration/configuration:coreml_plugin", # for Core ML Delegate
]

Langkah 2. Konfigurasikan Core ML Delegate di opsi tugas. Misalnya, Anda dapat menyiapkan Core ML Delegate di ImageClassifier sebagai berikut:

// Initialization
ImageClassifierOptions options;
// Load the TFLite model.
options.mutable_base_options()->mutable_model_file()->set_file_name(model_file);
// Turn on Core ML delegation.
options.mutable_base_options()->mutable_compute_settings()->mutable_tflite_settings()->set_delegate(::tflite::proto::Delegate::CORE_ML);
// Set DEVICES_ALL to enable Core ML delegation on any device (in contrast to
// DEVICES_WITH_NEURAL_ENGINE which creates Core ML delegate only on devices
// with Apple Neural Engine).
options.mutable_base_options()->mutable_compute_settings()->mutable_tflite_settings()->mutable_coreml_settings()->set_enabled_devices(::tflite::proto::CoreMLSettings::DEVICES_ALL);
// Create ImageClassifier from options.
std::unique_ptr<ImageClassifier> image_classifier = ImageClassifier::CreateFromOptions(options).value();

// Run inference on Core ML.
const ClassificationResult result = image_classifier->Classify(*frame_buffer).value();