graph_dp_model.cpp

Go to the documentation of this file.

// Copyright 2021 CEA LIST
// SPDX-FileCopyrightText: 2022 CEA LIST <gael.de-chalendar@cea.fr>
//
// SPDX-License-Identifier: MIT
 
#include <algorithm>
 
#include "deeplima/eigen_wrp/graph_dp_eigen_inference_impl.h"
#include "tasks/graph_dp/model/birnn_and_deep_biaffine_attention.h"
 
#include "convert_from_torch.h"
 
using namespace std;
using namespace torch;
using namespace deeplima::convert_from_torch;
using namespace deeplima::eigen_impl;
 
namespace deeplima
{
namespace graph_dp
{
namespace eigen_impl
{
 
void convert_classes(const DictsHolder& src, vector<vector<string>>& classes);
 
void BiRnnAndDeepBiaffineAttentionEigenInference::convert_from_torch(const std::string& fn)
{
  train::BiRnnAndDeepBiaffineAttentionImpl src;
  torch::load(src, fn, torch::Device(torch::kCPU));
 
  // dicts and embeddings
  Parent::convert_dicts_and_embeddings(src);
  m_embd_fn.push_back(src.get_embd_fn(0));
  assert(m_embd_fn[0].size() > 0);
 
  Parent::m_input_str_dicts_names = src.get_input_class_names();
  Parent::m_output_str_dicts_names = src.get_output_class_names();
 
  // torch modules
  Parent::m_lstm.reserve(src.get_layers_lstm().size());
  for (size_t i = 0; i < src.get_layers_lstm().size(); i++)
  {
    const std::string name = src.get_module_name(i, "lstm");
    Parent::m_lstm_idx[name] = i;
 
    const nn::LSTM& m = src.get_layers_lstm()[i];
    Parent::m_lstm.emplace_back(typename Parent::params_bilstm_spec_t());
    typename Parent::params_bilstm_spec_t& layer = Parent::m_lstm.back();
 
    convert_module_from_torch(m, layer);
  }
 
  Parent::m_multi_bilstm.emplace_back(std::make_shared<typename Parent::params_multilayer_bilstm_spec_t>(Parent::m_lstm));
  Parent::m_multi_bilstm_idx["encoder"] = 0;
 
  Parent::m_linear.reserve(src.get_layers_linear().size());
  for (size_t i = 0; i < src.get_layers_linear().size(); i++)
  {
    const std::string name = src.get_module_name(i, "linear");
    Parent::m_linear_idx[name] = i;
 
    const nn::Linear& m = src.get_layers_linear()[i];
    Parent::m_linear.emplace_back(params_linear_t<Eigen::MatrixXf, Eigen::VectorXf>());
    params_linear_t<Eigen::MatrixXf, Eigen::VectorXf>& layer = Parent::m_linear.back();
 
    convert_module_from_torch(m, layer);
  }
 
  m_deep_biaffine_attn_decoder.reserve(src.get_layers_deep_biaffine_attn_decoder().size());
 
  for (size_t i = 0; i < src.get_layers_deep_biaffine_attn_decoder().size(); i++)
  {
    const std::string name = src.get_module_name(i, "deep_biaffine_attention_decoder");
    m_deep_biaffine_attn_decoder_idx[name] = i;
 
    const deeplima::nets::torch_modules::DeepBiaffineAttentionDecoder& m
        = src.get_layers_deep_biaffine_attn_decoder()[i];
 
    m_deep_biaffine_attn_decoder.emplace_back(std::make_shared<params_deep_biaffine_attn_decoder_t<Eigen::MatrixXf, Eigen::VectorXf>>());
    auto& layer = *m_deep_biaffine_attn_decoder.back().get();
 
    convert_module_from_torch(m, layer);
  }
 
  // Label (deprel) decoder, present only in labeled models.
  for (size_t i = 0; i < src.get_layers_deep_biaffine_attn_label_decoder().size(); i++)
  {
    const deeplima::nets::torch_modules::DeepBiaffineAttentionLabelDecoder& m
        = src.get_layers_deep_biaffine_attn_label_decoder()[i];
 
    m_deep_biaffine_attn_label_decoder.emplace_back(std::make_shared<params_deep_biaffine_attn_label_decoder_t<Eigen::MatrixXf, Eigen::VectorXf>>());
    auto& layer = *m_deep_biaffine_attn_label_decoder.back().get();
 
    convert_module_from_torch(m, layer);
  }
  m_rel_class_names = src.get_rel_class_names();
 
  // The arc head is the only generic "task" the model declares, so the output
  // buffer would be sized to a single column. The deprel (rel) is produced by a
  // separate label decoder rather than the generic task pool, so when one is
  // present we add a second output column for it. predict() fills column 0 with
  // heads and column 1 with deprel ids.
  if (!m_deep_biaffine_attn_label_decoder.empty()
      && std::find(Parent::m_output_str_dicts_names.begin(),
                   Parent::m_output_str_dicts_names.end(), "rel")
         == Parent::m_output_str_dicts_names.end())
  {
    Parent::m_output_str_dicts_names.push_back("rel");
  }
 
  // temp: create exec plan
  Parent::m_ops.push_back(std::make_shared<Op_BiLSTM<Eigen::MatrixXf, Eigen::VectorXf, float>>());
  Parent::m_params.push_back(Parent::m_multi_bilstm[0]);
 
  Parent::m_ops.push_back(std::make_shared<Op_DeepBiaffineAttnDecoder<Eigen::MatrixXf, Eigen::VectorXf, float>>());
  Parent::m_params.push_back(m_deep_biaffine_attn_decoder[0]);
 
  Parent::m_wb.resize(2);
 
  // tags
  // std::cerr << "TAGS:" << std::endl;
  // for ( const auto& it : src.get_tags() )
  // {
  //   std::cerr << "\t" << it.first << " = " << it.second << std::endl;
  // }
  // std::cerr << std::endl;
}
 
void convert_classes(const DictsHolder& src, vector<vector<string>>& classes)
{
  classes.resize(src.size());
  for (size_t i = 0; i < classes.size(); ++i)
  {
    shared_ptr<StringDict> d = dynamic_pointer_cast<StringDict, DictBase>(src[i]);
    classes[i].reserve(d->size());
    for (size_t j = 0; j < d->size(); ++j)
    {
      classes[i].push_back(d->get_value(j));
    }
  }
}
 
} // namespace eigen_impl
} // namespace graph_dp
} // namespace deeplima