Menerapkan Delegasi Kustom

Apa itu Delegasi TensorFlow Lite?

Delegasi TensorFlow Lite memungkinkan Anda menjalankan model (sebagian atau keseluruhan) pada eksekutor lain. Mekanisme ini dapat memanfaatkan berbagai akselerator pada perangkat seperti GPU atau Edge TPU (Tensor Processing Unit) untuk inferensi. Hal ini memberi pengembang metode yang fleksibel dan terpisah dari TFLite default untuk mempercepat inferensi.

Diagram di bawah merangkum para delegasi, detail selengkapnya ada di bagian bawah.

Kapan saya harus membuat delegasi khusus?

TensorFlow Lite memiliki beragam delegasi untuk akselerator target seperti GPU, DSP, EdgeTPU, dan framework seperti Android NNAPI.

Membuat delegasi Anda sendiri berguna dalam skenario berikut:

• Anda ingin mengintegrasikan mesin inferensi ML baru yang tidak didukung oleh delegasi mana pun yang ada.
• Anda memiliki akselerator perangkat keras khusus yang meningkatkan waktu proses untuk skenario yang diketahui.
• Anda sedang mengembangkan pengoptimalan CPU (seperti penggabungan operator) yang dapat mempercepat model tertentu.

Bagaimana cara kerja delegasi?

Pertimbangkan grafik model sederhana seperti berikut, dan delegasi “MyDelegate” yang memiliki implementasi lebih cepat untuk operasi Conv2D dan Mean.

Setelah menerapkan “MyDelegate” ini, grafik TensorFlow Lite asli akan diperbarui seperti berikut:

Grafik di atas diperoleh saat TensorFlow Lite membagi grafik asli dengan mengikuti dua aturan:

• Operasi spesifik yang dapat ditangani oleh delegasi dimasukkan ke dalam partisi sambil tetap memenuhi ketergantungan alur kerja komputasi asli antar operasi.
• Setiap partisi yang akan didelegasikan hanya memiliki node input dan output yang tidak ditangani oleh delegasi.

Setiap partisi yang ditangani oleh delegasi digantikan oleh node delegasi (bisa juga disebut sebagai kernel delegasi) dalam grafik asli yang mengevaluasi partisi pada panggilan pemanggilannya.

Bergantung pada modelnya, grafik akhir dapat berakhir dengan satu atau lebih node, yang berarti beberapa operasi tidak didukung oleh delegasi. Secara umum, Anda tidak ingin beberapa partisi ditangani oleh delegasi, karena setiap kali Anda beralih dari delegasi ke grafik utama, ada overhead untuk meneruskan hasil dari subgraf yang didelegasikan ke grafik utama yang dihasilkan karena memori salinan (misalnya, GPU ke CPU). Overhead tersebut mungkin mengimbangi peningkatan kinerja terutama bila terdapat salinan memori dalam jumlah besar.

Menerapkan delegasi Kustom Anda sendiri

Metode pilihan untuk menambahkan delegasi adalah menggunakan SimpleDelegate API .

Untuk membuat delegasi baru, Anda perlu mengimplementasikan 2 antarmuka dan menyediakan implementasi Anda sendiri untuk metode antarmuka.

1 - SimpleDelegateInterface

Kelas ini mewakili kemampuan delegasi, operasi mana yang didukung, dan kelas pabrik untuk membuat kernel yang merangkum grafik yang didelegasikan. Untuk lebih jelasnya, lihat antarmuka yang ditentukan dalam file header C++ ini. Komentar dalam kode menjelaskan setiap API secara detail.

2 - SimpleDelegateKernelInterface

Kelas ini merangkum logika untuk menginisialisasi/mempersiapkan/dan menjalankan partisi yang didelegasikan.

Ini memiliki: (Lihat definisi )

• Init(...): yang akan dipanggil satu kali untuk melakukan inisialisasi satu kali.
• Prepare(...): dipanggil untuk setiap instance berbeda dari node ini - ini terjadi jika Anda memiliki beberapa partisi yang didelegasikan. Biasanya Anda ingin melakukan alokasi memori di sini, karena ini akan dipanggil setiap kali tensor diubah ukurannya.
• Invoke(...): yang akan dipanggil untuk inferensi.

Contoh

Dalam contoh ini, Anda akan membuat delegasi yang sangat sederhana yang hanya dapat mendukung 2 jenis operasi (ADD) dan (SUB) dengan tensor float32 saja.

// 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>();
  }
};

Selanjutnya, buat kernel delegasi Anda sendiri dengan mewarisi dari 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_;
};

Tolok ukur dan evaluasi delegasi baru

TFLite memiliki seperangkat alat yang dapat Anda uji dengan cepat terhadap model TFLite.

• Alat Tolok Ukur Model : Alat ini mengambil model TFLite, menghasilkan input acak, lalu menjalankan model berulang kali untuk sejumlah proses tertentu. Ini mencetak statistik latensi gabungan di bagian akhir.
• Alat Perbedaan Inferensi : Untuk model tertentu, alat tersebut menghasilkan data Gaussian acak dan meneruskannya melalui dua penerjemah TFLite yang berbeda, satu menjalankan kernel CPU berulir tunggal dan yang lainnya menggunakan spesifikasi yang ditentukan pengguna. Ini mengukur perbedaan absolut antara tensor keluaran dari masing-masing penafsir, berdasarkan per elemen. Alat ini juga dapat berguna untuk men-debug masalah akurasi.
• Ada juga alat evaluasi tugas khusus, untuk klasifikasi gambar dan deteksi objek. Alat-alat ini dapat ditemukan di sini

Selain itu, TFLite memiliki serangkaian besar pengujian kernel dan unit operasi yang dapat digunakan kembali untuk menguji delegasi baru dengan cakupan lebih luas dan untuk memastikan jalur eksekusi TFLite reguler tidak rusak.

Untuk mencapai penggunaan kembali pengujian dan alat TFLite untuk delegasi baru, Anda dapat menggunakan salah satu dari dua opsi berikut:

• Memanfaatkan mekanisme pendaftar delegasi .
• Memanfaatkan mekanisme delegasi eksternal .

Memilih pendekatan terbaik

Kedua pendekatan tersebut memerlukan beberapa perubahan seperti yang dijelaskan di bawah ini. Namun, pendekatan pertama menghubungkan delegasi secara statis dan memerlukan pembangunan kembali alat pengujian, benchmarking, dan evaluasi. Sebaliknya, yang kedua menjadikan delegasi sebagai perpustakaan bersama dan mengharuskan Anda untuk mengekspos metode buat/hapus dari perpustakaan bersama.

Hasilnya, mekanisme delegasi eksternal akan bekerja dengan biner perkakas Tensorflow Lite yang sudah dibuat sebelumnya dari TFLite. Namun hal ini kurang eksplisit dan mungkin lebih rumit untuk disiapkan dalam pengujian integrasi otomatis. Gunakan pendekatan pendaftar delegasi untuk kejelasan yang lebih baik.

Opsi 1: Manfaatkan pencatat delegasi

Pendaftar delegasi menyimpan daftar penyedia delegasi, yang masing-masing menyediakan cara mudah untuk membuat delegasi TFLite berdasarkan tanda baris perintah, dan karenanya, nyaman untuk perkakas. Untuk memasukkan delegasi baru ke semua alat Tensorflow Lite yang disebutkan di atas, pertama-tama buatlah penyedia delegasi baru seperti ini , lalu buat sedikit perubahan saja pada aturan BUILD. Contoh lengkap dari proses integrasi ini ditunjukkan di bawah (dan kode dapat ditemukan di sini ).

Dengan asumsi Anda memiliki delegasi yang mengimplementasikan API SimpleDelegate, dan API "C" eksternal untuk membuat/menghapus delegasi 'dummy' ini seperti yang ditunjukkan di bawah ini:

// 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);

Untuk mengintegrasikan “DummyDelegate” dengan Alat Benchmark dan Alat Inferensi, tentukan DelegateProvider seperti di bawah ini:

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*) {});
}

Definisi aturan BUILD penting karena Anda perlu memastikan bahwa perpustakaan selalu ditautkan dan tidak dihilangkan oleh pengoptimal.

#### 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.
)

Sekarang tambahkan dua aturan pembungkus ini di file BUILD Anda untuk membuat versi Alat Benchmark dan Alat Inferensi, serta alat evaluasi lainnya, yang dapat dijalankan dengan delegasi Anda sendiri.

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",
    ],
)

Anda juga dapat menyambungkan penyedia delegasi ini ke pengujian kernel TFLite seperti yang dijelaskan di sini .

Opsi 2: Manfaatkan delegasi eksternal

Dalam alternatif ini, pertama-tama Anda membuat adaptor delegasi eksternal external_delegate_adaptor.cc seperti yang ditunjukkan di bawah ini. Perlu diperhatikan, pendekatan ini kurang disukai dibandingkan dengan Opsi 1 seperti yang telah disebutkan di atas .

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

Sekarang buat target BUILD yang sesuai untuk membangun perpustakaan dinamis seperti yang ditunjukkan di bawah ini:

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",
    ],
)

Setelah file .so delegasi eksternal ini dibuat, Anda dapat membuat binari atau menggunakan binari yang telah dibuat sebelumnya untuk dijalankan dengan delegasi baru selama biner tersebut ditautkan dengan pustaka external_delegate_provider yang mendukung tanda baris perintah seperti yang dijelaskan di sini . Catatan: penyedia delegasi eksternal ini telah ditautkan ke binari pengujian dan perkakas yang ada.

Lihat uraian di sini untuk ilustrasi tentang cara melakukan tolok ukur delegasi tiruan melalui pendekatan delegasi eksternal ini. Anda dapat menggunakan perintah serupa untuk alat pengujian dan evaluasi yang disebutkan sebelumnya.

Perlu dicatat bahwa delegasi eksternal adalah implementasi C++ yang sesuai dari delegasi dalam pengikatan Tensorflow Lite Python seperti yang ditunjukkan di sini . Oleh karena itu, pustaka adaptor delegasi eksternal dinamis yang dibuat di sini dapat langsung digunakan dengan Tensorflow Lite Python API.

Sumber daya

Tautan unduhan untuk binari perkakas TFLite yang dibuat sebelumnya setiap malam