Bibliothèque de tâches TensorFlow Lite

La bibliothèque de tâches TensorFlow Lite contient un ensemble d'outils puissants et Bibliothèques spécifiques aux tâches permettant aux développeurs d'applications de créer des expériences de ML avec TFLite. Il fournit des interfaces de modèles prêtes à l'emploi optimisées pour les modèles courants de machine learning (classification d'images, question-réponse, etc.). Le modèle sont conçues pour chaque tâche afin d'obtenir les meilleurs résultats les performances et la facilité d'utilisation. La bibliothèque de tâches fonctionne sur plusieurs plateformes 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 à l'aide de seulement cinq lignes de code. Utilisez le puissant des API faciles à utiliser de la bibliothèque Task, qui servent de composants de base pour vous aider développer le ML avec TFLite sur des appareils mobiles.

  • Traitement des données complexe, mais courant
    Accepte les logiques courantes de vision et 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 l'entraînement et l'inférence.

  • Gain de performances élevé
    Le traitement des données ne prendrait que quelques millisecondes, d'inférence rapide avec TensorFlow Lite.

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

Tâches disponibles

Vous trouverez ci-dessous la liste des types de tâches compatibles. La liste devrait s'allonger au fur et à mesure nous continuons à proposer 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 de TensorFlow Lite via des accélérateurs sur l'appareil tels que GPU et Coral Edge TPU. Utilisation pour les opérations des réseaux de neurones, offre d'énormes avantages en termes de latence et de l'efficacité énergétique. Par exemple, les GPU peuvent fournir jusqu'à 5 fois accélérer de latence sur les appareils mobiles et l'inférence des TPU Coral Edge 10 fois plus importante plus rapides que les processeurs de bureau.

La bibliothèque de tâches offre une configuration facile et des options de remplacement que vous pouvez configurer et faire appel à des délégués. Les accélérateurs suivants sont désormais pris en charge dans l'API Task:

  • Android <ph type="x-smartling-placeholder">
      </ph>
    • GPU: Java / C++
  • Linux / Mac <ph type="x-smartling-placeholder">
  • iOS <ph type="x-smartling-placeholder">

L'accélération sera bientôt disponible dans l'API Task Swift / Web.

Exemple d'utilisation d'un GPU sur Android en Java

Étape 1 : Ajoutez la bibliothèque de plug-ins délégués au 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 : Configurer le délégué de 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 d'un GPU sur Android en C++

Étape 1 : Dépendez du plug-in délégué de GPU dans votre cible de compilation Bazel, par exemple:

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

Étape 2 : Configurez le délégué de GPU dans les options de la tâche. Par exemple, vous pouvez configurer 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 des paramètres d'accélérateur plus avancés cliquez 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 configurez 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 : Votre cible de compilation Bazel dépend du plug-in délégué TPU Coral Edge. 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 définir d'installer 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 indiqué ci-dessous. Si c'est déjà le cas vous pouvez passer à 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 : Procédez à la compilation 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 la démonstration de la CLI de la bibliothèque de tâches outil avec vos appareils Coral Edge TPU. Apprenez-en plus sur la version pré-entraînée de Edge TPU modèles et Edge TPU avancé paramètres.

Exemple d'utilisation du délégué Core ML en C++

Vous trouverez un exemple complet dans Délégué ML principal pour le classificateur d'images. Test.

Étape 1 : Dépendez du plug-in délégué Core ML dans votre cible de compilation Bazel, par exemple en tant que:

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

Étape 2 : Configurez le délégué Core ML dans les options de la tâche. Par exemple, vous pouvez définir et configurez le délégué Core ML 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();