public XBarGrammarProjection(BinaryGrammar bg, UnaryGrammar ug) {
Map<BinaryRule, BinaryRule> binaryRules = new HashMap<BinaryRule, BinaryRule>();
Map<UnaryRule, UnaryRule> unaryRules = new HashMap<UnaryRule, UnaryRule>();
sourceUG = ug;
sourceBG = bg;
sourceNumberer = Numberer.getGlobalNumberer(bg.stateSpace());
targetNumberer = Numberer.getGlobalNumberer(bg.stateSpace() + "-xbar");
projection = new int[sourceNumberer.total()];
scanStates(sourceNumberer, targetNumberer);
targetBG = new BinaryGrammar(targetNumberer.total(), bg.stateSpace() + "-xbar");
targetUG = new UnaryGrammar(targetNumberer.total());
for (Iterator<BinaryRule> brI = bg.iterator(); brI.hasNext(); ) {
BinaryRule rule = projectBinaryRule(brI.next());
Rule old = binaryRules.get(rule);
if (old == null || rule.score > old.score) {
binaryRules.put(rule, rule);
}
}
for (BinaryRule br : binaryRules.keySet()) {
targetBG.addRule(br);
// System.out.println("BR: "+targetNumberer.object(br.parent)+" ->
// "+targetNumberer.object(br.leftChild)+" "+targetNumberer.object(br.rightChild)+" %%
// "+br.score);
}
targetBG.splitRules();
for (int parent = 0; parent < sourceNumberer.total(); parent++) {
for (Iterator<UnaryRule> urI = ug.ruleIteratorByParent(parent); urI.hasNext(); ) {
UnaryRule sourceRule = urI.next();
UnaryRule rule = projectUnaryRule(sourceRule);
Rule old = unaryRules.get(rule);
if (old == null || rule.score > old.score) {
unaryRules.put(rule, rule);
}
/*
if (((UnaryRule)rule).child == targetNumberer.number("PRP") &&
((String)sourceNumberer.object(rule.parent)).charAt(0) == 'N') {
System.out.println("Source UR: "+sourceRule+" %% "+sourceRule.score);
System.out.println("Score of "+rule+"is now: "+((UnaryRule)unaryRules.get(rule)).score);
}
*/
}
}
for (UnaryRule ur : unaryRules.keySet()) {
targetUG.addRule(ur);
// System.out.println("UR: "+targetNumberer.object(ur.parent)+" ->
// "+targetNumberer.object(ur.child)+" %% "+ur.score);
}
targetUG.purgeRules();
System.out.println(
"Projected "
+ sourceNumberer.total()
+ " states to "
+ targetNumberer.total()
+ " states.");
}
public Object formResult() {
Set brs = new HashSet();
Set urs = new HashSet();
// scan each rule / history pair
int ruleCount = 0;
for (Iterator pairI = rulePairs.keySet().iterator(); pairI.hasNext(); ) {
if (ruleCount % 100 == 0) {
System.err.println("Rules multiplied: " + ruleCount);
}
ruleCount++;
Pair rulePair = (Pair) pairI.next();
Rule baseRule = (Rule) rulePair.first;
String baseLabel = (String) ruleToLabel.get(baseRule);
List history = (List) rulePair.second;
double totalProb = 0;
for (int depth = 1; depth <= HISTORY_DEPTH() && depth <= history.size(); depth++) {
List subHistory = history.subList(0, depth);
double c_label = labelPairs.getCount(new Pair(baseLabel, subHistory));
double c_rule = rulePairs.getCount(new Pair(baseRule, subHistory));
// System.out.println("Multiplying out "+baseRule+" with history "+subHistory);
// System.out.println("Count of "+baseLabel+" with "+subHistory+" is "+c_label);
// System.out.println("Count of "+baseRule+" with "+subHistory+" is "+c_rule );
double prob = (1.0 / HISTORY_DEPTH()) * (c_rule) / (c_label);
totalProb += prob;
for (int childDepth = 0; childDepth <= Math.min(HISTORY_DEPTH() - 1, depth); childDepth++) {
Rule rule = specifyRule(baseRule, subHistory, childDepth);
rule.score = (float) Math.log(totalProb);
// System.out.println("Created "+rule+" with score "+rule.score);
if (rule instanceof UnaryRule) {
urs.add(rule);
} else {
brs.add(rule);
}
}
}
}
System.out.println("Total states: " + stateNumberer.total());
BinaryGrammar bg = new BinaryGrammar(stateNumberer.total());
UnaryGrammar ug = new UnaryGrammar(stateNumberer.total());
for (Iterator brI = brs.iterator(); brI.hasNext(); ) {
BinaryRule br = (BinaryRule) brI.next();
bg.addRule(br);
}
for (Iterator urI = urs.iterator(); urI.hasNext(); ) {
UnaryRule ur = (UnaryRule) urI.next();
ug.addRule(ur);
}
return new Pair(ug, bg);
}