Libreria attività TensorFlow Lite

La libreria di attività TensorFlow Lite contiene una serie di librerie specifiche per attività potenti e facili da usare che consentono agli sviluppatori di app di creare esperienze ML con TFLite. Fornisce interfacce modello predefinite ottimizzate per attività comuni di apprendimento automatico, come classificazione di immagini, domande e risposte, ecc. Le interfacce modello sono progettate specificamente per ciascuna attività per ottenere le migliori prestazioni e usabilità. La libreria attività funziona su più piattaforme ed è supportata su Java, C++ e Swift.

Cosa aspettarsi dalla Libreria attività

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

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

  • Guadagno ad alte 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.

Attività supportate

Di seguito è riportato l'elenco dei tipi di attività supportati. Si prevede che l'elenco aumenterà man mano che continuiamo ad abilitare sempre più casi d'uso.

Esegui la libreria attività con i delegati

I delegati abilitano l'accelerazione hardware dei modelli TensorFlow Lite sfruttando acceleratori sul dispositivo come GPU e Coral Edge TPU . Utilizzarli 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 inferiscono 10 volte più velocemente delle CPU desktop.

La libreria attività fornisce semplici opzioni di configurazione e fallback per impostare e utilizzare i delegati. I seguenti acceleratori sono ora supportati nell'API Task:

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

Esempio di utilizzo della GPU su Android in Java

Passaggio 1. Aggiungi la libreria dei plugin delegati 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. Configura il delegato GPU nelle opzioni dell'attività tramite BaseOptions . Ad esempio, puoi configurare la GPU in ObjectDetector 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 nel target 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);

Scopri le impostazioni più avanzate dell'acceleratore qui .

Esempio di utilizzo di Coral Edge TPU in Python

Configura Coral Edge TPU nelle opzioni di base dell'attività. Ad esempio, puoi impostare 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 Coral Edge TPU nel target di creazione 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 impostare 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 CLI Library delle attività con i tuoi dispositivi Coral Edge TPU. 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 è disponibile in Image Classifier Core ML Delegate Test .

Passaggio 1. Dipende dal plug-in delegato Core ML nel target di build bazel, ad esempio:

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

Passaggio 2. Configurare il delegato Core ML nelle opzioni dell'attività. Ad esempio, puoi configurare Core ML Delegate 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();