O que é um delegado do TensorFlow Lite?
Um delegado do TensorFlow Lite permite que você execute seus modelos (parte ou todo) em outro executor. Esse mecanismo pode aproveitar uma variedade de aceleradores no dispositivo, como GPU ou Edge TPU (Unidade de processamento de tensor) para inferência. Isso fornece aos desenvolvedores um método flexível e desacoplado do TFLite padrão para acelerar a inferência.
O diagrama abaixo resume os delegados, mais detalhes nas seções abaixo.
Quando devo criar um delegado personalizado?
O TensorFlow Lite tem uma grande variedade de delegados para aceleradores de destino, como GPU, DSP, EdgeTPU e estruturas como NNAPI do Android.
Criar seu próprio delegado é útil nos seguintes cenários:
- Você deseja integrar um novo mecanismo de inferência de ML não suportado por nenhum representante existente.
- Você tem um acelerador de hardware personalizado que melhora o tempo de execução para cenários conhecidos.
- Você está desenvolvendo otimizações de CPU (como fusão de operador) que podem acelerar determinados modelos.
Como funcionam os delegados?
Considere um gráfico de modelo simples como o seguinte e um delegado “MyDelegate” que tenha uma implementação mais rápida para operações Conv2D e Mean.
Após aplicar este “MyDelegate”, o gráfico original do TensorFlow Lite será atualizado da seguinte forma:
O gráfico acima é obtido quando o TensorFlow Lite divide o gráfico original seguindo duas regras:
- Operações específicas que podem ser tratadas pelo delegado são colocadas em uma partição enquanto ainda satisfazem as dependências do fluxo de trabalho de computação original entre as operações.
- Cada partição a ser delegada tem apenas nós de entrada e saída que não são tratados pelo delegado.
Cada partição que é tratada por um delegado é substituída por um nó delegado (também pode ser chamado como um kernel delegado) no gráfico original que avalia a partição em sua chamada de invocação.
Dependendo do modelo, o gráfico final pode terminar com um ou mais nós, o que significa que algumas operações não são suportadas pelo delegado. Em geral, você não quer ter várias partições tratadas pelo delegado, porque cada vez que você alterna do delegado para o gráfico principal, há uma sobrecarga para passar os resultados do subgrafo delegado para o gráfico principal que resulta devido à memória cópias (por exemplo, GPU para CPU). Essa sobrecarga pode compensar os ganhos de desempenho, especialmente quando há uma grande quantidade de cópias de memória.
Implementando seu próprio delegado personalizado
O método preferencial para adicionar um delegado é usar a API SimpleDelegate .
Para criar um novo delegado, você precisa implementar 2 interfaces e fornecer sua própria implementação para os métodos de interface.
1 - SimpleDelegateInterface
Essa classe representa os recursos do delegado, quais operações são suportadas e uma classe de fábrica para criar um kernel que encapsula o gráfico delegado. Para obter mais detalhes, consulte a interface definida neste arquivo de cabeçalho C++ . Os comentários no código explicam cada API em detalhes.
2 - SimpleDelegateKernelInterface
Esta classe encapsula a lógica para inicializar/preparar/e executar a partição delegada.
Tem: (Ver definição )
- Init(...): que será chamado uma vez para fazer qualquer inicialização única.
- Prepare(...): chamado para cada instância diferente deste nó - isso acontece se você tiver várias partições delegadas. Normalmente você quer fazer alocações de memória aqui, já que isso será chamado toda vez que os tensores forem redimensionados.
- Invoke(...): que será chamado para inferência.
Exemplo
Neste exemplo, você criará um delegado muito simples que pode suportar apenas 2 tipos de operações (ADD) e (SUB) apenas com tensores float32.
// MyDelegate implements the interface of SimpleDelegateInterface.
// This holds the Delegate capabilities.
class MyDelegate : public SimpleDelegateInterface {
public:
bool IsNodeSupportedByDelegate(const TfLiteRegistration* registration,
const TfLiteNode* node,
TfLiteContext* context) const override {
// Only supports Add and Sub ops.
if (kTfLiteBuiltinAdd != registration->builtin_code &&
kTfLiteBuiltinSub != registration->builtin_code)
return false;
// This delegate only supports float32 types.
for (int i = 0; i < node->inputs->size; ++i) {
auto& tensor = context->tensors[node->inputs->data[i]];
if (tensor.type != kTfLiteFloat32) return false;
}
return true;
}
TfLiteStatus Initialize(TfLiteContext* context) override { return kTfLiteOk; }
const char* Name() const override {
static constexpr char kName[] = "MyDelegate";
return kName;
}
std::unique_ptr<SimpleDelegateKernelInterface> CreateDelegateKernelInterface()
override {
return std::make_unique<MyDelegateKernel>();
}
};
Em seguida, crie seu próprio kernel delegado herdando da SimpleDelegateKernelInterface
// My delegate kernel.
class MyDelegateKernel : public SimpleDelegateKernelInterface {
public:
TfLiteStatus Init(TfLiteContext* context,
const TfLiteDelegateParams* params) override {
// Save index to all nodes which are part of this delegate.
inputs_.resize(params->nodes_to_replace->size);
outputs_.resize(params->nodes_to_replace->size);
builtin_code_.resize(params->nodes_to_replace->size);
for (int i = 0; i < params->nodes_to_replace->size; ++i) {
const int node_index = params->nodes_to_replace->data[i];
// Get this node information.
TfLiteNode* delegated_node = nullptr;
TfLiteRegistration* delegated_node_registration = nullptr;
TF_LITE_ENSURE_EQ(
context,
context->GetNodeAndRegistration(context, node_index, &delegated_node,
&delegated_node_registration),
kTfLiteOk);
inputs_[i].push_back(delegated_node->inputs->data[0]);
inputs_[i].push_back(delegated_node->inputs->data[1]);
outputs_[i].push_back(delegated_node->outputs->data[0]);
builtin_code_[i] = delegated_node_registration->builtin_code;
}
return kTfLiteOk;
}
TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) override {
return kTfLiteOk;
}
TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) override {
// Evaluate the delegated graph.
// Here we loop over all the delegated nodes.
// We know that all the nodes are either ADD or SUB operations and the
// number of nodes equals ''inputs_.size()'' and inputs[i] is a list of
// tensor indices for inputs to node ''i'', while outputs_[i] is the list of
// outputs for node
// ''i''. Note, that it is intentional we have simple implementation as this
// is for demonstration.
for (int i = 0; i < inputs_.size(); ++i) {
// Get the node input tensors.
// Add/Sub operation accepts 2 inputs.
auto& input_tensor_1 = context->tensors[inputs_[i][0]];
auto& input_tensor_2 = context->tensors[inputs_[i][1]];
auto& output_tensor = context->tensors[outputs_[i][0]];
TF_LITE_ENSURE_EQ(
context,
ComputeResult(context, builtin_code_[i], &input_tensor_1,
&input_tensor_2, &output_tensor),
kTfLiteOk);
}
return kTfLiteOk;
}
private:
// Computes the result of addition of 'input_tensor_1' and 'input_tensor_2'
// and store the result in 'output_tensor'.
TfLiteStatus ComputeResult(TfLiteContext* context, int builtin_code,
const TfLiteTensor* input_tensor_1,
const TfLiteTensor* input_tensor_2,
TfLiteTensor* output_tensor) {
if (NumElements(input_tensor_1) != NumElements(input_tensor_2) ||
NumElements(input_tensor_1) != NumElements(output_tensor)) {
return kTfLiteDelegateError;
}
// This code assumes no activation, and no broadcasting needed (both inputs
// have the same size).
auto* input_1 = GetTensorData<float>(input_tensor_1);
auto* input_2 = GetTensorData<float>(input_tensor_2);
auto* output = GetTensorData<float>(output_tensor);
for (int i = 0; i < NumElements(input_tensor_1); ++i) {
if (builtin_code == kTfLiteBuiltinAdd)
output[i] = input_1[i] + input_2[i];
else
output[i] = input_1[i] - input_2[i];
}
return kTfLiteOk;
}
// Holds the indices of the input/output tensors.
// inputs_[i] is list of all input tensors to node at index 'i'.
// outputs_[i] is list of all output tensors to node at index 'i'.
std::vector<std::vector<int>> inputs_, outputs_;
// Holds the builtin code of the ops.
// builtin_code_[i] is the type of node at index 'i'
std::vector<int> builtin_code_;
};
Faça um benchmark e avalie o novo delegado
O TFLite possui um conjunto de ferramentas que você pode testar rapidamente em relação a um modelo TFLite.
- Ferramenta de referência de modelo : a ferramenta pega um modelo TFLite, gera entradas aleatórias e, em seguida, executa repetidamente o modelo por um número especificado de execuções. Ele imprime estatísticas de latência agregadas no final.
- Ferramenta de Diferença de Inferência : Para um determinado modelo, a ferramenta gera dados gaussianos aleatórios e os passa por dois interpretadores TFLite diferentes, um executando kernel de CPU de thread único e o outro usando uma especificação definida pelo usuário. Ele mede a diferença absoluta entre os tensores de saída de cada interpretador, por elemento. Essa ferramenta também pode ser útil para depurar problemas de precisão.
- Existem também ferramentas de avaliação específicas para tarefas, para classificação de imagens e detecção de objetos. Essas ferramentas podem ser encontradas aqui
Além disso, o TFLite possui um grande conjunto de testes de unidade de kernel e op que podem ser reutilizados para testar o novo delegado com mais cobertura e para garantir que o caminho de execução regular do TFLite não seja interrompido.
Para conseguir reutilizar testes e ferramentas do TFLite para o novo delegado, você pode usar uma das duas opções a seguir:
- Utilize o mecanismo de registrador delegado .
- Utilize o mecanismo de delegação externa .
Escolhendo a melhor abordagem
Ambas as abordagens requerem algumas alterações, conforme detalhado abaixo. No entanto, a primeira abordagem vincula o delegado estaticamente e requer a reconstrução das ferramentas de teste, benchmarking e avaliação. Em contraste, o segundo torna o delegado como uma biblioteca compartilhada e exige que você exponha os métodos de criação/exclusão da biblioteca compartilhada.
Como resultado, o mecanismo de delegado externo funcionará com os binários de ferramentas do Tensorflow Lite pré-criados do TFLite . Mas é menos explícito e pode ser mais complicado de configurar em testes de integração automatizados. Use a abordagem de registrador delegado para maior clareza.
Opção 1: aproveitar o registrador delegado
O registrador delegado mantém uma lista de provedores delegados, cada um dos quais fornece uma maneira fácil de criar delegados TFLite com base em sinalizadores de linha de comando e, portanto, são convenientes para ferramentas. Para conectar o novo delegado a todas as ferramentas do Tensorflow Lite mencionadas acima, primeiro crie um novo provedor de delegado como este e, em seguida, faça apenas algumas alterações nas regras BUILD. Um exemplo completo desse processo de integração é mostrado abaixo (e o código pode ser encontrado aqui ).
Supondo que você tenha um delegado que implemente as APIs SimpleDelegate e as APIs externas "C" de criar/excluir esse delegado 'fictício' conforme mostrado abaixo:
// Returns default options for DummyDelegate.
DummyDelegateOptions TfLiteDummyDelegateOptionsDefault();
// Creates a new delegate instance that need to be destroyed with
// `TfLiteDummyDelegateDelete` when delegate is no longer used by TFLite.
// When `options` is set to `nullptr`, the above default values are used:
TfLiteDelegate* TfLiteDummyDelegateCreate(const DummyDelegateOptions* options);
// Destroys a delegate created with `TfLiteDummyDelegateCreate` call.
void TfLiteDummyDelegateDelete(TfLiteDelegate* delegate);
Para integrar o “DummyDelegate” com Benchmark Tool e Inference Tool, defina um DelegateProvider como abaixo:
class DummyDelegateProvider : public DelegateProvider {
public:
DummyDelegateProvider() {
default_params_.AddParam("use_dummy_delegate",
ToolParam::Create<bool>(false));
}
std::vector<Flag> CreateFlags(ToolParams* params) const final;
void LogParams(const ToolParams& params) const final;
TfLiteDelegatePtr CreateTfLiteDelegate(const ToolParams& params) const final;
std::string GetName() const final { return "DummyDelegate"; }
};
REGISTER_DELEGATE_PROVIDER(DummyDelegateProvider);
std::vector<Flag> DummyDelegateProvider::CreateFlags(ToolParams* params) const {
std::vector<Flag> flags = {CreateFlag<bool>("use_dummy_delegate", params,
"use the dummy delegate.")};
return flags;
}
void DummyDelegateProvider::LogParams(const ToolParams& params) const {
TFLITE_LOG(INFO) << "Use dummy test delegate : ["
<< params.Get<bool>("use_dummy_delegate") << "]";
}
TfLiteDelegatePtr DummyDelegateProvider::CreateTfLiteDelegate(
const ToolParams& params) const {
if (params.Get<bool>("use_dummy_delegate")) {
auto default_options = TfLiteDummyDelegateOptionsDefault();
return TfLiteDummyDelegateCreateUnique(&default_options);
}
return TfLiteDelegatePtr(nullptr, [](TfLiteDelegate*) {});
}
As definições de regra BUILD são importantes, pois você precisa garantir que a biblioteca esteja sempre vinculada e não descartada pelo otimizador.
#### The following are for using the dummy test delegate in TFLite tooling ####
cc_library(
name = "dummy_delegate_provider",
srcs = ["dummy_delegate_provider.cc"],
copts = tflite_copts(),
deps = [
":dummy_delegate",
"//tensorflow/lite/tools/delegates:delegate_provider_hdr",
],
alwayslink = 1, # This is required so the optimizer doesn't optimize the library away.
)
Agora adicione essas duas regras de wrapper em seu arquivo BUILD para criar uma versão de Benchmark Tool e Inference Tool e outras ferramentas de avaliação, que podem ser executadas com seu próprio delegado.
cc_binary(
name = "benchmark_model_plus_dummy_delegate",
copts = tflite_copts(),
linkopts = task_linkopts(),
deps = [
":dummy_delegate_provider",
"//tensorflow/lite/tools/benchmark:benchmark_model_main",
],
)
cc_binary(
name = "inference_diff_plus_dummy_delegate",
copts = tflite_copts(),
linkopts = task_linkopts(),
deps = [
":dummy_delegate_provider",
"//tensorflow/lite/tools/evaluation/tasks:task_executor_main",
"//tensorflow/lite/tools/evaluation/tasks/inference_diff:run_eval_lib",
],
)
cc_binary(
name = "imagenet_classification_eval_plus_dummy_delegate",
copts = tflite_copts(),
linkopts = task_linkopts(),
deps = [
":dummy_delegate_provider",
"//tensorflow/lite/tools/evaluation/tasks:task_executor_main",
"//tensorflow/lite/tools/evaluation/tasks/imagenet_image_classification:run_eval_lib",
],
)
cc_binary(
name = "coco_object_detection_eval_plus_dummy_delegate",
copts = tflite_copts(),
linkopts = task_linkopts(),
deps = [
":dummy_delegate_provider",
"//tensorflow/lite/tools/evaluation/tasks:task_executor_main",
"//tensorflow/lite/tools/evaluation/tasks/coco_object_detection:run_eval_lib",
],
)
Você também pode conectar esse provedor delegado aos testes de kernel TFLite conforme descrito aqui .
Opção 2: aproveitar o delegado externo
Nesta alternativa, você primeiro cria um adaptador de delegado externo, o external_delegate_adaptor.cc , conforme mostrado abaixo. Observe que essa abordagem é um pouco menos preferida em comparação com a Opção 1, conforme mencionado acima .
TfLiteDelegate* CreateDummyDelegateFromOptions(char** options_keys,
char** options_values,
size_t num_options) {
DummyDelegateOptions options = TfLiteDummyDelegateOptionsDefault();
// Parse key-values options to DummyDelegateOptions.
// You can achieve this by mimicking them as command-line flags.
std::unique_ptr<const char*> argv =
std::unique_ptr<const char*>(new const char*[num_options + 1]);
constexpr char kDummyDelegateParsing[] = "dummy_delegate_parsing";
argv.get()[0] = kDummyDelegateParsing;
std::vector<std::string> option_args;
option_args.reserve(num_options);
for (int i = 0; i < num_options; ++i) {
option_args.emplace_back("--");
option_args.rbegin()->append(options_keys[i]);
option_args.rbegin()->push_back('=');
option_args.rbegin()->append(options_values[i]);
argv.get()[i + 1] = option_args.rbegin()->c_str();
}
// Define command-line flags.
// ...
std::vector<tflite::Flag> flag_list = {
tflite::Flag::CreateFlag(...),
...,
tflite::Flag::CreateFlag(...),
};
int argc = num_options + 1;
if (!tflite::Flags::Parse(&argc, argv.get(), flag_list)) {
return nullptr;
}
return TfLiteDummyDelegateCreate(&options);
}
#ifdef __cplusplus
extern "C" {
#endif // __cplusplus
// Defines two symbols that need to be exported to use the TFLite external
// delegate. See tensorflow/lite/delegates/external for details.
TFL_CAPI_EXPORT TfLiteDelegate* tflite_plugin_create_delegate(
char** options_keys, char** options_values, size_t num_options,
void (*report_error)(const char*)) {
return tflite::tools::CreateDummyDelegateFromOptions(
options_keys, options_values, num_options);
}
TFL_CAPI_EXPORT void tflite_plugin_destroy_delegate(TfLiteDelegate* delegate) {
TfLiteDummyDelegateDelete(delegate);
}
#ifdef __cplusplus
}
#endif // __cplusplus
Agora crie o destino BUILD correspondente para construir uma biblioteca dinâmica conforme mostrado abaixo:
cc_binary(
name = "dummy_external_delegate.so",
srcs = [
"external_delegate_adaptor.cc",
],
linkshared = 1,
linkstatic = 1,
deps = [
":dummy_delegate",
"//tensorflow/lite/c:common",
"//tensorflow/lite/tools:command_line_flags",
"//tensorflow/lite/tools:logging",
],
)
Depois que esse arquivo .so delegado externo é criado, você pode criar binários ou usar os pré-criados para executar com o novo delegado, desde que o binário esteja vinculado à biblioteca external_delegate_provider que oferece suporte a sinalizadores de linha de comando conforme descrito aqui . Observação: esse provedor delegado externo já foi vinculado a binários de teste e ferramentas existentes.
Consulte as descrições aqui para obter uma ilustração de como avaliar o delegado fictício por meio dessa abordagem de delegado externo. Você pode usar comandos semelhantes para as ferramentas de teste e avaliação mencionadas anteriormente.
Vale a pena notar que o delegado externo é a implementação C++ correspondente do delegado na vinculação do Tensorflow Lite Python, conforme mostrado aqui . Portanto, a biblioteca do adaptador de delegado externo dinâmico criada aqui pode ser usada diretamente com as APIs do Tensorflow Lite Python.
Recursos
Links de download para binários de ferramentas TFLite pré-construídos todas as noites
| SO | ARCO | BINARY_NAME |
| Linux | x86_64 | |
| braço | ||
| aarch64 | ||
| Android | braço | |
| aarch64 |