Grazie per esserti sintonizzato su Google I/O. Visualizza tutte le sessioni su richiesta Guarda su richiesta

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 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 ciascuna 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 non esperti di 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 su 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.

  • Guadagno ad alte prestazioni
    L'elaborazione dei dati non richiederebbe più di pochi millisecondi, garantendo la rapida esperienza di inferenza utilizzando TensorFlow Lite.

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

Attività supportate

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

Esegui libreria attività con delegati

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

Libreria attività offre una configurazione semplice e opzioni di fallback per configurare e utilizzare i delegati. I seguenti acceleratori sono ora supportati nell'API delle attività:

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

Esempio di utilizzo della GPU su Android in Java

Passo 1. Aggiungi la libreria di plug-in delegata 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 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 delegato includono:

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

Passaggio 2. Configurare il delegato GPU nelle opzioni dell'attività. Ad esempio, puoi configurare 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 Coral Edge TPU nel target di build bazel, ad esempio:

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

Passaggio 2. Configurare 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();

Passo 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. Compilare 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 Coral Edge TPU. Scopri di più sui modelli pre-addestrati di Edge TPU e sulle impostazioni avanzate di Edge TPU .

Esempio di utilizzo di Core ML Delegate in C++

Un esempio completo è disponibile in Image Classifier Core ML Delegate Test .

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

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

Passaggio 2. Configura Core ML Delegate 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();