NeuralNetwork::extractContext can now generate multiple variants of context

decoder/src/Decoder.cpp

@@ -25,10 +25,10 @@ void Decoder::decode(BaseConfig & config, std::size_t beamSize, bool debug, bool
       config.printForDebug(stderr);
 
     auto dictState = machine.getDict(config.getState()).getState();
-    auto context = machine.getClassifier()->getNN()->extractContext(config, machine.getDict(config.getState()));
+    auto context = machine.getClassifier()->getNN()->extractContext(config, machine.getDict(config.getState())).back();
     machine.getDict(config.getState()).setState(dictState);
 
-    auto neuralInput = torch::from_blob(context.data(), {(long)context.size()}, at::kLong).clone().to(NeuralNetworkImpl::device);
+    auto neuralInput = torch::from_blob(context.data(), {(long)context.size()}, torch::kLong).clone().to(NeuralNetworkImpl::device);
     auto prediction = machine.getClassifier()->getNN()(neuralInput).squeeze();
 
     int chosenTransition = -1;

torch_modules/include/CNNNetwork.hpp

@@ -33,7 +33,7 @@ class CNNNetworkImpl : public NeuralNetworkImpl
 
   CNNNetworkImpl(int nbOutputs, int unknownValueThreshold, int leftBorder, int rightBorder, int nbStackElements, std::vector<std::string> columns, std::vector<int> focusedBufferIndexes, std::vector<int> focusedStackIndexes, std::vector<std::string> focusedColumns, std::vector<int> maxNbElements, int leftWindowRawInput, int rightWindowRawInput);
   torch::Tensor forward(torch::Tensor input) override;
-  std::vector<long> extractContext(Config & config, Dict & dict) const override;
+  std::vector<std::vector<long>> extractContext(Config & config, Dict & dict) const override;
 };
 
 #endif

torch_modules/include/NeuralNetwork.hpp

@@ -27,7 +27,7 @@ class NeuralNetworkImpl : public torch::nn::Module
   public :
 
   virtual torch::Tensor forward(torch::Tensor input) = 0;
-  virtual std::vector<long> extractContext(Config & config, Dict & dict) const;
+  virtual std::vector<std::vector<long>> extractContext(Config & config, Dict & dict) const;
   std::vector<long> extractContextIndexes(const Config & config) const;
   int getContextSize() const;
   void setColumns(const std::vector<std::string> & columns);

torch_modules/include/RLTNetwork.hpp

@@ -23,7 +23,7 @@ class RLTNetworkImpl : public NeuralNetworkImpl
 
   RLTNetworkImpl(int nbOutputs, int leftBorder, int rightBorder, int nbStackElements);
   torch::Tensor forward(torch::Tensor input) override;
-  std::vector<long> extractContext(Config & config, Dict & dict) const override;
+  std::vector<std::vector<long>> extractContext(Config & config, Dict & dict) const override;
 };
 
 #endif

torch_modules/src/CNNNetwork.cpp

@@ -74,44 +74,52 @@ torch::Tensor CNNNetworkImpl::forward(torch::Tensor input)
   return linear2(hiddenDropout(torch::relu(linear1(totalInput))));
 }
 
-std::vector<long> CNNNetworkImpl::extractContext(Config & config, Dict & dict) const
+std::vector<std::vector<long>> CNNNetworkImpl::extractContext(Config & config, Dict & dict) const
 {
   if (dict.size() >= maxNbEmbeddings)
     util::warning(fmt::format("dict.size()={} > maxNbEmbeddings={}", dict.size(), maxNbEmbeddings));
 
   std::vector<long> contextIndexes = extractContextIndexes(config);
-  std::vector<long> context;
+  std::vector<std::vector<long>> context;
+  context.emplace_back();
 
   if (rawInputSize > 0)
   {
     for (int i = 0; i < leftWindowRawInput; i++)
       if (config.hasCharacter(config.getCharacterIndex()-leftWindowRawInput+i))
-        context.push_back(dict.getIndexOrInsert(fmt::format("Letter({})", config.getLetter(config.getCharacterIndex()-leftWindowRawInput+i))));
+        context.back().push_back(dict.getIndexOrInsert(fmt::format("Letter({})", config.getLetter(config.getCharacterIndex()-leftWindowRawInput+i))));
       else
-        context.push_back(dict.getIndexOrInsert(Dict::nullValueStr));
+        context.back().push_back(dict.getIndexOrInsert(Dict::nullValueStr));
 
     for (int i = 0; i <= rightWindowRawInput; i++)
       if (config.hasCharacter(config.getCharacterIndex()+i))
-
-        context.push_back(dict.getIndexOrInsert(fmt::format("Letter({})", config.getLetter(config.getCharacterIndex()+i))));
+        context.back().push_back(dict.getIndexOrInsert(fmt::format("Letter({})", config.getLetter(config.getCharacterIndex()+i))));
       else
-        context.push_back(dict.getIndexOrInsert(Dict::nullValueStr));
+        context.back().push_back(dict.getIndexOrInsert(Dict::nullValueStr));
   }
 
   for (auto index : contextIndexes)
     for (auto & col : columns)
       if (index == -1)
-        context.push_back(dict.getIndexOrInsert(Dict::nullValueStr));
+        for (auto & contextElement : context)
+          contextElement.push_back(dict.getIndexOrInsert(Dict::nullValueStr));
       else
       {
         int dictIndex = dict.getIndexOrInsert(config.getAsFeature(col, index));
+
+        for (auto & contextElement : context)
+          contextElement.push_back(dictIndex);
+
+        if (is_training())
           if (col == "FORM" || col == "LEMMA")
             if (dict.getNbOccs(dictIndex) < unknownValueThreshold)
-            dictIndex = dict.getIndexOrInsert(Dict::unknownValueStr);
-
-        context.push_back(dictIndex);
+            {
+              context.emplace_back(context.back());
+              context.back().back() = dict.getIndexOrInsert(Dict::unknownValueStr);
+            }
       }
 
+  for (auto & contextElement : context)
     for (unsigned int colIndex = 0; colIndex < focusedColumns.size(); colIndex++)
     {
       auto & col = focusedColumns[colIndex];
@@ -140,7 +148,7 @@ std::vector<long> CNNNetworkImpl::extractContext(Config & config, Dict & dict) c
         if (index == -1)
         {
           for (int i = 0; i < maxNbElements[colIndex]; i++)
-          context.emplace_back(dict.getIndexOrInsert(Dict::nullValueStr));
+            contextElement.emplace_back(dict.getIndexOrInsert(Dict::nullValueStr));
           continue;
         }
 
@@ -183,10 +191,13 @@ std::vector<long> CNNNetworkImpl::extractContext(Config & config, Dict & dict) c
           util::myThrow(fmt::format("elements.size ({}) != maxNbElements[colIndex ({},{})]", elements.size(), maxNbElements[colIndex], col));
 
         for (auto & element : elements)
-        context.emplace_back(dict.getIndexOrInsert(element));
+          contextElement.emplace_back(dict.getIndexOrInsert(element));
       }
     }
 
+  if (!is_training() && context.size() > 1)
+    util::myThrow(fmt::format("Not in training mode, yet context yields multiple variants (size={})", context.size()));
+
   return context;
 }
 

torch_modules/src/NeuralNetwork.cpp

@@ -35,7 +35,7 @@ std::vector<long> NeuralNetworkImpl::extractContextIndexes(const Config & config
   return context;
 }
 
-std::vector<long> NeuralNetworkImpl::extractContext(Config & config, Dict & dict) const
+std::vector<std::vector<long>> NeuralNetworkImpl::extractContext(Config & config, Dict & dict) const
 {
   std::vector<long> indexes = extractContextIndexes(config);
   std::vector<long> context;
@@ -47,7 +47,7 @@ std::vector<long> NeuralNetworkImpl::extractContext(Config & config, Dict & dict
       else
         context.push_back(dict.getIndexOrInsert(config.getAsFeature(col, index)));
 
-  return context;
+  return {context};
 }
 
 int NeuralNetworkImpl::getContextSize() const

torch_modules/src/RLTNetwork.cpp

@@ -79,7 +79,7 @@ torch::Tensor RLTNetworkImpl::forward(torch::Tensor input)
   return linear2(torch::relu(linear1(representation)));
 }
 
-std::vector<long> RLTNetworkImpl::extractContext(Config & config, Dict & dict) const
+std::vector<std::vector<long>> RLTNetworkImpl::extractContext(Config & config, Dict & dict) const
 {
   std::vector<long> contextIndexes;
   std::stack<int> leftContext;
@@ -183,6 +183,6 @@ std::vector<long> RLTNetworkImpl::extractContext(Config & config, Dict & dict) c
       else
         context.push_back(dict.getIndexOrInsert(config.getAsFeature(col, l)));
 
-  return context;
+  return {context};
 }
 

trainer/src/Trainer.cpp

@@ -48,19 +48,23 @@ void Trainer::extractExamples(SubConfig & config, bool debug, std::vector<torch:
       util::myThrow("No transition appliable !");
     }
 
+    std::vector<std::vector<long>> context;
+
     try
     {
-      auto context = machine.getClassifier()->getNN()->extractContext(config,machine.getDict(config.getState()));
-      contexts.emplace_back(torch::from_blob(context.data(), {(long)context.size()}, torch::TensorOptions(at::kLong)).clone().to(NeuralNetworkImpl::device));
+      context = machine.getClassifier()->getNN()->extractContext(config,machine.getDict(config.getState()));
+      for (auto & element : context)
+        contexts.emplace_back(torch::from_blob(element.data(), {(long)element.size()}, torch::TensorOptions(torch::kLong)).clone().to(NeuralNetworkImpl::device));
     } catch(std::exception & e)
     {
       util::myThrow(fmt::format("Failed to extract context : {}", e.what()));
     }
 
     int goldIndex = machine.getTransitionSet().getTransitionIndex(transition);
-    auto gold = torch::zeros(1, torch::TensorOptions(at::kLong).device(NeuralNetworkImpl::device));
+    auto gold = torch::zeros(1, torch::TensorOptions(torch::kLong).device(NeuralNetworkImpl::device));
     gold[0] = goldIndex;
 
+    for (auto & element : context)
       classes.emplace_back(gold);
 
     transition->apply(config);