Libreria attività TensorFlow Lite

La libreria di attività TensorFlow Lite contiene un insieme di strumenti potenti e facili da usare librerie specifiche per le attività per permettere agli sviluppatori di app di creare esperienze ML con TFLite. Fornisce interfacce dei modelli pronte all'uso ottimizzate per il machine learning più diffuso come classificazione delle immagini, domanda e risposta ecc. Il modello sono progettate appositamente per ogni attività, in modo da prestazioni e usabilità. La libreria attività funziona su più piattaforme ed è supportata Java, C++ e Swift.

Che cosa aspettarsi dalla libreria attività

  • API pulite e ben definite, utilizzabili anche da esperti non esperti
    L'inferenza può essere fatta con sole 5 righe di codice. Utilizza le potenti funzionalità le API di facile utilizzo nella libreria delle attività come componenti di base per aiutarti sviluppare ML con TFLite sui dispositivi mobili.

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

  • Aumento delle prestazioni elevato
    L'elaborazione dei dati non richiederebbe più di pochi millisecondi, garantendo che di inferenza rapida con TensorFlow Lite.

  • Ampliabilità e personalizzazione
    Puoi sfruttare tutti i vantaggi offerti dall'infrastruttura della libreria di attività, 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 crescerà man mano che continuiamo ad attivare un numero sempre maggiore di casi d'uso.

Esegui la libreria di attività con i delegati

I delegati abilitano l'accelerazione hardware delle Modelli TensorFlow Lite sfruttando acceleratori on-device come GPU e Coral Edge TPU. Utilizzo per le operazioni di rete neurale offre enormi vantaggi in termini di latenza ed efficienza energetica. Ad esempio, le GPU possono fornire fino a velocizza di latenza sui dispositivi mobili e l'inferenza delle TPU Corallo Edge 10 volte più veloce rispetto alle CPU desktop.

La libreria attività fornisce opzioni di configurazione e di riserva facili da impostare e utilizzare delegati. Nell'API Tasks sono ora supportati i seguenti acceleratori:

Il supporto dell'accelerazione in Tasks Swift / API web sarà disponibile a breve.

Esempio di utilizzo della GPU su Android in Java

Passaggio 1. Aggiungi la libreria dei plug-in delegati GPU all'oggetto build.gradle del modulo 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'
}

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 della GPU nel target della build del bazel, ad esempio:

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

Passaggio 2: Configura il delegato GPU nelle opzioni dell'attività. Ad esempio, puoi configurare 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);

Esplorare 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 configura Coral Edge TPU in ImageClassifier in questo modo:

# 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 delega di Coral Edge TPU nel target della build del bazel quali:

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 per configurare Coral Edge TPU in ImageClassifier nel seguente modo:

// 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 descritto di seguito. Se è già installata, 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 la demo dell'interfaccia a riga di comando della libreria attività strumento con i dispositivi Coral Edge TPU. Scopri di più sulla edge TPU preaddestrato modelli avanzati e edge TPU avanzato impostazioni.

Esempio di utilizzo di Core ML Delega in C++

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

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

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

Passaggio 2: Configurare Core ML Delegato nelle opzioni dell'attività. Ad esempio, puoi impostare Core ML Delegato in ImageClassifier nel seguente modo:

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