Skip to content
Snippets Groups Projects
Select Git revision
  • 5d625a17a64d3b4930902fd0c40ea03c02bac1a6
  • master default protected
2 results

accuracy.py

Blame
  • Decoder.cpp 3.33 KiB
    #include "Decoder.hpp"
    #include "util.hpp"
    #include "Error.hpp"
    
    Decoder::Decoder(TransitionMachine & tm, Config & config)
    : tm(tm), config(config)
    {
    }
    
    void Decoder::decode()
    {
      float entropyAccumulator = 0.0;
      int nbActionsInSequence = 0;
      bool justFlipped = false;
      Errors errors;
      errors.newSequence();
      while (!config.isFinal())
      {
        TransitionMachine::State * currentState = tm.getCurrentState();
        Classifier * classifier = currentState->classifier;
        config.setCurrentStateName(&currentState->name);
        Dict::currentClassifierName = classifier->name;
    
        if (ProgramParameters::debug)
        {
          config.printForDebug(stderr);
          fprintf(stderr, "State : \'%s\'\n", currentState->name.c_str());
        }
    
        auto weightedActions = classifier->weightActions(config);
    
        if (ProgramParameters::debug)
        {
          Classifier::printWeightedActions(stderr, weightedActions);
          fprintf(stderr, "\n");
        }
    
        std::string & predictedAction = weightedActions[0].second.second;
        Action * action = classifier->getAction(predictedAction);
    
        for(unsigned int i = 0; i < weightedActions.size(); i++)
        {
          predictedAction = weightedActions[i].second.second;
          action = classifier->getAction(predictedAction);
    
          if(weightedActions[i].first)
            break;
        }
    
        if(!action->appliable(config))
        {
          // First case the analysis is finished but without an empty stack
          if (config.head == (int)config.tapes[0].ref.size()-1)
          {
            while (!config.stackEmpty())
              config.stackPop();
            continue;
          }
          else
          {
            fprintf(stderr, "ERROR (%s) : action \'%s\' is not appliable. Aborting\n", ERRINFO, predictedAction.c_str());
            exit(1);
          }
        }
    
        if (classifier->needsTrain() && ProgramParameters::errorAnalysis && (classifier->name == ProgramParameters::classifierName || ProgramParameters::classifierName.empty()))
        {
          auto zeroCostActions = classifier->getZeroCostActions(config);
          std::string oAction = zeroCostActions[0];
          for (auto & s : zeroCostActions)
            if (action->name == s)
              oAction = s;
          errors.add({action->name, oAction, weightedActions});
        }
    
        action->apply(config);
    
        TransitionMachine::Transition * transition = tm.getTransition(predictedAction);
        tm.takeTransition(transition);
    
        config.moveHead(transition->headMvt);
    
        float entropy = Classifier::computeEntropy(weightedActions);
        config.addToEntropyHistory(entropy);
    
        nbActionsInSequence++;
        entropyAccumulator += entropy;
    
        if (ProgramParameters::printEntropy || ProgramParameters::errorAnalysis)
        {
          if (config.head >= 1 && config.getTape(ProgramParameters::sequenceDelimiterTape)[config.head-1] != ProgramParameters::sequenceDelimiter)
            justFlipped = false;
    
          if ((config.head >= 1 && config.getTape(ProgramParameters::sequenceDelimiterTape)[config.head-1] == ProgramParameters::sequenceDelimiter && !justFlipped))
          {
            justFlipped = true;
            errors.newSequence();
            entropyAccumulator /= nbActionsInSequence;
            nbActionsInSequence = 0;
            if (ProgramParameters::printEntropy)
              fprintf(stderr, "Entropy : %.2f\n", entropyAccumulator);
            entropyAccumulator = 0.0;
          }
        }
    
      }
    
      if (ProgramParameters::errorAnalysis)
        errors.printStats();
      else
        config.printAsOutput(stdout);
    }