| /* |
| * 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; |
| } |
| |
| } |
