Libreria attività TensorFlow Lite

TensorFlow Lite Task Library contiene una serie di librerie specifiche per attività potenti e facili da usare per gli sviluppatori di app per creare esperienze ML con TFLite. Fornisce interfacce del modello predefinite ottimizzate per le attività di apprendimento automatico più diffuse, come la classificazione delle immagini, domande e risposte, ecc. Le interfacce del modello sono progettate specificamente per ogni attività per ottenere le migliori prestazioni e usabilità. Task Library funziona su più piattaforme ed è supportata su Java, C++ e Swift.

Cosa aspettarsi dalla Libreria attività

  • API pulite e ben definite utilizzabili da esperti non ML
    L'inferenza può essere eseguita in sole 5 righe di codice. Usa le API potenti e facili da usare nella libreria delle attività come elementi costitutivi per aiutarti a sviluppare facilmente ML con TFLite sui dispositivi mobili.

  • Elaborazione dati complessa ma comune
    Supporta la visione comune e la logica di elaborazione del linguaggio naturale per la conversione tra i tuoi dati e il formato dei dati richiesto dal modello. Fornisce la stessa logica di elaborazione condivisibile per l'addestramento e l'inferenza.

  • Elevato guadagno di prestazioni
    L'elaborazione dei dati non richiederebbe più di pochi millisecondi, garantendo un'esperienza di inferenza rapida utilizzando TensorFlow Lite.

  • Estendibilità e personalizzazione
    Puoi sfruttare tutti i vantaggi offerti dall'infrastruttura della Libreria attività e creare facilmente le tue API di inferenza Android/iOS.

Compiti supportati

Di seguito è riportato l'elenco dei tipi di attività supportati. L'elenco dovrebbe crescere man mano che continuiamo a consentire sempre più casi d'uso.

Esegui Libreria attività con i delegati

I delegati consentono l'accelerazione hardware dei modelli TensorFlow Lite sfruttando gli acceleratori sul dispositivo come la GPU e il TPU Coral Edge . Il loro utilizzo per le operazioni di rete neurale offre enormi vantaggi in termini di latenza ed efficienza energetica. Ad esempio, le GPU possono fornire una velocità di latenza fino a 5 volte superiore sui dispositivi mobili e le TPU Coral Edge inferenza 10 volte più veloci rispetto alle CPU desktop.

Libreria attività offre una configurazione semplice e opzioni di fallback per la configurazione e l'utilizzo dei delegati. I seguenti acceleratori sono ora supportati nell'API delle attività:

Il supporto per l'accelerazione in Task Swift/API Web sarà presto disponibile.

Esempio di utilizzo della GPU su Android in Java

Passaggio 1. Aggiungi la libreria del plug-in delegato GPU al file build.gradle del tuo modulo:

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

Passaggio 2. Configurare il delegato GPU nelle opzioni dell'attività tramite BaseOptions . Ad esempio, puoi configurare la GPU in ObjectDetecor come segue:

// 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);

Esempio di utilizzo della GPU su Android in C++

Passaggio 1. Dipende dal plug-in delegato GPU nella destinazione di build bazel, ad esempio:

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

Altre opzioni di delega includono:

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

Passaggio 2. Configura il delegato GPU nelle opzioni dell'attività. Ad esempio, puoi impostare la GPU in BertQuestionAnswerer come segue:

// 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);

Esplora le impostazioni dell'acceleratore più avanzate qui .

Esempio di utilizzo di Coral Edge TPU in Python

Configura Coral Edge TPU nelle opzioni di base dell'attività. Ad esempio, puoi configurare Coral Edge TPU in ImageClassifier come segue:

# 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)

Esempio di utilizzo di Coral Edge TPU in C++

Passaggio 1. Dipende dal plug-in delegato TPU Coral Edge nella destinazione di build bazel, ad esempio:

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

Passaggio 2. Configura Coral Edge TPU nelle opzioni dell'attività. Ad esempio, puoi configurare Coral Edge TPU in ImageClassifier come segue:

// 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();

Passaggio 3. Installa il pacchetto libusb-1.0-0-dev come di seguito. Se è già installato, vai al passaggio successivo.

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

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

Passaggio 4. Compila con le seguenti configurazioni nel comando bazel:

# 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.

Prova lo strumento demo della Task Library CLI con i tuoi dispositivi TPU Coral Edge. Scopri di più sui modelli Edge TPU preaddestrati e sulle impostazioni avanzate di Edge TPU .

Esempio di utilizzo del delegato Core ML in C++

Un esempio completo può essere trovato in Image Classifier Core ML Delegate Test .

Passaggio 1. Dipende dal plug-in delegato Core ML nella tua destinazione di build bazel, ad esempio:

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

Passaggio 2. Configura il delegato Core ML nelle opzioni dell'attività. Ad esempio, puoi configurare Core ML Delegato in ImageClassifier come segue:

// 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();