/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.uima.ruta.textruler.learner.lp2;
import java.io.File;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Set;
import org.apache.uima.cas.CAS;
import org.apache.uima.cas.Type;
import org.apache.uima.cas.TypeSystem;
import org.apache.uima.cas.text.AnnotationFS;
import org.apache.uima.ruta.engine.RutaEngine;
import org.apache.uima.ruta.textruler.TextRulerPlugin;
import org.apache.uima.ruta.textruler.core.TextRulerAnnotation;
import org.apache.uima.ruta.textruler.core.TextRulerExample;
import org.apache.uima.ruta.textruler.core.TextRulerRule;
import org.apache.uima.ruta.textruler.core.TextRulerRuleItem;
import org.apache.uima.ruta.textruler.core.TextRulerRulePattern;
import org.apache.uima.ruta.textruler.core.TextRulerTarget;
import org.apache.uima.ruta.textruler.core.TextRulerTarget.MLTargetType;
import org.apache.uima.ruta.textruler.core.TextRulerToolkit;
import org.apache.uima.ruta.textruler.extension.TextRulerLearnerDelegate;
import org.apache.uima.ruta.textruler.learner.lp2.LP2RuleItem.MLLP2ContextConstraint;
import org.apache.uima.ruta.textruler.learner.lp2.LP2RuleItem.MLLP2OtherConstraint;
import org.apache.uima.util.FileUtils;
public class NaiveLP2 extends BasicLP2 {
public NaiveLP2(String inputDir, String prePropTMFile, String tmpDir, String[] slotNames,
Set<String> filterSet, boolean skip, TextRulerLearnerDelegate delegate) {
super(inputDir, prePropTMFile, tmpDir, slotNames, filterSet, skip, delegate);
}
public static final boolean SAVE_DEBUG_INFO_IN_TEMPFOLDER = false;
@Override
protected void induceRulesFromExample(TextRulerExample e, int roundNumber) {
LP2Rule baseRule = createInitialRuleForPositiveExample(e);
List<LP2Rule> genRules = generalizeRule(baseRule);
if (shouldAbort())
return;
List<LP2Rule> test = new ArrayList<LP2Rule>();
// int i=1;
// for (LP2Rule newRule : genRules)
// {
// if (shouldAbort())
// return;
// sendStatusUpdateToDelegate("Round "+roundNumber+" - Testing proposed generalization "+i+"/"+(genRules.size())+
// " - uncovered examples: "+
// (examples.size()-coveredExamples.size() + " / "+examples.size()),
// TextRulerLearnerState.ML_RUNNING, false);
// i++;
// testRuleOnDocumentSet(newRule, exampleDocuments);
//
// checkAndHandleNewRule(newRule);
//
// if (TextRulerToolkit.DEBUG)
// test.add(newRule);
// }
// new cache and testCAS optimized rule testing:
sendStatusUpdateToDelegate(
"Round " + roundNumber + " - Testing " + (genRules.size())
+ "generalizations... - uncovered examples: "
+ (examples.size() - coveredExamples.size() + " / " + examples.size()),
TextRulerLearnerState.ML_RUNNING, false);
testRulesOnDocumentSet(new ArrayList<TextRulerRule>(genRules), exampleDocuments);
for (LP2Rule newRule : genRules) {
checkAndHandleNewRule(newRule);
if (TextRulerToolkit.DEBUG)
test.add(newRule);
}
if (TextRulerToolkit.DEBUG && SAVE_DEBUG_INFO_IN_TEMPFOLDER) {
Collections.sort(test, new Comparator<LP2Rule>() {
public int compare(LP2Rule o1, LP2Rule o2) {
return o1.getRuleString().compareTo(o2.getRuleString());
}
});
String startend = e.getTarget().type == MLTargetType.SINGLE_LEFT_BOUNDARY ? "left_"
: "right_";
File file = new File(tempDirectory() + startend + "generalizations" + roundNumber + RutaEngine.SCRIPT_FILE_EXTENSION);
StringBuffer str = new StringBuffer();
for (TextRulerRule rule : test) {
str.append(rule.getCoveringStatistics() + "\t\t" + rule.getRuleString() + "\n");
}
try {
FileUtils.saveString2File(str.toString(), file);
} catch (Exception ex) {
TextRulerPlugin.error(ex);
}
}
}
protected void checkAndHandleNewRule(LP2Rule rule) {
boolean tooFewPositives = rule.getCoveringStatistics().getCoveredPositivesCount() < minCoveredPositives;
boolean tooManyErrors = rule.getErrorRate() > maxErrorThreshold;
boolean isBestRule = !(tooFewPositives || tooManyErrors);
if (TextRulerToolkit.DEBUG && SAVE_DEBUG_INFO_IN_TEMPFOLDER)
TextRulerToolkit.appendStringToFile(tempDirectory() + "bestcandidates"+RutaEngine.SCRIPT_FILE_EXTENSION,
rule.getRuleString() + "\n");
if (isBestRule) {
currentBestRules.add(rule);
currentBestRules.removeSubsumedRules();
currentBestRules.cutToMaxSize();
} else if (!tooFewPositives) {
// test in context
// in our TM representation, we simply can add a NEAR condition in
// the MARKing rule item and retest it on the
// corpus. we should do that for all kinds of tags we have, but
// currently we only do it for the corresponding opening/closing
// tag, since we do not have any information about other slots yet!
// // TODO use all other slot tags! (see optimized version as well)
if (true) {
rule = rule.copy();
LP2RuleItem item = rule.getMarkingRuleItem();
// TextRulerToolkit.log("CONTEXTUAL RULE CANDIDATE: "+rule.getRuleString()+" ; "+rule.getCoveringStatistics());
item.setContextConstraint(new MLLP2ContextConstraint(slotMaximumTokenCountMap.get(rule
.getTarget().getSingleSlotRawTypeName()), rule));
rule.setIsContextualRule(true);
rule.setNeedsCompile(true);
if (TextRulerToolkit.DEBUG && SAVE_DEBUG_INFO_IN_TEMPFOLDER)
TextRulerToolkit.appendStringToFile(tempDirectory() + "ctxcandidates"+RutaEngine.SCRIPT_FILE_EXTENSION,
rule.getRuleString());
testRuleOnDocumentSet(rule, exampleDocuments); // not very
// fast... but
// works!
boolean ctxTooFewPositives = rule.getCoveringStatistics().getCoveredPositivesCount() < minCoveredPositives;
boolean ctxTooManyErrors = rule.getErrorRate() > maxErrorThreshold;
boolean isGoodContextRule = !(ctxTooFewPositives || ctxTooManyErrors);
if (isGoodContextRule) {
currentContextualRules.add(rule);
currentContextualRules.removeSubsumedRules();
currentContextualRules.cutToMaxSize();
}
}
}
}
protected List<LP2Rule> generalizeRule(LP2Rule baseRule) {
List<LP2Rule> result = new ArrayList<LP2Rule>();
TextRulerRulePattern rulePattern = new TextRulerRulePattern();
TextRulerRulePattern prePattern = baseRule.getPreFillerPattern();
for (int i = prePattern.size() - 1; i >= 0; i--) // we have to reverse
// the order again!
{
rulePattern.add(prePattern.get(i));
}
rulePattern.addAll(baseRule.getPostFillerPattern());
recursiveGeneralizeRule(baseRule, rulePattern, new TextRulerRulePattern(), result);
TextRulerToolkit.log("GENERALIZATIONS: " + result.size());
for (LP2Rule r : result)
removeOutermostWildCardItemsFromRule(r);
// for (LP2Rule r : result)
// {
// TextRulerToolkit.log("NEWRULE = "+r.getRuleString());
// }
return result;
}
protected LP2Rule createInitialRuleForPositiveExample(TextRulerExample example) {
TextRulerTarget target = example.getTarget();
LP2Rule rule = new LP2Rule(this, example.getTarget());
CAS docCas = example.getDocumentCAS();
TextRulerAnnotation exampleAnnotation = example.getAnnotation();
TypeSystem ts = docCas.getTypeSystem();
Type tokensRootType = ts.getType(TextRulerToolkit.RUTA_ANY_TYPE_NAME);
int thePosition = target.type == MLTargetType.SINGLE_LEFT_BOUNDARY ? exampleAnnotation
.getBegin() : exampleAnnotation.getEnd();
List<AnnotationFS> leftContext = TextRulerToolkit.getAnnotationsBeforePosition(docCas,
thePosition, windowSize,
TextRulerToolkit.getFilterSetWithSlotNames(slotNames, filterSet), tokensRootType);
List<AnnotationFS> rightContext = TextRulerToolkit.getAnnotationsAfterPosition(docCas,
thePosition, windowSize,
TextRulerToolkit.getFilterSetWithSlotNames(slotNames, filterSet), tokensRootType);
// the left context has to be reversed since we get the arrayList from
// the slot's point of view!
for (int i = leftContext.size() - 1; i >= 0; i--) {
TextRulerAnnotation annot = new TextRulerAnnotation(leftContext.get(i), example.getDocument());
LP2RuleItem item = new LP2RuleItem();
item.setWordConstraint(annot);
if (item.getWordConstraint().isRegExpConstraint())
item.addOtherConstraint(new MLLP2OtherConstraint(annot, annot));
rule.addPreFillerItem(item);
}
for (AnnotationFS afs : rightContext) {
TextRulerAnnotation annot = new TextRulerAnnotation(afs, example.getDocument());
LP2RuleItem item = new LP2RuleItem();
item.setWordConstraint(annot);
if (item.getWordConstraint().isRegExpConstraint())
item.addOtherConstraint(new MLLP2OtherConstraint(annot, annot));
rule.addPostFillerItem(item);
}
TextRulerToolkit.log("INITIAL RULE: " + rule.getRuleString());
return rule;
}
protected void recursiveGeneralizeRule(LP2Rule baseRule, TextRulerRulePattern allItems,
TextRulerRulePattern currentPattern, List<LP2Rule> resultList) {
if (currentPattern.size() == allItems.size()) {
// create new Rule
LP2Rule newRule = new LP2Rule(this, baseRule.getTarget());
int preCount = baseRule.getPreFillerPattern().size();
for (int i = 0; i < currentPattern.size(); i++) {
if (i < preCount)
newRule.addPreFillerItem(currentPattern.get(i));
else
newRule.addPostFillerItem(currentPattern.get(i));
}
// TextRulerToolkit.log("GEN: "+newRule.getRuleString());
if (newRule.totalInnerConstraintCount() > 0) // skip the ANY ANY ANY
// ANY... rule ! this
// makes no sense in no
// application!!
resultList.add(newRule);
} else {
int index = currentPattern.size();
TextRulerRuleItem baseItem = allItems.get(index);
List<TextRulerRuleItem> itemGeneralizations = generalizeRuleItem((LP2RuleItem) baseItem);
for (TextRulerRuleItem newItem : itemGeneralizations) {
currentPattern.add(newItem);
recursiveGeneralizeRule(baseRule, allItems, currentPattern, resultList);
currentPattern.remove(currentPattern.size() - 1);
}
}
}
protected void recursiveGeneralizeRuleItem(LP2RuleItem baseItem,
List<MLLP2OtherConstraint> otherConstraints, int currentConstraintIndex,
List<MLLP2OtherConstraint> currentConstraintTuple, List<TextRulerRuleItem> result) {
if (currentConstraintIndex > otherConstraints.size() - 1) {
LP2RuleItem newItem;
newItem = new LP2RuleItem();
for (MLLP2OtherConstraint c : currentConstraintTuple)
newItem.addOtherConstraint(c.copy());
result.add(newItem);
} else {
MLLP2OtherConstraint currentConstraint = otherConstraints.get(currentConstraintIndex);
// recurse WITH and WITHOUT this key:
recursiveGeneralizeRuleItem(baseItem, otherConstraints, currentConstraintIndex + 1,
currentConstraintTuple, result);
currentConstraintTuple.add(currentConstraint);
recursiveGeneralizeRuleItem(baseItem, otherConstraints, currentConstraintIndex + 1,
currentConstraintTuple, result);
currentConstraintTuple.remove(currentConstraintTuple.size() - 1);
}
}
protected List<TextRulerRuleItem> generalizeRuleItem(LP2RuleItem baseItem) {
List<TextRulerRuleItem> result = new ArrayList<TextRulerRuleItem>();
// one with word constraint
if (baseItem.getWordConstraint() != null) {
LP2RuleItem newItem = new LP2RuleItem();
newItem.setWordConstraint(baseItem.getWordConstraint().copy());
result.add(newItem);
}
// all other combinations without word constraint
// List<String> keys = new
// ArrayList<String>(baseItem.getOtherConstraints().keySet());
List<MLLP2OtherConstraint> constraints = baseItem.getOtherConstraints();
recursiveGeneralizeRuleItem(baseItem, constraints, 0, new ArrayList<MLLP2OtherConstraint>(),
result);
return result;
}
protected void removeOutermostWildCardItemsFromRule(LP2Rule rule) {
while (true) {
LP2RuleItem item = (LP2RuleItem) rule.getOutermostPreFillerItem();
if (item == null) // no more items left
break;
// if this rule is a RIGHT BOUNDARY rule, we must not remove the
// last remaining pre filler item,
// since this is used for marking the SLOT END BOUNDARY (= RIGHT
// BOUNDARY)
if ((rule.getTarget().type == MLTargetType.SINGLE_RIGHT_BOUNDARY)
&& (rule.getPreFillerPattern().size() == 1))
break;
if (item.totalConstraintCount() == 0)
rule.removeOutermostPreFillerItem();
else
break;
}
while (true) {
LP2RuleItem item = (LP2RuleItem) rule.getOutermostPostFillerItem();
if (item == null) // no more items left
break;
// if this rule is a LEFT BOUNDARY rule, we must not remove the last
// remaining post filler item,
// since this is used for marking the SLOT START BOUNDARY (= LEFT
// BOUNDARY)
if ((rule.getTarget().type == MLTargetType.SINGLE_LEFT_BOUNDARY)
&& (rule.getPostFillerPattern().size() == 1))
break;
if (item.totalConstraintCount() == 0)
rule.removeOutermostPostFillerItem();
else
break;
}
}
@Override
public boolean collectNegativeCoveredInstancesWhenTesting() {
return false;
}
}