Exemplo n.º 1
0
 /** Returns the features for the highest-score current parse with semantics that equal sem. */
 public HashVector getFeats(Exp sem) {
   HashVector result = new HashVector();
   List<ParseResult> pr = findBestParses(allParses, sem);
   for (ParseResult p : pr) {
     p.getFeats(result);
   }
   if (pr.size() > 1) result.divideBy(pr.size());
   return result;
 }
Exemplo n.º 2
0
 private List<ParseResult> removeRepeats(List<ParseResult> all) {
   System.out.println("----------------------- all.size equals to --------------" + all.size());
   List<ParseResult> bestList = new LinkedList<ParseResult>();
   for (int i = 0; i < all.size(); i++) {
     ParseResult e_i = all.get(i);
     boolean best = true;
     for (int j = i + 1; j < all.size(); j++) {
       ParseResult e_j = all.get(j);
       if (e_i.getExp().equals(e_j.getExp()) && e_i.getScore() <= e_j.getScore()) {
         best = false;
         break;
       }
     }
     if (best) bestList.add(e_i);
   }
   return bestList;
 }
Exemplo n.º 3
0
  /**
   * Return a parsed chart of the input, pruning each cell to pruneN entries.
   *
   * <p>Uses the CKY algorithm.
   */
  public Chart parse(String input, Exp pruningSem, boolean computeInside) {

    List tokens = tokenize(input);
    Globals.tokens = tokens;
    Globals.lastWordIndex = tokens.size() - 1;

    // create a chart and add the input words
    Chart chart = new Chart(tokens);

    if (pruningSem != null) {
      chart.setPruningSem(pruningSem);
    }

    // initialize cells list with the lexical rule
    lexicon.addCells(chart);
    if (tempLex != null) {
      tempLex.addCells(chart);
    }

    int size = tokens.size();
    List temp = new LinkedList();
    // now do the CKY parsing:
    for (int len = 1; len < size; len++) {
      for (int begin = 0; begin < size - len; begin++) {
        for (int split = 0; split < len; split++) {
          temp.clear();
          Iterator leftIter = chart.getCellsIterator(begin, begin + split);
          while (leftIter.hasNext()) {
            Cell left = (Cell) leftIter.next();
            Iterator rightIter = chart.getCellsIterator(begin + split + 1, begin + len);
            while (rightIter.hasNext()) {
              Cell right = (Cell) rightIter.next();
              Iterator rules = binaryRules.iterator();
              while (rules.hasNext()) {
                ((BinaryParseRule) rules.next()).newCellsFrom(left, right, temp);
              }
            }
          }
          chart.addAll(temp);
        }
      }
    }

    //		System.out.println("fffffffffffffffff");
    //		for(ParseResult pr : chart.getParseResults()){
    //			System.out.println(pr + "#" + pr.getScore());
    //		}
    //		System.out.println("fffffffffffffffff");

    chart.pruneParseResults(pruneN);
    // store the parse results
    allParses = chart.getParseResults();

    allParses = removeRepeats(allParses);

    // find best parses for test and for generating
    // new lexical items.

    bestParses = findBestParses(allParses);

    //		System.out.println("&&&&&&&&&&&&&&&&&&&&&");
    //		System.out.println(input + " " + pruningSem);
    //		for (int len = size-1; len>=0; len--){
    //			for (int begin = 0; begin<size-len; begin++){
    //				Iterator i = chart.getCellsIterator(begin,begin+len);
    //				while (i.hasNext()){
    //					Cell c = (Cell)i.next();
    //					System.out.println("len = " + len + " begin = " + begin + "\n" + c.lex);
    //				}
    //			}
    //		}
    //		System.out.println("&&&&&&&&&&&&&&&&&&&&&");

    return chart;
  }
Exemplo n.º 4
0
 public ParseResult bestParse(Exp sem) {
   List<ParseResult> result = findBestParses(allParses, sem);
   if (result.size() > 0) return result.get(0);
   return null;
 }
Exemplo n.º 5
0
 /**
  * Expands the lexicon and updates the weight vector and feature indices. Does not add entries
  * that are already present.
  */
 public void addLexEntries(List lex) {
   for (int i = 0; i < lex.size(); i++) {
     addLexEntry((LexEntry) lex.get(i));
   }
 }