| /* |
| * 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.kep; |
| |
| import org.apache.uima.ruta.textruler.core.TextRulerBasicLearner; |
| import org.apache.uima.ruta.textruler.core.TextRulerMultiSlotRule; |
| import org.apache.uima.ruta.textruler.core.TextRulerRuleItem; |
| import org.apache.uima.ruta.textruler.core.TextRulerRulePattern; |
| import org.apache.uima.ruta.textruler.core.TextRulerSlotPattern; |
| import org.apache.uima.ruta.textruler.core.TextRulerTarget; |
| |
| public class KEPRule extends TextRulerMultiSlotRule { |
| |
| private boolean isCorrectionRule = false; |
| |
| public KEPRule(KEPRule copyFrom) { |
| super(copyFrom); |
| this.isCorrectionRule = copyFrom.isCorrectionRule; |
| } |
| |
| public KEPRule(TextRulerBasicLearner parentAlgorithm, TextRulerTarget target) { |
| super(parentAlgorithm, target); |
| slotPatterns.add(new TextRulerSlotPattern()); |
| } |
| |
| @Override |
| public KEPRule copy() { |
| return new KEPRule(this); |
| } |
| |
| public double getLaplacian() { |
| int e = 0; |
| int n = 0; |
| |
| if (coveringStatistics != null) { |
| e = coveringStatistics.getCoveredNegativesCount(); |
| n = coveringStatistics.getCoveredNegativesCount() |
| + coveringStatistics.getCoveredPositivesCount(); |
| } |
| return ((double) e + 1) / ((double) n + 1); |
| } |
| |
| public boolean containsTerm(KEPRuleItem term) { |
| for (TextRulerSlotPattern sp : slotPatterns) { |
| for (TextRulerRuleItem i : sp.preFillerPattern) |
| if (i.equals(term)) |
| return true; |
| for (TextRulerRuleItem i : sp.fillerPattern) |
| if (i.equals(term)) |
| return true; |
| for (TextRulerRuleItem i : sp.postFillerPattern) |
| if (i.equals(term)) |
| return true; |
| } |
| return false; |
| } |
| |
| public KEPRuleItem searchNeighborOfItem(KEPRuleItem item, boolean goToLeft) { |
| int slotIndex = -1; |
| int patternIndex = -1; |
| int slotI = 0; |
| for (TextRulerSlotPattern sp : slotPatterns) { |
| for (TextRulerRuleItem it : sp.preFillerPattern) { |
| if (it == item) { |
| slotIndex = slotI; |
| patternIndex = 0; // 0=preFiller |
| break; |
| } |
| } |
| if (slotIndex < 0) { |
| for (TextRulerRuleItem it : sp.fillerPattern) { |
| if (it == item) { |
| slotIndex = slotI; |
| patternIndex = 1; // 1=filler |
| break; |
| } |
| } |
| } |
| if (slotIndex < 0) { |
| for (TextRulerRuleItem it : sp.postFillerPattern) { |
| if (it == item) { |
| slotIndex = slotI; |
| patternIndex = 2; // 2=postFiller |
| break; |
| } |
| } |
| } |
| if (slotIndex >= 0) { |
| break; |
| } |
| } |
| if (slotIndex < 0) // we didn't even find the item in our rule ?! how |
| // can this happen ? |
| return null; |
| |
| TextRulerRulePattern currentPattern = getPattern(slotIndex, patternIndex); |
| while (currentPattern != null) { |
| int startIndex = currentPattern.indexOf(item); // this is only >= 0 |
| // for the first |
| // pattern... |
| if (!goToLeft) // walk forward... |
| { |
| int startSearchFromIndex = startIndex + 1; |
| if (startSearchFromIndex < currentPattern.size()) |
| return (KEPRuleItem) currentPattern.get(startSearchFromIndex); |
| else // skip to next pattern |
| { |
| patternIndex++; |
| if (patternIndex > 2) { |
| patternIndex = 0; |
| slotIndex++; |
| if (slotIndex >= slotPatterns.size()) |
| return null; // not found! |
| } |
| currentPattern = getPattern(slotIndex, patternIndex); |
| } |
| } else { |
| int startSearchFromIndex = startIndex >= 0 ? startIndex - 1 : currentPattern.size() - 1; |
| if (startSearchFromIndex >= 0 && currentPattern.size() > 0) |
| return (KEPRuleItem) currentPattern.get(startSearchFromIndex); |
| else // skip to previous pattern |
| { |
| patternIndex--; |
| if (patternIndex < 0) { |
| patternIndex = 2; |
| slotIndex--; |
| if (slotIndex < 0) |
| return null; // not found! |
| } |
| currentPattern = getPattern(slotIndex, patternIndex); |
| } |
| } |
| } |
| return null; |
| } |
| |
| private TextRulerRulePattern getPattern(int slotIndex, int patternIndex) { |
| TextRulerSlotPattern sp = slotPatterns.get(slotIndex); |
| if (patternIndex == 0) |
| return sp.preFillerPattern; |
| else if (patternIndex == 1) |
| return sp.fillerPattern; |
| else if (patternIndex == 2) |
| return sp.postFillerPattern; |
| else |
| return null; |
| } |
| |
| public KEPRule addPostFillerItem(KEPRuleItem item) { |
| this.getPostFiller().add(item); |
| setNeedsCompile(true); |
| return this; |
| } |
| |
| public KEPRule addInFillerItem(KEPRuleItem item) { |
| this.getInFiller().add(item); |
| setNeedsCompile(true); |
| return this; |
| } |
| |
| public KEPRule addPreFillerItem(KEPRuleItem item) { |
| this.getPreFiller().add(0, item); |
| setNeedsCompile(true); |
| return this; |
| } |
| |
| public TextRulerRulePattern getPreFiller() { |
| return this.slotPatterns.get(0).preFillerPattern; |
| } |
| |
| public void setPreFiller(TextRulerRulePattern preFiller) { |
| this.slotPatterns.get(0).preFillerPattern = preFiller; |
| setNeedsCompile(true); |
| } |
| |
| public TextRulerRulePattern getInFiller() { |
| return this.slotPatterns.get(0).fillerPattern; |
| } |
| |
| public void setInFiller(TextRulerRulePattern inFiller) { |
| this.slotPatterns.get(0).fillerPattern = inFiller; |
| setNeedsCompile(true); |
| } |
| |
| public TextRulerRulePattern getPostFiller() { |
| return this.slotPatterns.get(0).postFillerPattern; |
| } |
| |
| public void setPostFiller(TextRulerRulePattern postFiller) { |
| this.slotPatterns.get(0).postFillerPattern = postFiller; |
| setNeedsCompile(true); |
| } |
| |
| public KEPRule setCorrectionRule(boolean isCorrectionRule) { |
| this.isCorrectionRule = isCorrectionRule; |
| setNeedsCompile(true); |
| return this; |
| } |
| |
| public boolean isCorrectionRule() { |
| return isCorrectionRule; |
| } |
| |
| public TextRulerTarget getTarget() { |
| return this.target; |
| } |
| |
| public void setTarget(TextRulerTarget target) { |
| this.target = target; |
| setNeedsCompile(true); |
| } |
| |
| public boolean coversSameExamples(KEPRule otherRule) { |
| if (otherRule.getCoveringStatistics().getCoveredPositivesCount() != this |
| .getCoveringStatistics().getCoveredPositivesCount() |
| || !otherRule.getCoveringStatistics().getCoveredPositiveExamples().containsAll( |
| this.getCoveringStatistics().getCoveredPositiveExamples())) |
| return false; |
| return true; |
| } |
| } |