dep_treeler.h

Go to the documentation of this file.

//
//    FreeLing - Open Source Language Analyzers
//
//    Copyright (C) 2014   TALP Research Center
//                         Universitat Politecnica de Catalunya
//
//    This library is free software; you can redistribute it and/or
//    modify it under the terms of the GNU Affero General Public
//    License as published by the Free Software Foundation; either
//    version 3 of the License, or (at your option) any later version.
//
//    This library 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
//    Affero General Public License for more details.
//
//    You should have received a copy of the GNU Affero General Public
//    License along with this library; if not, write to the Free Software
//    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
//    contact: Lluis Padro (padro@lsi.upc.es)
//             TALP Research Center
//             despatx C6.212 - Campus Nord UPC
//             08034 Barcelona.  SPAIN
//


#ifndef _DEP_TREELER
#define _DEP_TREELER

#include <string>
#include <map>
#include <set>
#include <vector>

#include "freeling/windll.h"
#include "freeling/morfo/language.h"
#include "freeling/morfo/tagset.h"
#include "freeling/morfo/dependency_parser.h"

//#include "treeler/dep/dep-symbols.h"
//#include "treeler/control/script.h"
//#include "treeler/io/io-conll.h"
//#include "treeler/base/label.h"
//#include "treeler/control/models.h"

#include "treeler/dep/dependency_parser.h"
#include "treeler/srl/srl_parser.h"

namespace freeling {



class WINDLL dep_treeler : public freeling::dependency_parser {

 public:   
  dep_treeler(const std::wstring &);
  ~dep_treeler();

  void analyze(freeling::sentence &) const;

  using processor::analyze;
    
private:  
  //typedef treeler::control::Model<treeler::control::DEP1>::R DEP1_R;
  //typedef treeler::Label<DEP1_R> TreelerTree;

  treeler::dependency_parser *dp;
  treeler::srl_parser *srl;
  // tagset handler
  freeling::tagset *tags;

  // predicate detection configuration

  // given a synset, obtain predicate and argument structure
  std::map<std::string,map<std::wstring,treeler::srl::PossiblePredArgs> > predicates;
  // which PoS are always predicate, even if not in the files
  std::set<std::string> always_predicate;
  // arguments to expect for predicates not found in the files
  std::list<pair<std::string,std::string> > default_args;
  // predicate exceptions
  std::map<std::string,std::string> pred_exceptions;
 
  void FL2Treeler(const freeling::sentence& fl_sentence, treeler::dependency_parser::sentence &tl_sentence) const;
  void Treeler2FL(freeling::sentence &fl_sentence,
                  const treeler::dependency_parser::dep_vector &tl_tree,  
                  const treeler::srl_parser::pred_arg_set &tl_roles) const;

  freeling::dep_tree* build_dep_tree(int node_id, 
                                     const std::vector<std::list<int> > &sons, 
                                     const std::vector<std::string> &labels,
                                     std::map<int,freeling::depnode*> &depnods,
                                     freeling::sentence &fl_sentence) const;

  void load_options(const std::string &cfg, treeler::Options &opts);

  // compute predicates for SRL
  void load_predicate_files(const std::map<std::wstring,std::wstring> &);
  void compute_predicates(const treeler::srl_parser::basic_sentence &, const freeling::sentence &, 
                          const treeler::srl_parser::dep_vector &, treeler::srl::PossiblePreds &) const;
  bool is_pred_exception(const treeler::srl_parser::basic_sentence &, size_t, const treeler::srl_parser::dep_vector &) const;

};

}
#endif