Class BertModel::Impl

example/cpp/bert_model.cpp:81–236

};

struct BertModel::Impl {
  explicit Impl(const std::string &filename, DLDeviceType device_type,
                size_t n_layers, int64_t n_heads)
      : device_type_(device_type) {
    auto npz = cnpy::npz_load(filename);
    NPZMapView root("", &npz);

    // HERE define your network model
    embedding_ = LoadEmbedding(root.Sub("embeddings"), device_type);

    for (size_t i = 0; i < n_layers; ++i) {
      auto view = root.Sub("encoder.layer." + std::to_string(i));
      NPZLoader params(view, device_type);
      encoders_.emplace_back(std::move(params), n_heads);
    }

    if (root.IsExist("pooler")) {
      pooler_ = LoadPooler(root.Sub("pooler"), device_type);
    }
  }

  // preprocess helper function
  template <typename T>
  void PadTensor(const std::vector<std::vector<T>> &data_array, int64_t n,
                 int64_t m, T pad_val, DLDeviceType device_type,
                 core::Tensor *output_tensor) {
    if (m == 0 || n == 0 || data_array.size() == 0) {
      return;
    }
    core::Tensor cpu_tensor(nullptr);
    T *tensor_data_ptr;
    if (device_type == DLDeviceType::kDLGPU) {
      tensor_data_ptr = cpu_tensor.Reshape<T>({n, m}, DLDeviceType::kDLCPU, 0);
      output_tensor->Reshape<T>({n, m}, device_type, 0);
    } else {
      tensor_data_ptr = output_tensor->Reshape<T>({n, m}, device_type, 0);
    }
    for (int64_t i = 0; i < n; ++i, tensor_data_ptr += m) {
      auto &line = data_array[i];
      if (line.size() > 0) {
        core::Copy(line.data(), line.size(), DLDeviceType::kDLCPU,
                   DLDeviceType::kDLCPU, tensor_data_ptr);
      }
      if (line.size() != static_cast<size_t>(m)) {
        layers::kernels::common::Fill(tensor_data_ptr + line.size(),
                                      static_cast<size_t>(m) - line.size(),
                                      pad_val, DLDeviceType::kDLCPU);
      }
    }
    if (device_type == DLDeviceType::kDLGPU) {
      core::Copy<T>(cpu_tensor, *output_tensor);
    }
  }

  // do inference
  std::vector<float> operator()(
      const std::vector<std::vector<int64_t>> &inputs,
      const std::vector<std::vector<int64_t>> &poistion_ids,