Bibliothèque de tâches TensorFlow Lite

La bibliothèque de tâches TensorFlow Lite contient un ensemble de bibliothèques spécifiques aux tâches puissantes et faciles à utiliser permettant aux développeurs d'applications de créer des expériences de ML avec TFLite. Il fournit des interfaces de modèle prêtes à l'emploi optimisées pour les tâches d'apprentissage automatique courantes, telles que la classification d'images, les questions et réponses, etc. Les interfaces de modèle sont spécifiquement conçues pour chaque tâche afin d'obtenir les meilleures performances et la meilleure convivialité. La bibliothèque de tâches fonctionne sur plusieurs plates-formes et est prise en charge sur Java, C++ et Swift.

À quoi s'attendre de la bibliothèque de tâches

  • API propres et bien définies utilisables par des non-experts en ML
    L'inférence peut être effectuée en seulement 5 lignes de code. Utilisez les API puissantes et faciles à utiliser de la bibliothèque de tâches comme blocs de construction pour vous aider à développer facilement ML avec TFLite sur les appareils mobiles.

  • Traitement de données complexe mais commun
    Prend en charge la vision commune et la logique de traitement du langage naturel pour effectuer la conversion entre vos données et le format de données requis par le modèle. Fournit la même logique de traitement partageable pour la formation et l'inférence.

  • Gain de haute performance
    Le traitement des données ne prendrait pas plus de quelques millisecondes, garantissant une expérience d'inférence rapide avec TensorFlow Lite.

  • Extensibilité et personnalisation
    Vous pouvez tirer parti de tous les avantages de l'infrastructure de la bibliothèque de tâches et créer facilement vos propres API d'inférence Android/iOS.

Tâches prises en charge

Vous trouverez ci-dessous la liste des types de tâches pris en charge. La liste devrait s'allonger à mesure que nous continuons à permettre de plus en plus de cas d'utilisation.

Exécuter la bibliothèque de tâches avec des délégués

Les délégués permettent l'accélération matérielle des modèles TensorFlow Lite en tirant parti des accélérateurs intégrés à l'appareil tels que le GPU et le TPU Coral Edge . Leur utilisation pour les opérations de réseau neuronal offre d'énormes avantages en termes de latence et d'efficacité énergétique. Par exemple, les GPU peuvent fournir jusqu'à 5 fois plus de temps de latence sur les appareils mobiles, et l'inférence des TPU Coral Edge est 10 fois plus rapide que les processeurs de bureau.

La bibliothèque de tâches fournit une configuration facile et des options de secours pour vous permettre de configurer et d'utiliser des délégués. Les accélérateurs suivants sont désormais compatibles avec l'API Task :

La prise en charge de l'accélération dans Task Swift / API Web sera bientôt disponible.

Exemple d'utilisation du GPU sur Android en Java

Étape 1. Ajoutez la bibliothèque du plug-in délégué GPU au fichier build.gradle de votre module :

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

Étape 2. Configurez le délégué GPU dans les options de tâche via BaseOptions . Par exemple, vous pouvez configurer le GPU dans ObjectDetector comme suit :

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

Exemple d'utilisation du GPU sur Android en C++

Étape 1. Dépendez du plug-in délégué GPU dans votre cible de génération bazel, par exemple :

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

Les autres options de délégué incluent :

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

Étape 2. Configurez le délégué GPU dans les options de tâche. Par exemple, vous pouvez configurer le GPU dans BertQuestionAnswerer comme suit :

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

Explorez des paramètres d'accélérateur plus avancés ici .

Exemple d'utilisation de Coral Edge TPU en Python

Configurez Coral Edge TPU dans les options de base de la tâche. Par exemple, vous pouvez configurer Coral Edge TPU dans ImageClassifier comme suit :

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

Exemple d'utilisation de Coral Edge TPU en C++

Étape 1. Dépendez du plug-in délégué Coral Edge TPU dans votre cible de construction bazel, par exemple :

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

Étape 2. Configurez Coral Edge TPU dans les options de tâche. Par exemple, vous pouvez configurer Coral Edge TPU dans ImageClassifier comme suit :

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

Étape 3. Installez le package libusb-1.0-0-dev comme ci-dessous. S'il est déjà installé, passez à l'étape suivante.

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

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

Étape 4. Compilez avec les configurations suivantes dans votre commande 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.

Essayez l' outil de démonstration CLI de la bibliothèque de tâches avec vos appareils Coral Edge TPU. En savoir plus sur les modèles Edge TPU pré-entraînés et les paramètres Edge TPU avancés .

Exemple d'utilisation de Core ML Delegate en C++

Un exemple complet peut être trouvé sur Image Classifier Core ML Delegate Test .

Étape 1. Dépendez du plug-in délégué Core ML dans votre cible de génération bazel, par exemple :

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

Étape 2. Configurez Core ML Delegate dans les options de tâche. Par exemple, vous pouvez configurer Core ML Delegate dans ImageClassifier comme suit :

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