什么是 TensorFlow Lite 委托？
TensorFlow Lite 委托 允许您在另一个执行器上运行模型（部分或全部）。这种机制可以利用各种设备上的加速器，例如 GPU 或 Edge TPU（张量处理单元）进行推理。这为开发人员提供了一种灵活且与默认 TFLite 脱耦的方法，可以加快推理速度。
下图总结了委托，更多详细信息请参见以下部分。
何时应该创建自定义委托？
TensorFlow Lite 为目标加速器（如 GPU、DSP、EdgeTPU）和 Android NNAPI 等框架提供了各种委托。
在以下情况下创建自己的委托很有用
- 您希望集成新的机器学习推理引擎，而该引擎不受任何现有委托的支持。
- 您拥有自定义硬件加速器，可以提高已知场景的运行时间。
- 您正在开发 CPU 优化（例如运算符融合），可以加快某些模型的速度。
委托如何工作？
考虑一个简单的模型图，例如以下模型图，以及一个委托“MyDelegate”，它对 Conv2D 和 Mean 运算具有更快的实现。
应用此“MyDelegate”后，原始 TensorFlow Lite 图将更新如下
上面的图是通过 TensorFlow Lite 遵循以下两个规则拆分原始图得到的
- 可以由委托处理的特定运算将被放入分区中，同时仍满足运算之间原始计算工作流程的依赖关系。
- 每个要委托的分区只有输入和输出节点，这些节点不受委托处理。
每个由委托处理的分区都将被替换为原始图中的委托节点（也可以称为委托内核），该节点在其调用时评估分区。
根据模型的不同，最终图可能包含一个或多个节点，后者意味着某些运算不受委托支持。通常，您不希望有多个由委托处理的分区，因为每次从委托切换到主图时，都会有将结果从委托子图传递到主图的开销，这是由于内存复制（例如，GPU 到 CPU）造成的。这种开销可能会抵消性能提升，尤其是在内存复制量很大的情况下。
实现自己的自定义委托
添加委托的首选方法是使用 SimpleDelegate API。
要创建新的委托，您需要实现 2 个接口并为接口方法提供自己的实现。
1 - SimpleDelegateInterface
此类表示委托的功能，哪些运算受支持，以及用于创建封装委托图的内核的工厂类。有关更多详细信息，请参阅在此 C++ 头文件 中定义的接口。代码中的注释详细解释了每个 API。
2 - SimpleDelegateKernelInterface
此类封装了初始化/准备/运行委托分区的逻辑。
它具有：（请参阅 定义）
- Init(...): 将被调用一次以执行任何一次性初始化。
- Prepare(...): 针对每个不同的节点实例调用 - 如果你有多个委托分区，就会发生这种情况。通常你希望在这里进行内存分配，因为这将在每次张量大小调整时被调用。
- Invoke(...): 用于推理。
示例
在这个示例中，你将创建一个非常简单的委托，它只能支持两种类型的操作 (ADD) 和 (SUB)，并且只支持 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>();
}
};
接下来，通过继承 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_;
};
对新的委托进行基准测试和评估
TFLite 有一套工具，你可以快速地针对 TFLite 模型进行测试。
- 模型基准测试工具: 该工具接受一个 TFLite 模型，生成随机输入，然后重复运行模型指定次数。它在最后打印聚合的延迟统计信息。
- 推理差异工具: 对于给定的模型，该工具生成随机高斯数据，并将其通过两个不同的 TFLite 解释器，一个运行单线程 CPU 内核，另一个使用用户定义的规范。它测量每个解释器输出张量之间的绝对差异，以每个元素为基础。此工具还可以帮助调试精度问题。
- 还有一些针对图像分类和目标检测的任务特定评估工具。这些工具可以在这里找到 这里
此外，TFLite 有一套庞大的内核和操作单元测试，可以重复使用来测试新的委托，以获得更广泛的覆盖范围，并确保常规的 TFLite 执行路径没有被破坏。
为了实现对新委托重复使用 TFLite 测试和工具，你可以使用以下两种选项之一
选择最佳方法
两种方法都需要一些更改，如下所述。但是，第一种方法会静态链接委托，并需要重建测试、基准测试和评估工具。相比之下，第二种方法将委托作为共享库，并要求你从共享库公开创建/删除方法。
因此，外部委托机制将与 TFLite 的 预构建的 Tensorflow Lite 工具二进制文件 一起使用。但它不太明确，在自动集成测试中设置起来可能更复杂。使用委托注册器方法以获得更好的清晰度。
选项 1: 利用委托注册器
该 委托注册器 保持一个委托提供程序列表，每个提供程序都提供了一种简单的方法来基于命令行标志创建 TFLite 委托，因此对于工具来说很方便。要将新的委托插入到上面提到的所有 Tensorflow Lite 工具中，你首先要创建一个新的委托提供程序，就像 这个 一样，然后只对 BUILD 规则进行一些更改。下面展示了此集成过程的完整示例（代码可以在 这里 找到）。
假设你有一个委托实现了 SimpleDelegate API，以及创建/删除此“虚拟”委托的 extern “C” API，如下所示
// 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);
要将“DummyDelegate”与基准测试工具和推理工具集成，请定义一个 DelegateProvider，如下所示
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*) {});
}
BUILD 规则定义很重要，因为你需要确保库始终被链接，并且不会被优化器删除。
#### 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.
)
现在在你的 BUILD 文件中添加这两个包装器规则，以创建基准测试工具和推理工具的版本，以及其他评估工具，这些工具可以与你自己的委托一起运行。
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",
],
)
你还可以将此委托提供程序插入到 TFLite 内核测试中，如 这里 所述。
选项 2: 利用外部委托
在这个替代方案中，你首先创建一个外部委托适配器，即 external_delegate_adaptor.cc，如下所示。注意，与选项 1 相比，这种方法略微不那么受欢迎，如 前面所述。
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
现在创建相应的 BUILD 目标以构建动态库，如下所示
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",
],
)
创建此外部委托 .so 文件后，你可以构建二进制文件或使用预构建的二进制文件与新的委托一起运行，只要二进制文件与 external_delegate_provider 库链接，该库支持命令行标志，如 这里 所述。注意：此外部委托提供程序已经链接到现有的测试和工具二进制文件。
请参考 这里 的描述，了解如何通过这种外部委托方法对虚拟委托进行基准测试。你可以对前面提到的测试和评估工具使用类似的命令。
值得注意的是，外部委托 是 Tensorflow Lite Python 绑定中 委托 的相应 C++ 实现，如 这里 所示。因此，这里创建的动态外部委托适配器库可以直接与 Tensorflow Lite Python API 一起使用。
资源
夜间构建的预构建 TFLite 工具二进制文件的下载链接
| 操作系统 | 架构 | 二进制文件名称 |
| Linux | x86_64 | |
| arm | ||
| aarch64 | ||
| Android | arm | |
| aarch64 |