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.
API Vision
API de langage naturel (NL)
API audio
API personnalisées
- Étendez l'infrastructure de l'API de tâches et créez une API personnalisée .
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 :
- Android
- Linux/Mac
- Bord de corail TPU : C++
- IOS
- Délégué Core ML : C++
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();