[onert] Load BCQUnembedding operator (#16216)

* [onert] Load BCQUnembedding operator

This commit updates CircleLoader to load `BCQUnembedding` custom operator.

Signed-off-by: Seok Namkoong <seok9311@naver.com>

* fix error handling

---------

Signed-off-by: Seok Namkoong <seok9311@naver.com>

Author: llFreetimell

runtime/onert/core/src/loader/BaseLoader.h

@@ -101,6 +101,8 @@ template <typename LoaderDomain> class BaseLoader
   void loadSparsity(const Tensor *tensor, ir::TypeInfo &typeInfo);
   void loadOperationIO(const Operator *op, ir::OperandIndexSequence &inputs,
                        ir::OperandIndexSequence &outputs);
+  template <typename OpIR, typename... Args>
+  const OpIR *loadOperationTo(const Operator *op, ir::Graph &subg, Args &&...args);
   // Create operations from Operator
   void loadOperation(const Operator *op, ir::Graph &subg);
   // Load Strides and Paddings from options to param
@@ -131,8 +133,6 @@ template <typename LoaderDomain> class BaseLoader
   std::unique_ptr<ir::Data> loadMetadata(const uint32_t buffer_idx);
   virtual std::unique_ptr<ir::Graph> loadSubgraph(const SubGraph *subg) = 0;
   // Operations
-  template <typename OpIR, typename... Args>
-  const OpIR *loadOperationTo(const Operator *op, ir::Graph &subg, Args &&...args);
 
   void loadArgMinMax(const Operator *op, ir::Graph &subg, bool is_argmax);
   void loadBinaryArithmetic(const Operator *op, ir::Graph &subg,

runtime/onert/core/src/loader/CircleLoader.cc

@@ -75,6 +75,7 @@ class CircleLoader final : public loader::BaseLoader<LoaderDomain>
   void loadRoPE(const Operator *op, ir::Graph &subg);
   void loadCall(const Operator *op, ir::Graph &subg);
   void loadRunModel(const Operator *op, ir::Graph &subg);
+  void loadBCQUnembedding(const Operator *op, ir::Graph &subg);
   void loadCustom(const Operator *op, ir::Graph &subg);
 
 public:
@@ -86,6 +87,7 @@ class CircleLoader final : public loader::BaseLoader<LoaderDomain>
     {
       case BuiltinOperator::BuiltinOperator_FULLY_CONNECTED:
       case BuiltinOperator::BuiltinOperator_BCQ_FULLY_CONNECTED:
+      case BuiltinOperator::BuiltinOperator_CUSTOM:
       case BuiltinOperator::BuiltinOperator_UNIDIRECTIONAL_SEQUENCE_LSTM:
         return true;
       default:
@@ -182,6 +184,9 @@ class CircleLoader final : public loader::BaseLoader<LoaderDomain>
       case circle::BuiltinOperator::BuiltinOperator_RUN_MODEL:
         loadRunModel(op, subg);
         return;
+      case circle::BuiltinOperator::BuiltinOperator_CUSTOM:
+        loadCustom(op, subg);
+        return;
       default:
         BaseLoader::loadOperation(op, subg);
         return;
@@ -350,6 +355,76 @@ void CircleLoader::loadRunModel(const Operator *op, ir::Graph &subg)
   subg.addOperation(std::move(new_op));
 }
 
+void CircleLoader::loadBCQUnembedding(const Operator *op, ir::Graph &subg)
+{
+  ir::OperandIndexSequence inputs;
+  ir::OperandIndexSequence outputs;
+
+  loadOperationIO(op, inputs, outputs);
+
+  ir::operation::BCQUnembedding::Param param;
+  if (op->custom_options() == nullptr)
+  {
+    throw std::runtime_error{"BCQUnembedding: empty option"};
+  }
+  else
+  {
+    const auto attr_map = getCustomOpAttrMap(op);
+    param.weights_hidden_size = attr_map["weights_hidden_size"].AsUInt32();
+    param.lsh_type = attr_map["lsh_type"].AsString().str();
+    param.lsh_choices = attr_map["lsh_choices"].AsInt32();
+  }
+
+  const auto fbn = loadOperationTo<ir::operation::BCQUnembedding>(op, subg, param);
+
+  if (fbn->getInputs().size() != 5)
+  {
+    throw std::runtime_error{"BCQUnembedding: NYI input - only support five inputs"};
+  }
+}
+
+void CircleLoader::loadCustom(const Operator *op, ir::Graph &subg)
+{
+  ir::OperandIndexSequence inputs;
+  ir::OperandIndexSequence outputs;
+
+  assert(op->custom_options_format() == CustomOptionsFormat::CustomOptionsFormat_FLEXBUFFERS &&
+         "Unsupported custom operation options format");
+
+  auto *op_code = _domain_model->operator_codes()->Get(op->opcode_index());
+  auto custom_op_name = op_code->custom_code()->str();
+
+  enum class BuiltinOP
+  {
+    BCQUnembedding,
+  };
+
+  // Mapping from custom op name string to BuiltinOP enum
+  std::map<std::string, BuiltinOP> builtin_map = {
+    {"BCQUnembedding", BuiltinOP::BCQUnembedding},
+  };
+
+  // If unknown circle custom op, pass to BaseLoader
+  if (builtin_map.find(custom_op_name) == builtin_map.end())
+  {
+    BaseLoader::loadOperation(op, subg);
+    return;
+  }
+
+  auto custom_op_id = builtin_map.at(custom_op_name);
+  switch (custom_op_id)
+  {
+    case BuiltinOP::BCQUnembedding:
+      loadBCQUnembedding(op, subg);
+      break;
+    default:
+      throw std::runtime_error{"CircleLoader: Circle Custom OP map is defined but operation loader "
+                               "function is not defined"};
+  }
+
+  return;
+}
+
 } // namespace
 
 std::unique_ptr<ir::Model> loadCircleModel(const std::string &filename)