A biblioteca de tarefas do TensorFlow Lite contém um conjunto de bibliotecas específicas de tarefas poderosas e fáceis de usar para desenvolvedores de aplicativos criarem experiências de ML com TFLite. Ele fornece interfaces de modelo prontas para uso otimizadas para tarefas populares de aprendizado de máquina, como classificação de imagens, perguntas e respostas, etc. As interfaces de modelo são projetadas especificamente para cada tarefa para obter o melhor desempenho e usabilidade. A Biblioteca de Tarefas funciona em várias plataformas e é compatível com Java, C++ e Swift.
O que esperar da Biblioteca de Tarefas
APIs limpas e bem definidas que podem ser usadas por não especialistas em ML
A inferência pode ser feita em apenas 5 linhas de código. Use as APIs poderosas e fáceis de usar da biblioteca de tarefas como blocos de construção para ajudá-lo a desenvolver facilmente ML com TFLite em dispositivos móveis.Processamento de dados complexo, mas comum
Suporta visão comum e lógica de processamento de linguagem natural para converter entre seus dados e o formato de dados exigido pelo modelo. Fornece a mesma lógica de processamento compartilhável para treinamento e inferência.Ganho de alto desempenho
O processamento de dados não levaria mais do que alguns milissegundos, garantindo uma experiência de inferência rápida usando o TensorFlow Lite.Extensibilidade e personalização
Você pode aproveitar todos os benefícios que a infraestrutura da biblioteca de tarefas oferece e criar facilmente suas próprias APIs de inferência para Android/iOS.
Tarefas suportadas
Abaixo está a lista dos tipos de tarefas suportadas. Espera-se que a lista cresça à medida que continuamos possibilitando cada vez mais casos de uso.
APIs de visão
APIs de linguagem natural (NL)
APIs de áudio
APIs personalizadas
- Amplie a infraestrutura da Task API e crie uma API personalizada .
Execute a biblioteca de tarefas com delegados
Os delegados permitem a aceleração de hardware dos modelos do TensorFlow Lite aproveitando aceleradores no dispositivo, como GPU e Coral Edge TPU . Utilizá-los para operações de rede neural oferece enormes benefícios em termos de latência e eficiência de energia. Por exemplo, as GPUs podem fornecer uma aceleração de até 5x na latência em dispositivos móveis, e as TPUs Coral Edge inferem 10x mais rápido do que as CPUs de desktop.
A Biblioteca de Tarefas fornece configuração fácil e opções alternativas para você configurar e usar delegados. Os seguintes aceleradores agora são suportados na Task API:
- Android
- Linux/Mac
- Coral Borda TPU : C++
- iOS
- Delegado principal de ML : C++
O suporte de aceleração no Task Swift/Web API estará disponível em breve.
Exemplo de uso de GPU no Android em Java
Etapa 1. Adicione a biblioteca de plug-ins delegados da GPU ao arquivo build.gradle
do seu módulo:
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'
}
Etapa 2. Configure o delegado GPU nas opções de tarefa por meio de BaseOptions . Por exemplo, você pode configurar a GPU no ObjectDetector
da seguinte maneira:
// 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);
Exemplo de uso de GPU no Android em C++
Etapa 1. Depende do plug-in delegado de GPU em seu destino de compilação do Bazel, como:
deps = [
"//tensorflow_lite_support/acceleration/configuration:gpu_plugin", # for GPU
]
Outras opções de delegado incluem:
"//tensorflow_lite_support/acceleration/configuration:nnapi_plugin", # for NNAPI
"//tensorflow_lite_support/acceleration/configuration:hexagon_plugin", # for Hexagon
Passo 2. Configure o delegado GPU nas opções de tarefa. Por exemplo, você pode configurar a GPU no BertQuestionAnswerer
da seguinte maneira:
// 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);
Explore configurações mais avançadas do acelerador aqui .
Exemplo de uso de Coral Edge TPU em Python
Configure Coral Edge TPU nas opções básicas da tarefa. Por exemplo, você pode configurar o Coral Edge TPU no ImageClassifier
da seguinte maneira:
# 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)
Exemplo de uso de Coral Edge TPU em C++
Etapa 1. Depende do plug-in delegado Coral Edge TPU em seu destino de construção do Bazel, como:
deps = [
"//tensorflow_lite_support/acceleration/configuration:edgetpu_coral_plugin", # for Coral Edge TPU
]
Passo 2. Configure Coral Edge TPU nas opções de tarefa. Por exemplo, você pode configurar o Coral Edge TPU no ImageClassifier
da seguinte maneira:
// 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();
Etapa 3. Instale o pacote libusb-1.0-0-dev
conforme abaixo. Se já estiver instalado, pule para a próxima etapa.
# On the Linux
sudo apt-get install libusb-1.0-0-dev
# On the macOS
port install libusb
# or
brew install libusb
Etapa 4. Compile com as seguintes configurações em seu 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.
Experimente a ferramenta de demonstração Task Library CLI com seus dispositivos Coral Edge TPU. Explore mais sobre os modelos pré-treinados do Edge TPU e as configurações avançadas do Edge TPU .
Exemplo de uso do Core ML Delegate em C++
Um exemplo completo pode ser encontrado em Image Classifier Core ML Delegate Test .
Etapa 1. Depende do plug-in delegado Core ML em seu destino de compilação do Bazel, como:
deps = [
"//tensorflow_lite_support/acceleration/configuration:coreml_plugin", # for Core ML Delegate
]
Etapa 2. Configure o Core ML Delegate nas opções de tarefa. Por exemplo, você pode configurar o Core ML Delegate no ImageClassifier
da seguinte maneira:
// 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();