DeSR Dependency Parser

src/MeParser.cpp

/*
**  DeSR
**  src/MeParser.cpp
**  ----------------------------------------------------------------------
**  Copyright (c) 2005  Giuseppe Attardi (attardi@di.unipi.it).
**  ----------------------------------------------------------------------
**
**  This file is part of DeSR.
**
**  DeSR is free software; you can redistribute it and/or modify it
**  under the terms of the GNU General Public License, version 3,
**  as published by the Free Software Foundation.
**
**  DeSR is distributed in the hope that it will be useful,
**  but WITHOUT ANY WARRANTY; without even the implied warranty of
**  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
**  GNU General Public License for more details.
**
**  You should have received a copy of the GNU General Public License
**  along with this program.  If not, see <http://www.gnu.org/licenses/>.
**  ----------------------------------------------------------------------
*/


#ifdef _WIN32
#include "lib/strtok_r.h"
#endif

#include "conf/conf_int.h"
#include "Parser.h"
#include "EventStream.h"
#include "State.h"

// ME library
#include "GIS.h"
#include "LBFGS.h"

// standard
#include <math.h>

using namespace std;

namespace Parser {

IXE::conf<int>  iterations("MEiter", 60);

// define for using beam search
#define BEAM

struct MeParser : public Parser
{
  MeParser(char const* modelFile);

  void          train(SentenceReader* sentenceReader, char const* modelFile);

  Sentence*     parse(Sentence* sentence);

  void          revise(SentenceReader* sentenceReader, char const* actionFile = 0);

  Tanl::Classifier::MaxEnt      model;
};

Parser* MeParserFactory(char const* modelFile = 0)
{
  return new MeParser(modelFile);
}

REGISTER_PARSER(ME, MeParserFactory);

MeParser::MeParser(char const* modelFile) :
  Parser(model.PredIndex())
{
  if (!modelFile)
    return;                     // training
  ifstream ifs(modelFile);
  if (!ifs)
    throw IXE::FileError(string("Missing model file: ") + modelFile);
  // load header
  readHeader(ifs);
  model.load(ifs);
  // read entities
  info.load(ifs);
  ifs.close();
}

void MeParser::train(SentenceReader* sentenceReader, char const* modelFile)
{
  EventStream eventStream(sentenceReader, &info);
  Tanl::Classifier::LBFGS model(iterations, featureCutoff);
  model.verbose = verbose;
  model.read(eventStream);
  ofstream ofs(modelFile, ios::binary | ios::trunc);
  // dump configuration settings
  writeHeader(ofs);
  model.train();
  // cant do before train since outcomeLabels is created in train()
  model.writeHeader(ofs);
  model.writeData(ofs);
  // dump entities
  info.save(ofs);
}

#ifdef BEAM
// FIXME: this is duplicated in DlParser.cpp
static double addState(ParseState* s, vector<ParseState*>& states)
{
  int size = states.size();
  if (size == 0) {
    states.push_back(s);
    return s->lprob;
  }
  double worst = states[size-1]->lprob;
  if (size == beam && s->lprob < worst)
    return worst;
  TO_EACH (vector<ParseState*>, states, it)
    if (s->lprob > (*it)->lprob) {
      if (size == beam) {
        delete states.back();
        states.pop_back();
      }
      states.insert(it, s);
      return states.back()->lprob;
    }
  if (size < beam)
    states.push_back(s);
  return states.back()->lprob;
}
#endif

Sentence* MeParser::parse(Sentence* sentence)
{
  int numOutcomes = model.NumOutcomes();
  double params[numOutcomes];

# ifdef BEAM
  vector<ParseState*> currStates; currStates.reserve(beam);
  vector<ParseState*> nextStates; nextStates.reserve(beam);
  vector<ParseState*>* bestStates = &currStates;
  vector<ParseState*>* bestNextStates = &nextStates;
  ParseState* state = new ParseState(*sentence, &info, predIndex);
  addState(state, *bestStates);

  while (true) {
    int finished = 0;
    int numBest = bestStates->size();
    //int numNext = 0;
    double worstProb = -numeric_limits<double>::infinity();
    for (int i = 0; i < numBest; i++) {
      state = (*bestStates)[i];
      if (state->hasNext()) {
        Tanl::Classifier::Context& context = *state->next();
        model.estimate(context, params);
        for (int o = 0; o < numOutcomes; o++) {
          if (params[o] < 1e-4)
            continue;           // not worth considering
          double lprob = log(params[o]) + state->lprob;
          if (bestNextStates->size() == beam && lprob < worstProb)
            continue;           // not worth considering
          char const* outcome = model.OutcomeName(o);
          ParseState* next = state->transition(outcome);
          if (!next) {
            // dead end
            state->dispose();
            continue;
          }
          next->lprob = lprob;
          worstProb = addState(next, *bestNextStates);
        }
      } else {
        worstProb = addState(state, *bestNextStates);
        finished++;
      }
    }
    if (finished == numBest)
      break;
    // swap vectors
    vector<ParseState*>* tmp = bestStates;
    bestStates = bestNextStates;
    bestNextStates = tmp;
    bestNextStates->clear();
  }
  Sentence* s = (*bestStates)[0]->getSentence();
  return s;
# else
  ParseState* state = new ParseState(*sentence, &info, predIndex);

  while (state->hasNext()) {
    Tanl::Classifier::Context& context = *state->next();
    model.estimate(context, params);
    int best = model.BestOutcome(params);
    char const* outcome = model.OutcomeName(best);
    cerr << outcome << ' ' << params[best] << endl;
    ParseState* next = state->transition(outcome);
    if (!next)
      next = state->transition("S");
    //delete state;
    state = next;
  }
  Sentence* s = state->getSentence();
  delete state;
  return s;
# endif
}

void MeParser::revise(SentenceReader* sentenceReader, char const* actionFile)
{
  if (actionFile) {
    // read an action file
    ifstream ifs(actionFile);
    WordIndex predIndex;

    ReviseContextStream contextStream(sentenceReader, predIndex);

    char line[4000];
    while (contextStream.hasNext()) {
      ++contextStream.cur;
      ifs.getline(line, sizeof(line));
      char* next = line;
      char const* outcome = strtok_r(0, " \t", &next);
      contextStream.actions.push_back(outcome);
    }
  } else {
    int numOutcomes = model.NumOutcomes();
    double* params = new double[numOutcomes];
    int correct = 0;
    int wrong = 0;

    ReviseContextStream contextStream(sentenceReader, model.PredIndex());

    while (contextStream.hasNext()) {
      Tanl::Classifier::Context& context = *contextStream.next();
      model.estimate(context, params);
      char const* outcome = model.OutcomeName(model.BestOutcome(params));
      contextStream.actions.push_back(outcome);
    }
  }
}

} // namespace Parser

 

Copyright © 2005-2007 G. Attardi. Generated on 13 Aug 2009 by doxygen 1.5.7.1.