HistoryModule.cpp

#include "HistoryModule.hpp"

HistoryModuleImpl::HistoryModuleImpl(std::string name, const std::string & definition)
{
  setName(name);
  std::regex regex("(?:(?:\\s|\\t)*)NbElem\\{(.*)\\}(?:(?:\\s|\\t)*)(\\S+)\\{(.*)\\}(?:(?:\\s|\\t)*)In\\{(.*)\\}(?:(?:\\s|\\t)*)Out\\{(.*)\\}(?:(?:\\s|\\t)*)");
  if (!util::doIfNameMatch(regex, definition, [this,&definition](auto sm)
        {
          try
          {
            maxNbElements = std::stoi(sm.str(1));

            auto subModuleType = sm.str(2);
            auto subModuleArguments = util::split(sm.str(3), ' ');

            auto options = MyModule::ModuleOptions(true)
              .bidirectional(std::stoi(subModuleArguments[0]))
              .num_layers(std::stoi(subModuleArguments[1]))
              .dropout(std::stof(subModuleArguments[2]))
              .complete(std::stoi(subModuleArguments[3]));

            inSize = std::stoi(sm.str(4));
            int outSize = std::stoi(sm.str(5));

            if (subModuleType == "LSTM")
              myModule = register_module("myModule", LSTM(inSize, outSize, options));
            else if (subModuleType == "GRU")
              myModule = register_module("myModule", GRU(inSize, outSize, options));
            else if (subModuleType == "Concat")
              myModule = register_module("myModule", Concat(inSize));
            else
              util::myThrow(fmt::format("unknown sumodule type '{}'", subModuleType));

          } catch (std::exception & e) {util::myThrow(fmt::format("{} in '{}'",e.what(),definition));}
        }))
    util::myThrow(fmt::format("invalid definition '{}'", definition));
}

torch::Tensor HistoryModuleImpl::forward(torch::Tensor input)
{
  return myModule->forward(wordEmbeddings(input.narrow(1, firstInputIndex, maxNbElements)));
}

std::size_t HistoryModuleImpl::getOutputSize()
{
  return myModule->getOutputSize(maxNbElements);
}

std::size_t HistoryModuleImpl::getInputSize()
{
  return maxNbElements;
}

void HistoryModuleImpl::addToContext(std::vector<std::vector<long>> & context, const Config & config)
{
  auto & dict = getDict();

  for (auto & contextElement : context)
    for (int i = 0; i < maxNbElements; i++)
      if (config.hasHistory(i))
        contextElement.emplace_back(dict.getIndexOrInsert(config.getHistory(i)));
      else
        contextElement.emplace_back(dict.getIndexOrInsert(Dict::nullValueStr));
}

void HistoryModuleImpl::registerEmbeddings()
{
  wordEmbeddings = register_module("embeddings", torch::nn::Embedding(torch::nn::EmbeddingOptions(getDict().size(), inSize)));
}