Library Tugas TensorFlow Lite

Library Tugas TensorFlow Lite berisi serangkaian kumpulan tugas yang andal dan mudah digunakan library khusus tugas bagi developer aplikasi untuk membuat pengalaman ML dengan TFLite. Menyediakan antarmuka model siap pakai yang dioptimalkan untuk machine learning populer seperti klasifikasi gambar, tanya jawab, dll. antarmuka dirancang khusus untuk setiap tugas guna mencapai performa dan kegunaan. {i>Task Library<i} bekerja lintas platform dan didukung di Java, C++, dan Swift.

Yang diharapkan dari Library Tugas

  • API rapi dan jelas yang dapat digunakan oleh pakar non-ML
    Inferensi dapat dilakukan hanya dalam 5 baris kode. Gunakan alat dan API yang mudah digunakan di library Task sebagai elemen penyusun untuk membantu Anda mengembangkan ML dengan TFLite di perangkat seluler.

  • Pemrosesan data yang rumit tetapi umum
    Mendukung logika natural language processing dan visi umum untuk mengonversi antara data Anda dan format data yang dibutuhkan oleh model. Menyediakan logika pemrosesan yang sama dan dapat dibagikan untuk pelatihan dan inferensi.

  • Peningkatan performa tinggi
    Pemrosesan data membutuhkan waktu tidak lebih dari beberapa milidetik, yang memastikan inferensi yang cepat menggunakan TensorFlow Lite.

  • Perluasan dan penyesuaian
    Anda dapat memanfaatkan semua manfaat yang diberikan oleh infrastruktur {i>Task Library<i} dan membangun API inferensi Android/iOS sendiri dengan mudah.

Tugas yang didukung

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

Menjalankan Library Tugas dengan Delegasi

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

Library Tugas menyediakan konfigurasi yang mudah dan opsi fallback untuk Anda siapkan dan menggunakan delegasi. Akselerator berikut kini didukung di Task API:

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

Contoh penggunaan GPU di Android dalam Java

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

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

Langkah 2. Konfigurasikan delegasi GPU dalam opsi tugas melalui BaseOptions. Misalnya, Anda dapat menyiapkan GPU di ObjectDetector seperti 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 di Android dalam C++

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

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

Langkah 2. Konfigurasikan delegasi GPU dalam opsi tugas. Misalnya, Anda dapat menyiapkan 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);

Mempelajari setelan akselerator lanjutan lainnya di sini.

Contoh penggunaan Coral Edge TPU di Python

Konfigurasi Coral Edge TPU di opsi dasar tugas. Sebagai contoh, Anda dapat siapkan Coral Edge TPU 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 Coral Edge TPU di C++

Langkah 1. Bergantung pada plugin delegasi Coral Edge TPU 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 Coral Edge TPU 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 diinstal, 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.

Coba demo CLI Library Tugas alat dengan perangkat TPU Coral Edge. Jelajahi lebih lanjut di Edge TPU terlatih model dan Edge TPU lanjutan setelan.

Contoh penggunaan Delegasi Core ML di C++

Contoh lengkapnya dapat ditemukan di Image Classifier Core ML Delegate Menguji.

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

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

Langkah 2. Konfigurasikan Delegasi Core ML di opsi tugas. Misalnya, Anda dapat mengatur Delegasi Core ML 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();