Esempio n. 1
0
  // if survive, return true
  // best-deduction is always kept
  private boolean pruningEdge(HyperEdge dt, HGNode parent) {

    /**
     * TODO: theoretically, if an item is get called, then its best deduction should always be kept
     * even just by the threshold-checling. In reality, due to precision of Double, the
     * threshold-checking may not be perfect
     */
    if (dt != parent.bestHyperedge) { // best deduction should always survive if the Item is get
      // called
      // ### prune?
      if (shouldPruneHyperedge(dt, parent)) {
        return false; // early stop
      }
    }

    // ### still survive, recursive call all my ant-items
    if (null != dt.getTailNodes()) {
      for (HGNode ant_it : dt.getTailNodes()) {
        pruningNode(ant_it); // recursive call on each ant item, note: the ant_it will not be pruned
        // as I need it
      }
    }

    // ### if get to here, then survive; remember: if I survive, then my upper-item must survive
    numSurvivedEdges++;
    return true; // survive
  }
Esempio n. 2
0
  private boolean shouldPruneHyperedge(HyperEdge dt, HGNode parent) {

    // ### get merit
    double postLogProb = getEdgeUnormalizedPosteriorLogProb(dt, parent);

    if (dt.getRule() != null
        && dt.getRule().getOwner() == glueGrammarOwner
        && dt.getRule().getArity() == 2) { // specicial rule: S->S X
      // TODO
      return (postLogProb - this.bestLogProb < THRESHOLD_GLUE);
    } else {
      return (postLogProb - this.bestLogProb < THRESHOLD_GENERAL);
    }
  }
 private static int[] getNewSource(boolean isGlue, HyperEdge edge) {
   BilingualRule rule = (BilingualRule) edge.getRule();
   int[] english = rule.getEnglish();
   // if this is a unary abstract rule, just return null
   // TODO: except glue rules!
   if (english.length == 1 && english[0] < 0 && !isGlue) return null;
   int currNT = 1;
   int[] result = new int[english.length];
   for (int i = 0; i < english.length; i++) {
     int curr = english[i];
     if (!Vocabulary.nt(curr)) {
       result[i] = curr;
     } else {
       int index = -curr - 1;
       int label = getLabelWithSpan(edge.getAntNodes().get(index));
       result[i] = label * 2 - currNT;
       currNT++;
     }
   }
   // System.err.printf("source: %s\n", result);
   return result;
 }
 private BilingualRule getRuleWithSpans(HyperEdge edge, HGNode head) {
   Rule edgeRule = edge.getRule();
   // System.err.printf("EdgeRule: %s\n", edgeRule);
   if (!(edgeRule instanceof BilingualRule)) {
     // System.err.println("edge rule is not a bilingual rule");
     return null;
   }
   int headLabel = getLabelWithSpan(head);
   // System.err.printf("Head label: %s\n", headLabel);
   // if (edge.getAntNodes() != null) {
   // for (HGNode n : edge.getAntNodes())
   // System.err.printf("> %s\n", getLabelWithSpan(n));
   // }
   int[] source = getNewSource(nodeHasGoalSymbol(head), edge);
   // if this would be unary abstract, getNewSource will be null
   if (source == null) return null;
   int[] target = getNewTargetFromSource(source);
   BilingualRule result =
       new BilingualRule(
           headLabel, source, target, edgeRule.getFeatureScores(), edgeRule.getArity());
   // System.err.printf("new rule is %s\n", result);
   return result;
 }
Esempio n. 5
0
 public double finalTransitionLogP(HyperEdge edge, int spanStart, int spanEnd, int sentID) {
   return finalTransitionLogP(
       edge.getAntNodes().get(0), spanStart, spanEnd, edge.getSourcePath(), sentID);
 }
Esempio n. 6
0
 public double transitionLogP(HyperEdge edge, int spanStart, int spanEnd, int sentID) {
   return transitionLogP(
       edge.getRule(), edge.getAntNodes(), spanStart, spanEnd, edge.getSourcePath(), sentID);
 }