Bibliothèque de tâches TensorFlow Lite

La bibliothèque de tâches TensorFlow Lite contient un ensemble de bibliothèques spécifiques à des 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 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 éléments de base pour vous aider à développer facilement du ML avec TFLite sur les appareils mobiles.

  • Traitement de données complexe mais courant
    Prend en charge la vision commune et la logique de traitement du langage naturel pour convertir 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 performances élevé
    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 offerts par 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 activent 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 Coral Edge TPU . 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 une latence jusqu'à 5 fois plus rapide sur les appareils mobiles, et les TPU Coral Edge inférence 10 fois plus rapide que les processeurs de bureau.

La bibliothèque de tâches offre une configuration simple 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 pris en charge dans l'API Task :

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

Exemple d'utilisation du GPU sur Android en Java

Étape 1. Ajoutez la bibliothèque de plugins de 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 plugin délégué GPU dans votre cible de build Bazel, tel que :

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

Découvrez les 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, tel que :

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 Task Library avec vos appareils Coral Edge TPU. Découvrez-en davantage 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 plugin délégué Core ML dans votre cible de build Bazel, tel que :

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