OPENNLP-758 Applied clean up patch. Thanks to Anthony Beylerian for providing a patch.
diff --git a/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/Constants.java b/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/Constants.java
index 9909c70..e5a0c38 100644
--- a/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/Constants.java
+++ b/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/Constants.java
@@ -22,6 +22,8 @@
import java.util.ArrayList;
import java.util.Arrays;
+import opennlp.tools.disambiguator.lesk.Lesk;
+import net.sf.extjwnl.JWNLException;
import net.sf.extjwnl.data.POS;
public class Constants {
@@ -125,22 +127,62 @@
"you're", "yours", "yourself", "yourselves", "you've", "zero"));
// Print a text in the console
+ public static void printResults(WSDisambiguator disambiguator,
+ String[] results) {
+
+ if (results != null) {
+
+ if (disambiguator instanceof Lesk) {
+ POS pos;
+ long offset;
+ double score;
+ String[] parts;
+
+ for (String result : results) {
+ parts = result.split("@");
+ pos = POS.getPOSForKey(parts[0]);
+ offset = Long.parseLong(parts[1]);
+ score = Double.parseDouble(parts[2]);
+ try {
+ Constants.print("score : " + score + " for : "
+ + Loader.getDictionary().getSynsetAt(pos, offset).getGloss());
+ } catch (JWNLException e) {
+ e.printStackTrace();
+ }
+ }
+ }
+ }
+
+ }
+
public static void print(Object in) {
- System.out.println(in);
+ if (in == null) {
+ System.out.println("object is null");
+ } else {
+ System.out.println(in);
+ }
}
public static void print(Object[] array) {
- System.out.println(Arrays.asList(array));
+ if (array == null) {
+ System.out.println("object is null");
+ } else {
+ System.out.println(Arrays.asList(array));
+ }
}
public static void print(Object[][] array) {
- System.out.print("[");
- for (int i = 0; i < array.length; i++) {
- print(array[i]);
- if (i != array.length - 1) {
- System.out.print("\n");
+ if (array == null) {
+ System.out.println("object is null");
+ } else {
+ System.out.print("[");
+ for (int i = 0; i < array.length; i++) {
+ print(array[i]);
+ if (i != array.length - 1) {
+ System.out.print("\n");
+ }
+ print("]");
}
- print("]");
}
}
@@ -169,6 +211,15 @@
}
+ public static boolean isRelevant(String posTag) {
+ return getPOS(posTag) != null;
+ }
+
+ public static boolean isRelevant(POS pos) {
+ return pos.equals(POS.ADJECTIVE) || pos.equals(POS.ADVERB)
+ || pos.equals(POS.NOUN) || pos.equals(POS.VERB);
+ }
+
// Check whether a list of arrays contains an array
public static boolean belongsTo(String[] array, ArrayList<String[]> fullList) {
for (String[] refArray : fullList) {
@@ -196,5 +247,4 @@
return true;
}
-
}
diff --git a/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/DataExtractor.java b/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/DataExtractor.java
index 0161504..1ad6bad 100644
--- a/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/DataExtractor.java
+++ b/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/DataExtractor.java
@@ -41,10 +41,6 @@
public class DataExtractor {
- /**
- * Constructor
- */
-
public DataExtractor() {
super();
}
@@ -52,7 +48,6 @@
/**
* Extract the dictionary from the dictionary XML file and map the senses
*/
-
private ArrayList<DictionaryInstance> extractDictionary(String xmlLocation) {
ArrayList<DictionaryInstance> dictionary = new ArrayList<DictionaryInstance>();
@@ -283,9 +278,9 @@
* Extract the training instances from the training/test set File
*/
- public HashMap<Integer, WTDIMS> extractWSDInstances(String xmlDataSet) {
+ public ArrayList<WTDIMS> extractWSDInstances(String xmlDataSet) {
- HashMap<Integer, WTDIMS> setInstances = new HashMap<Integer, WTDIMS>();
+ ArrayList<WTDIMS> setInstances = new ArrayList<WTDIMS>();
try {
@@ -298,8 +293,6 @@
NodeList lexelts = doc.getElementsByTagName("lexelt");
- int index = 0;
-
for (int i = 0; i < lexelts.getLength(); i++) {
Node nLexelt = lexelts.item(i);
@@ -371,16 +364,12 @@
WTDIMS wordToDisambiguate = new WTDIMS(word, answers, sentence,
rawWord);
- setInstances.put(index, wordToDisambiguate);
- index++;
+ setInstances.add(wordToDisambiguate);
// System.out.print(index + "\t");
// System.out.println(wordToDisambiguate.toString());
}
-
}
-
}
-
}
} catch (Exception e) {
@@ -390,5 +379,4 @@
return setInstances;
}
-
}
diff --git a/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/DictionaryInstance.java b/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/DictionaryInstance.java
index e53ffa8..ae694f7 100644
--- a/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/DictionaryInstance.java
+++ b/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/DictionaryInstance.java
@@ -20,8 +20,7 @@
package opennlp.tools.disambiguator;
public class DictionaryInstance {
-
-
+
protected int index;
protected String word;
@@ -31,7 +30,6 @@
protected String[] synset;
protected String gloss;
-
public DictionaryInstance(int index, String word, String id, String source,
String[] synset, String gloss) {
super();
@@ -43,6 +41,10 @@
this.gloss = gloss;
}
+ /**
+ * Getters and Setters
+ */
+
public int getIndex() {
return index;
}
diff --git a/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/FeaturesExtractor.java b/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/FeaturesExtractor.java
index abcff6c..40c1cbc 100644
--- a/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/FeaturesExtractor.java
+++ b/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/FeaturesExtractor.java
@@ -20,8 +20,6 @@
package opennlp.tools.disambiguator;
-
-
import java.util.ArrayList;
import opennlp.tools.disambiguator.ims.WTDIMS;
@@ -44,8 +42,6 @@
* Collocations: it requires one parameter: "the n-gram"
*
*/
-
- // private methods
private String[] extractPosOfSurroundingWords(String[] sentence,
int wordIndex, int windowSize) {
@@ -94,7 +90,7 @@
private String[] extractLocalCollocations(String[] sentence, int wordIndex,
int ngram) {
- /*
+ /**
* Here the author used only 11 features of this type. the range was set to
* 3 (bigrams extracted in a way that they are at max separated by 1 word).
*/
@@ -124,6 +120,7 @@
return res;
}
+ // public method
/**
* This method generates the different set of features related to the IMS
* approach and store them in the corresponding attributes of the WTDIMS
diff --git a/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/Node.java b/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/Node.java
index 8481d0c..cb1eccc 100644
--- a/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/Node.java
+++ b/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/Node.java
@@ -31,7 +31,6 @@
/**
* Convenience class to access some features.
*/
-
public class Node {
public Synset parent;
@@ -69,6 +68,10 @@
public String getSense() {
return this.synset.getGloss().toString();
}
+
+ public long getSenseID() {
+ return this.synset.getOffset();
+ }
public void setHypernyms() {
// PointerUtils pointerUtils = PointerUtils.get();
@@ -168,5 +171,4 @@
public ArrayList<WordPOS> getSynonyms() {
return synonyms;
}
-
}
diff --git a/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/WSDParameters.java b/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/WSDParameters.java
new file mode 100644
index 0000000..a08df71
--- /dev/null
+++ b/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/WSDParameters.java
@@ -0,0 +1,50 @@
+/*
+ * 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 opennlp.tools.disambiguator;
+
+/**
+ * Disambiguation Parameters
+ *
+ */
+public abstract class WSDParameters {
+
+ protected boolean isCoarseSense;
+
+ /**
+ * @return if the disambiguation type is coarse grained or fine grained
+ */
+ public boolean isCoarseSense() {
+ return isCoarseSense;
+ }
+
+ public void setCoarseSense(boolean isCoarseSense) {
+ this.isCoarseSense = isCoarseSense;
+ }
+
+ public WSDParameters(){
+ this.isCoarseSense = true;
+ }
+
+ /**
+ * @return checks if the parameters are valid or not
+ */
+ public abstract boolean isValid();
+
+}
diff --git a/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/WSDisambiguator.java b/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/WSDisambiguator.java
index 5b67511..8fc8e72 100644
--- a/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/WSDisambiguator.java
+++ b/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/WSDisambiguator.java
@@ -19,14 +19,49 @@
package opennlp.tools.disambiguator;
+import java.security.InvalidParameterException;
import opennlp.tools.util.Span;
+
/**
- * The interface for word sense disambiguators.
+ * A word sense disambiguator that determines which sense of a word is meant in a particular context.
+ * It is a classification task, where the classes are the different senses of the ambiguous word.
+ * Disambiguation can be achieved in either supervised or un-supervised approaches.
+ * For the moment this component relies on WordNet to retrieve sense definitions.
+ * It returns an array of WordNet sense IDs ordered by their disambiguation score.
+ * The sense with highest score is the most likely sense of the word.
+ *
+ * Please see {@link Lesk} for an un-supervised approach.
+ * Please see {@link IMS} for a supervised approach.
+ *
+ * @see Lesk
+ * @see IMS
*/
public interface WSDisambiguator {
- public String[] disambiguate(String[] inputText, int inputWordIndex);
+
+ /**
+ * @return the parameters of the disambiguation algorithm
+ */
+ public WSDParameters getParams();
+
+ /**
+ * @param the disambiguation implementation specific parameters.
+ * @throws InvalidParameterException
+ */
+ public void setParams(WSDParameters params) throws InvalidParameterException;
+
+ /**
+ * @param tokenizedContext
+ * @param ambiguousTokenIndex
+ * @return result as an array of WordNet IDs
+ */
+ public String[] disambiguate(String[] tokenizedContext, int ambiguousTokenIndex);
- public String[] disambiguate(String[] inputText, Span[] inputWordSpans);
+ /**
+ * @param tokenizedContext
+ * @param ambiguousTokenIndexSpans
+ * @return result as an array of WordNet IDs
+ */
+ public String[][] disambiguate(String[] tokenizedContext, Span[] ambiguousTokenIndexSpans);
}
diff --git a/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/WordPOS.java b/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/WordPOS.java
index cf7e31d..9bc49ea 100644
--- a/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/WordPOS.java
+++ b/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/WordPOS.java
@@ -28,13 +28,13 @@
import net.sf.extjwnl.data.POS;
import net.sf.extjwnl.data.Synset;
+// TODO extend Word instead
public class WordPOS {
private String word;
private List stems;
private POS pos;
- // Constructor
public WordPOS(String word, POS pos) throws IllegalArgumentException {
if (word == null || pos == null) {
throw new IllegalArgumentException("Args are null");
@@ -106,5 +106,4 @@
}
return false;
}
-
}
diff --git a/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/WordToDisambiguate.java b/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/WordToDisambiguate.java
index 3eaa1ed..5f27b38 100644
--- a/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/WordToDisambiguate.java
+++ b/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/WordToDisambiguate.java
@@ -25,160 +25,141 @@
-
public class WordToDisambiguate {
-
- // TODO Check if it is necessary to add an attribute [word] since the word in the sentence is not necessarily in the base form ??
-
- protected String [] sentence;
- protected String [] posTags;
-
- protected int wordIndex;
- protected int sense;
-
- protected ArrayList<String> senseID;
-
-
-
- /**
- * Constructor
- */
-
-
- public WordToDisambiguate(String[] sentence, int wordIndex, int sense) throws IllegalArgumentException{
- super();
-
- if (wordIndex>sentence.length){
- throw new IllegalArgumentException("The index is out of bounds !");
- }
-
- this.sentence = sentence;
- this.posTags = PreProcessor.tag(sentence);
-
- this.wordIndex = wordIndex;
-
- this.sense = sense;
- }
-
- public WordToDisambiguate(String[] sentence, int wordIndex) {
- this(sentence,wordIndex,-1);
- }
-
- public WordToDisambiguate() {
- String[] emptyString = {};
- int emptyInteger = 0;
-
- this.sentence = emptyString;
- this.wordIndex = emptyInteger;
- this.sense = -1;
-
- }
+ // TODO Check if it is necessary to add an attribute [word] since the word in
+ // the sentence is not necessarily in the base form ??
-
- /**
- * Getters and Setters
- */
-
- // Sentence
- public String[] getSentence() {
- return sentence;
- }
+ protected String[] sentence;
+ protected String[] posTags;
- public void setSentence(String[] sentence) {
- this.sentence = sentence;
- }
+ protected int wordIndex;
-
- // Sentence Pos-Tags
- public String[] getPosTags() {
- return posTags;
- }
+ protected int sense;
- public void setPosTags(String[] posTags) {
- this.posTags = posTags;
- }
+ protected ArrayList<String> senseIDs;
-
- // Word to disambiguate
- public int getWordIndex() {
- return wordIndex;
- }
+ /**
+ * Constructor
+ */
- public String getRawWord() {
-
- /**
- * For example, from the word "running" it returns "run.v"
- */
-
- String wordBaseForm = Loader.getLemmatizer().lemmatize(this.sentence[wordIndex], this.posTags[wordIndex]);
-
- String ref = "";
-
- if (Constants.getPOS(this.posTags[wordIndex]).equals(POS.VERB)) {
- ref = wordBaseForm + ".v";
- } else if (Constants.getPOS(this.posTags[wordIndex]).equals(POS.NOUN)) {
- ref = wordBaseForm + ".n";
- } else if (Constants.getPOS(this.posTags[wordIndex]).equals(POS.ADJECTIVE)) {
- ref = wordBaseForm + ".a";
- } else if (Constants.getPOS(this.posTags[wordIndex]).equals(POS.ADVERB)) {
- ref = wordBaseForm + ".r";
- } else {
-
- }
-
- return ref;
-
- }
-
- public String getWord() {
- return this.sentence[this.wordIndex];
- }
-
- public String getPosTag() {
- return this.posTags[this.wordIndex];
- }
-
- public void setWordIndex(int wordIndex) {
- this.wordIndex = wordIndex;
- }
-
+ public WordToDisambiguate(String[] sentence, int wordIndex, int sense)
+ throws IllegalArgumentException {
+ super();
-
-
- // Word to disambiguate sense
- public int getSense() {
- return sense;
- }
+ if (wordIndex > sentence.length) {
+ throw new IllegalArgumentException("The index is out of bounds !");
+ }
- public void setSense(int sense) {
- this.sense = sense;
- }
+ this.sentence = sentence;
+ this.posTags = PreProcessor.tag(sentence);
-
-
- // Sense as in the source
- // TODO fix the conflict between this ID of the sense and that in the attribute [sense]
- public ArrayList<String> getSenseID() {
- return senseID;
- }
+ this.wordIndex = wordIndex;
- public void setSenseID(ArrayList<String> senseID) {
- this.senseID = senseID;
- }
-
-
+ this.sense = sense;
+ }
+ public WordToDisambiguate(String[] sentence, int wordIndex) {
+ this(sentence, wordIndex, -1);
+ }
- /**
- * toString
- */
-
- public String toString() {
- return (wordIndex + "\t" + getWord() + "\n" + sentence);
- }
-
+ public WordToDisambiguate() {
+ String[] emptyString = {};
+ int emptyInteger = 0;
-
+ this.sentence = emptyString;
+ this.wordIndex = emptyInteger;
+ this.sense = -1;
+ }
+
+ /**
+ * Getters and Setters
+ */
+
+ // Sentence
+ public String[] getSentence() {
+ return sentence;
+ }
+
+ public void setSentence(String[] sentence) {
+ this.sentence = sentence;
+ }
+
+ // Sentence Pos-Tags
+ public String[] getPosTags() {
+ return posTags;
+ }
+
+ public void setPosTags(String[] posTags) {
+ this.posTags = posTags;
+ }
+
+ // Word to disambiguate
+ public int getWordIndex() {
+ return wordIndex;
+ }
+
+ public String getRawWord() {
+
+ /**
+ * For example, from the word "running" it returns "run.v"
+ */
+
+ String wordBaseForm = Loader.getLemmatizer().lemmatize(
+ this.sentence[wordIndex], this.posTags[wordIndex]);
+
+ String ref = "";
+
+ if (Constants.getPOS(this.posTags[wordIndex]).equals(POS.VERB)) {
+ ref = wordBaseForm + ".v";
+ } else if (Constants.getPOS(this.posTags[wordIndex]).equals(POS.NOUN)) {
+ ref = wordBaseForm + ".n";
+ } else if (Constants.getPOS(this.posTags[wordIndex]).equals(POS.ADJECTIVE)) {
+ ref = wordBaseForm + ".a";
+ } else if (Constants.getPOS(this.posTags[wordIndex]).equals(POS.ADVERB)) {
+ ref = wordBaseForm + ".r";
+ } else {
+
+ }
+
+ return ref;
+
+ }
+
+ public String getWord() {
+ return this.sentence[this.wordIndex];
+ }
+
+ public String getPosTag() {
+ return this.posTags[this.wordIndex];
+ }
+
+ public void setWordIndex(int wordIndex) {
+ this.wordIndex = wordIndex;
+ }
+
+ // Word to disambiguate sense
+ public int getSense() {
+ return sense;
+ }
+
+ public void setSense(int sense) {
+ this.sense = sense;
+ }
+
+ // Sense as in the source
+ // TODO fix the conflict between this ID of the sense and that in the
+ // attribute [sense]
+ public ArrayList<String> getSenseIDs() {
+ return senseIDs;
+ }
+
+ public void setSenseIDs(ArrayList<String> senseIDs) {
+ this.senseIDs = senseIDs;
+ }
+
+ public String toString() {
+ return (wordIndex + "\t" + getWord() + "\n" + sentence);
+ }
}
diff --git a/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/ims/DefaultIMSContextGenerator.java b/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/ims/DefaultIMSContextGenerator.java
index b1710d7..0c8c4e6 100644
--- a/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/ims/DefaultIMSContextGenerator.java
+++ b/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/ims/DefaultIMSContextGenerator.java
@@ -34,8 +34,8 @@
/**
* Default context generator for IMS.
*/
- public DefaultIMSContextGenerator() {
+ public DefaultIMSContextGenerator() {
}
/**
diff --git a/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/ims/IMS.java b/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/ims/IMS.java
index 961c6c3..a453ecb 100644
--- a/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/ims/IMS.java
+++ b/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/ims/IMS.java
@@ -35,6 +35,7 @@
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
+import java.security.InvalidParameterException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.zip.GZIPInputStream;
@@ -51,6 +52,7 @@
import opennlp.tools.disambiguator.DataExtractor;
import opennlp.tools.disambiguator.FeaturesExtractor;
import opennlp.tools.disambiguator.PreProcessor;
+import opennlp.tools.disambiguator.WSDParameters;
import opennlp.tools.disambiguator.WordPOS;
import opennlp.tools.disambiguator.WSDisambiguator;
@@ -64,17 +66,11 @@
private FeaturesExtractor fExtractor = new FeaturesExtractor();
private DataExtractor dExtractor = new DataExtractor();
- /**
- * PARAMETERS
- */
private int windowSize;
+ private int word;
private int ngram;
- /**
- * Constructors
- */
-
public IMS() {
super();
windowSize = 3;
@@ -95,11 +91,7 @@
this.cg = factory.createContextGenerator();
}
- /**
- * INTERNAL METHODS
- */
-
- protected HashMap<Integer, WTDIMS> extractTrainingData(
+ protected ArrayList<WTDIMS> extractTrainingData(
String wordTrainingxmlFile,
HashMap<String, ArrayList<DictionaryInstance>> senses) {
@@ -108,18 +100,18 @@
* etc.)
*/
- HashMap<Integer, WTDIMS> trainingData = dExtractor
+ ArrayList<WTDIMS> trainingData = dExtractor
.extractWSDInstances(wordTrainingxmlFile);
// HashMap<Integer, WTDIMS> trainingData =
// dExtractor.extractWSDInstances(wordTrainingxmlFile);
- for (Integer key : trainingData.keySet()) {
- for (String senseId : trainingData.get(key).getSenseID()) {
+ for (WTDIMS data : trainingData) {
+ for (String senseId : data.getSenseIDs()) {
for (String dictKey : senses.keySet()) {
for (DictionaryInstance instance : senses.get(dictKey)) {
if (senseId.equals(instance.getId())) {
- trainingData.get(key).setSense(
+ data.setSense(
Integer.parseInt(dictKey.split("_")[1]));
break;
}
@@ -131,11 +123,11 @@
return trainingData;
}
- protected void extractFeature(HashMap<Integer, WTDIMS> words) {
+ protected void extractFeature(ArrayList<WTDIMS> words) {
- for (Integer key : words.keySet()) {
+ for (WTDIMS word : words) {
- fExtractor.extractIMSFeatures(words.get(key), windowSize, ngram);
+ fExtractor.extractIMSFeatures(word, windowSize, ngram);
}
@@ -217,18 +209,18 @@
HashMap<String, ArrayList<DictionaryInstance>> senses = dExtractor
.extractWordSenses(dict, map, wordTag);
- HashMap<Integer, WTDIMS> instances = extractTrainingData(
+ ArrayList<WTDIMS> instances = extractTrainingData(
wordTrainingxmlFile, senses);
extractFeature(instances);
ArrayList<Event> events = new ArrayList<Event>();
- for (int key : instances.keySet()) {
+ for (WTDIMS instance : instances) {
- int sense = instances.get(key).getSense();
+ int sense = instance.getSense();
- String[] context = cg.getContext(instances.get(key));
+ String[] context = cg.getContext(instance);
Event ev = new Event(sense + "", context);
@@ -338,9 +330,16 @@
}
@Override
- public String[] disambiguate(String[] inputText, Span[] inputWordSpans) {
- // TODO Auto-generated method stub
+ public String[][] disambiguate(String[] inputText, Span[] inputWordSpans) {
return null;
}
+ @Override
+ public WSDParameters getParams() {
+ return null;
+ }
+
+ @Override
+ public void setParams(WSDParameters params) throws InvalidParameterException {
+ }
}
diff --git a/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/ims/IMSContextGenerator.java b/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/ims/IMSContextGenerator.java
index 7b88474..cb670e4 100644
--- a/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/ims/IMSContextGenerator.java
+++ b/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/ims/IMSContextGenerator.java
@@ -25,5 +25,4 @@
public interface IMSContextGenerator {
public String[] getContext(WTDIMS word);
-
}
diff --git a/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/ims/IMSFactory.java b/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/ims/IMSFactory.java
index 5c078f6..81eac3f 100644
--- a/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/ims/IMSFactory.java
+++ b/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/ims/IMSFactory.java
@@ -99,4 +99,3 @@
public void validateArtifactMap() throws InvalidFormatException {
}
}
-
diff --git a/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/ims/WTDIMS.java b/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/ims/WTDIMS.java
index ec9fd10..e40c75a 100644
--- a/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/ims/WTDIMS.java
+++ b/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/ims/WTDIMS.java
@@ -19,8 +19,6 @@
package opennlp.tools.disambiguator.ims;
-
-
import java.util.ArrayList;
import opennlp.tools.disambiguator.PreProcessor;
@@ -34,7 +32,6 @@
public WTDIMS(String[] sentence, int word, int sense) {
super(sentence, word, sense);
-
}
public WTDIMS(String[] sentence, int word) {
@@ -57,8 +54,7 @@
}
}
- this.senseID = xmlAnswers;
-
+ this.senseIDs = xmlAnswers;
}
public String[] getPosOfSurroundingWords() {
@@ -85,4 +81,3 @@
this.localCollocations = localCollocations;
}
}
-
diff --git a/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/lesk/Lesk.java b/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/lesk/Lesk.java
index ecb1ec0..0b02df2 100644
--- a/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/lesk/Lesk.java
+++ b/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/lesk/Lesk.java
@@ -21,13 +21,13 @@
import java.security.InvalidParameterException;
import java.util.ArrayList;
-
import java.util.Collections;
import opennlp.tools.disambiguator.Constants;
import opennlp.tools.disambiguator.Loader;
import opennlp.tools.disambiguator.Node;
import opennlp.tools.disambiguator.PreProcessor;
+import opennlp.tools.disambiguator.WSDParameters;
import opennlp.tools.disambiguator.WSDisambiguator;
import opennlp.tools.disambiguator.WordPOS;
import opennlp.tools.disambiguator.WordSense;
@@ -35,36 +35,68 @@
import net.sf.extjwnl.data.Synset;
/**
- * Class for the Lesk algorithm and variants.
+ * Implementation of the <b>Overlap Of Senses</b> approach originally proposed by Lesk.
+ * The main idea is to check for word overlaps in the sense definitions of the surrounding context.
+ * An overlap is when two words have similar stems.
+ * The more overlaps a word has the higher its score.
+ * Different variations of the approach are included in this class.
+ *
*/
-
public class Lesk implements WSDisambiguator {
+ /**
+ * The lesk specific parameters
+ */
protected LeskParameters params;
-
- public Loader loader;
-
+
public Lesk() {
this(null);
}
+ /**
+ * Initializes the loader object and sets the input parameters
+ * @param Input Parameters
+ * @throws InvalidParameterException
+ */
public Lesk(LeskParameters params) throws InvalidParameterException {
- loader = new Loader();
+ Loader loader = new Loader();
this.setParams(params);
}
+
- public void setParams(LeskParameters params) throws InvalidParameterException {
+ /**
+ * If the parameters are null set the default ones, else only set them if they valid.
+ * Invalid parameters will return a exception
+ *
+ * @param Input parameters
+ * @throws InvalidParameterException
+ */
+ @Override
+ public void setParams(WSDParameters params) throws InvalidParameterException {
if (params == null) {
this.params = new LeskParameters();
} else {
if (params.isValid()) {
- this.params = params;
+ this.params = (LeskParameters) params;
} else {
throw new InvalidParameterException("wrong params");
}
}
}
+ /**
+ * @return the parameter settings
+ */
+ public LeskParameters getParams() {
+ return params;
+ }
+
+ /**
+ * The basic Lesk method where the entire context is considered for overlaps
+ *
+ * @param The word to disambiguate
+ * @return The array of WordSenses with their scores
+ */
public ArrayList<WordSense> basic(WTDLesk wtd) {
ArrayList<WordPOS> relvWords = PreProcessor.getAllRelevantWords(wtd);
@@ -98,14 +130,31 @@
return scoredSenses;
}
+ /**
+ * The basic Lesk method but applied to a default context windows
+ * @param The word to disambiguate
+ * @return The array of WordSenses with their scores
+ */
public ArrayList<WordSense> basicContextual(WTDLesk wtd) {
return this.basicContextual(wtd, LeskParameters.DFLT_WIN_SIZE);
}
+ /**
+ * The basic Lesk method but applied to a custom context windows
+ * @param The word to disambiguate
+ * @param windowSize
+ * @return The array of WordSenses with their scores
+ */
public ArrayList<WordSense> basicContextual(WTDLesk wtd, int windowSize) {
return this.basicContextual(wtd, windowSize, windowSize);
}
+ /**
+ * The basic Lesk method but applied to a context windows set by custom backward and forward window lengths
+ * @param wtd the word to disambiguate
+ * @param windowBackward
+ * @return the array of WordSenses with their scores
+ */
public ArrayList<WordSense> basicContextual(WTDLesk wtd, int windowBackward,
int windowForward) {
@@ -146,6 +195,19 @@
return scoredSenses;
}
+ /**
+ * An extended version of the Lesk approach that takes into consideration semantically related feature overlaps across the entire context
+ * The scoring function uses linear weights.
+ * @param wtd the word to disambiguate
+ * @param depth how deep to go into each feature tree
+ * @param depthScoreWeight the weighing per depth level
+ * @param includeSynonyms
+ * @param includeHypernyms
+ * @param includeHyponyms
+ * @param includeMeronyms
+ * @param includeHolonyms
+ * @return the array of WordSenses with their scores
+ */
public ArrayList<WordSense> extended(WTDLesk wtd, int depth,
double depthScoreWeight, boolean includeSynonyms,
boolean includeHypernyms, boolean includeHyponyms,
@@ -156,6 +218,19 @@
}
+ /**
+ * An extended version of the Lesk approach that takes into consideration semantically related feature overlaps in a default context window
+ * The scoring function uses linear weights.
+ * @param wtd the word to disambiguate
+ * @param depth how deep to go into each feature tree
+ * @param depthScoreWeight the weighing per depth level
+ * @param includeSynonyms
+ * @param includeHypernyms
+ * @param includeHyponyms
+ * @param includeMeronyms
+ * @param includeHolonyms
+ * @return the array of WordSenses with their scores
+ */
public ArrayList<WordSense> extendedContextual(WTDLesk wtd, int depth,
double depthScoreWeight, boolean includeSynonyms,
boolean includeHypernyms, boolean includeHyponyms,
@@ -167,6 +242,20 @@
}
+ /**
+ * An extended version of the Lesk approach that takes into consideration semantically related feature overlaps in a custom context window
+ * The scoring function uses linear weights.
+ * @param wtd the word to disambiguate
+ * @param windowSize the custom context window size
+ * @param depth how deep to go into each feature tree
+ * @param depthScoreWeight the weighing per depth level
+ * @param includeSynonyms
+ * @param includeHypernyms
+ * @param includeHyponyms
+ * @param includeMeronyms
+ * @param includeHolonyms
+ * @return the array of WordSenses with their scores
+ */
public ArrayList<WordSense> extendedContextual(WTDLesk wtd, int windowSize,
int depth, double depthScoreWeight, boolean includeSynonyms,
boolean includeHypernyms, boolean includeHyponyms,
@@ -177,6 +266,22 @@
includeMeronyms, includeHolonyms);
}
+
+ /**
+ * An extended version of the Lesk approach that takes into consideration semantically related feature overlaps in a custom context window
+ * The scoring function uses linear weights.
+ * @param wtd the word to disambiguate
+ * @param windowBackward the custom context backward window size
+ * @param windowForward the custom context forward window size
+ * @param depth how deep to go into each feature tree
+ * @param depthScoreWeight the weighing per depth level
+ * @param includeSynonyms
+ * @param includeHypernyms
+ * @param includeHyponyms
+ * @param includeMeronyms
+ * @param includeHolonyms
+ * @return the array of WordSenses with their scores
+ */
public ArrayList<WordSense> extendedContextual(WTDLesk wtd,
int windowBackward, int windowForward, int depth,
double depthScoreWeight, boolean includeSynonyms,
@@ -236,6 +341,21 @@
}
+
+ /**
+ * An extended version of the Lesk approach that takes into consideration semantically related feature overlaps in all the context.
+ * The scoring function uses exponential weights.
+ * @param wtd the word to disambiguate
+ * @param depth how deep to go into each feature tree
+ * @param intersectionExponent
+ * @param depthExponent
+ * @param includeSynonyms
+ * @param includeHypernyms
+ * @param includeHyponyms
+ * @param includeMeronyms
+ * @param includeHolonyms
+ * @return the array of WordSenses with their scores
+ */
public ArrayList<WordSense> extendedExponential(WTDLesk wtd, int depth,
double intersectionExponent, double depthExponent,
boolean includeSynonyms, boolean includeHypernyms,
@@ -246,7 +366,21 @@
includeMeronyms, includeHolonyms);
}
-
+
+ /**
+ * An extended version of the Lesk approach that takes into consideration semantically related feature overlaps in a default window in the context.
+ * The scoring function uses exponential weights.
+ * @param wtd the word to disambiguate
+ * @param depth how deep to go into each feature tree
+ * @param intersectionExponent
+ * @param depthExponent
+ * @param includeSynonyms
+ * @param includeHypernyms
+ * @param includeHyponyms
+ * @param includeMeronyms
+ * @param includeHolonyms
+ * @return the array of WordSenses with their scores
+ */
public ArrayList<WordSense> extendedExponentialContextual(WTDLesk wtd,
int depth, double intersectionExponent, double depthExponent,
boolean includeSynonyms, boolean includeHypernyms,
@@ -256,7 +390,22 @@
depth, intersectionExponent, depthExponent, includeSynonyms,
includeHypernyms, includeHyponyms, includeMeronyms, includeHolonyms);
}
-
+
+ /**
+ * An extended version of the Lesk approach that takes into consideration semantically related feature overlaps in a custom window in the context.
+ * The scoring function uses exponential weights.
+ * @param wtd the word to disambiguate
+ * @param windowSize
+ * @param depth how deep to go into each feature tree
+ * @param intersectionExponent
+ * @param depthExponent
+ * @param includeSynonyms
+ * @param includeHypernyms
+ * @param includeHyponyms
+ * @param includeMeronyms
+ * @param includeHolonyms
+ * @return the array of WordSenses with their scores
+ */
public ArrayList<WordSense> extendedExponentialContextual(WTDLesk wtd,
int windowSize, int depth, double intersectionExponent,
double depthExponent, boolean includeSynonyms, boolean includeHypernyms,
@@ -267,6 +416,22 @@
includeHyponyms, includeMeronyms, includeHolonyms);
}
+ /**
+ * An extended version of the Lesk approach that takes into consideration semantically related feature overlaps in a custom window in the context.
+ * The scoring function uses exponential weights.
+ * @param wtd the word to disambiguate
+ * @param windowBackward
+ * @param windowForward
+ * @param depth
+ * @param intersectionExponent
+ * @param depthExponent
+ * @param includeSynonyms
+ * @param includeHypernyms
+ * @param includeHyponyms
+ * @param includeMeronyms
+ * @param includeHolonyms
+ * @return the array of WordSenses with their scores
+ */
public ArrayList<WordSense> extendedExponentialContextual(WTDLesk wtd,
int windowBackward, int windowForward, int depth,
double intersectionExponent, double depthExponent,
@@ -327,6 +492,15 @@
}
+ /**
+ * Recursively score the hypernym tree linearly
+ * @param wordSense
+ * @param child
+ * @param relvWords
+ * @param depth
+ * @param maxDepth
+ * @param depthScoreWeight
+ */
private void fathomHypernyms(WordSense wordSense, Synset child,
ArrayList<WordPOS> relvWords, int depth, int maxDepth,
double depthScoreWeight) {
@@ -350,6 +524,16 @@
}
}
+ /**
+ * Recursively score the hypernym tree exponentially
+ * @param wordSense
+ * @param child
+ * @param relvWords
+ * @param depth
+ * @param maxDepth
+ * @param intersectionExponent
+ * @param depthScoreExponent
+ */
private void fathomHypernymsExponential(WordSense wordSense, Synset child,
ArrayList<WordPOS> relvWords, int depth, int maxDepth,
double intersectionExponent, double depthScoreExponent) {
@@ -374,6 +558,15 @@
}
}
+ /**
+ * Recursively score the hyponym tree linearly
+ * @param wordSense
+ * @param child
+ * @param relvWords
+ * @param depth
+ * @param maxDepth
+ * @param depthScoreWeight
+ */
private void fathomHyponyms(WordSense wordSense, Synset child,
ArrayList<WordPOS> relvWords, int depth, int maxDepth,
double depthScoreWeight) {
@@ -398,6 +591,16 @@
}
}
+ /**
+ * Recursively score the hyponym tree exponentially
+ * @param wordSense
+ * @param child
+ * @param relvWords
+ * @param depth
+ * @param maxDepth
+ * @param intersectionExponent
+ * @param depthScoreExponent
+ */
private void fathomHyponymsExponential(WordSense wordSense, Synset child,
ArrayList<WordPOS> relvWords, int depth, int maxDepth,
double intersectionExponent, double depthScoreExponent) {
@@ -422,6 +625,15 @@
}
}
+ /**
+ * Recursively score the meronym tree linearly
+ * @param wordSense
+ * @param child
+ * @param relvWords
+ * @param depth
+ * @param maxDepth
+ * @param depthScoreWeight
+ */
private void fathomMeronyms(WordSense wordSense, Synset child,
ArrayList<WordPOS> relvWords, int depth, int maxDepth,
double depthScoreWeight) {
@@ -446,6 +658,16 @@
}
}
+ /**
+ * Recursively score the meronym tree exponentially
+ * @param wordSense
+ * @param child
+ * @param relvWords
+ * @param depth
+ * @param maxDepth
+ * @param intersectionExponent
+ * @param depthScoreExponent
+ */
private void fathomMeronymsExponential(WordSense wordSense, Synset child,
ArrayList<WordPOS> relvWords, int depth, int maxDepth,
double intersectionExponent, double depthScoreExponent) {
@@ -470,6 +692,15 @@
}
}
+ /**
+ * Recursively score the holonym tree linearly
+ * @param wordSense
+ * @param child
+ * @param relvWords
+ * @param depth
+ * @param maxDepth
+ * @param depthScoreWeight
+ */
private void fathomHolonyms(WordSense wordSense, Synset child,
ArrayList<WordPOS> relvWords, int depth, int maxDepth,
double depthScoreWeight) {
@@ -494,6 +725,16 @@
}
}
+ /**
+ * Recursively score the holonym tree exponentially
+ * @param wordSense
+ * @param child
+ * @param relvWords
+ * @param depth
+ * @param maxDepth
+ * @param intersectionExponent
+ * @param depthScoreExponent
+ */
private void fathomHolonymsExponential(WordSense wordSense, Synset child,
ArrayList<WordPOS> relvWords, int depth, int maxDepth,
double intersectionExponent, double depthScoreExponent) {
@@ -518,6 +759,12 @@
}
}
+ /**
+ * Checks if the feature should be counted in the score
+ * @param featureSynsets
+ * @param relevantWords
+ * @return count of features to consider
+ */
private int assessFeature(ArrayList<Synset> featureSynsets,
ArrayList<WordPOS> relevantWords) {
int count = 0;
@@ -540,25 +787,32 @@
return count;
}
+ /**
+ * Checks if the synonyms should be counted in the score
+ * @param synonyms
+ * @param relevantWords
+ * @return count of synonyms to consider
+ */
private int assessSynonyms(ArrayList<WordPOS> synonyms,
ArrayList<WordPOS> relevantWords) {
int count = 0;
for (WordPOS synonym : synonyms) {
for (WordPOS sentenceWord : relevantWords) {
- // TODO try to switch to lemmatizer
if (sentenceWord.isStemEquivalent(synonym)) {
count = count + 1;
}
}
-
}
-
return count;
}
+ /**
+ * Gets the senses of the nodes
+ * @param nodes
+ * @return senses from the nodes
+ */
public ArrayList<WordSense> updateSenses(ArrayList<Node> nodes) {
-
ArrayList<WordSense> scoredSenses = new ArrayList<WordSense>();
for (int i = 0; i < nodes.size(); i++) {
@@ -573,12 +827,25 @@
return scoredSenses;
}
-
- // disambiguates a WTDLesk and returns an array of sense indexes from WordNet
- // ordered by their score
+
+ /**
+ * Disambiguates an ambiguous word in its context
+ *
+ * @param tokenizedContext
+ * @param ambiguousTokenIndex
+ * @return array of sense indexes from WordNet ordered by their score.
+ * The result format is <b>POS</b>@<b>SenseID</b>@<b>Sense Score</b>
+ * If the input token is non relevant a null is returned.
+ */
@Override
- public String[] disambiguate(String[] inputText, int inputWordIndex) {
- WTDLesk wtd = new WTDLesk(inputText, inputWordIndex);
+ public String[] disambiguate(String[] tokenizedContext, int ambiguousTokenIndex) {
+
+ WTDLesk wtd = new WTDLesk(tokenizedContext, ambiguousTokenIndex);
+ // if the word is not relevant return null
+ if (!Constants.isRelevant(wtd.getPosTag())){
+ return null ;
+ }
+
ArrayList<WordSense> wsenses = null;
switch (this.params.leskType) {
@@ -654,15 +921,32 @@
LeskParameters.DFLT_DEXP, true, true, true, true, true);
Collections.sort(wsenses);
+ // TODO modify to longs but for now we have strings in the data for coarsing
String[] senses = new String[wsenses.size()];
for (int i = 0; i < wsenses.size(); i++) {
- senses[i] = wsenses.get(i).getSense();
+ senses[i] = Constants.getPOS(wsenses.get(i).getWTDLesk().getPosTag())
+ .getKey()
+ + "@"
+ + Long.toString(wsenses.get(i).getNode().getSenseID())
+ + "@"
+ + wsenses.get(i).getScore();
}
return senses;
}
- @Override
- public String[] disambiguate(String[] inputText, Span[] inputWordSpans) {
+
+ /**
+ * Disambiguates an ambiguous word in its context
+ * The user can set a span of inputWords from the tokenized input
+ *
+ * @param inputText
+ * @param inputWordSpans
+ * @return array of array of sense indexes from WordNet ordered by their score.
+ * The result format is <b>POS</b>@<b>SenseID</b>@<b>Sense Score</b>
+ * If the input token is non relevant a null is returned.
+ */
+ @Override
+ public String[][] disambiguate(String[] tokenizedContext, Span[] ambiguousTokenSpans) {
// TODO need to work on spans
return null;
}
diff --git a/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/lesk/LeskParameters.java b/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/lesk/LeskParameters.java
index 3d1834a..d0aa8f5 100644
--- a/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/lesk/LeskParameters.java
+++ b/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/lesk/LeskParameters.java
@@ -19,11 +19,23 @@
package opennlp.tools.disambiguator.lesk;
-public class LeskParameters {
+import opennlp.tools.disambiguator.WSDParameters;
- // VARIATIONS
+/**
+ * Lesk specific parameter set
+ *
+ */
+public class LeskParameters extends WSDParameters {
+
+
+ /**
+ * Enum of all types of implemented variations of Lesk
+ *
+ */
public static enum LESK_TYPE {
- LESK_BASIC, LESK_BASIC_CTXT, LESK_BASIC_CTXT_WIN, LESK_BASIC_CTXT_WIN_BF, LESK_EXT, LESK_EXT_CTXT, LESK_EXT_CTXT_WIN, LESK_EXT_CTXT_WIN_BF, LESK_EXT_EXP, LESK_EXT_EXP_CTXT, LESK_EXT_EXP_CTXT_WIN, LESK_EXT_EXP_CTXT_WIN_BF,
+ LESK_BASIC, LESK_BASIC_CTXT, LESK_BASIC_CTXT_WIN, LESK_BASIC_CTXT_WIN_BF,
+ LESK_EXT, LESK_EXT_CTXT, LESK_EXT_CTXT_WIN, LESK_EXT_CTXT_WIN_BF, LESK_EXT_EXP,
+ LESK_EXT_EXP_CTXT, LESK_EXT_EXP_CTXT_WIN, LESK_EXT_EXP_CTXT_WIN_BF,
}
// DEFAULTS
@@ -33,25 +45,124 @@
protected static final double DFLT_IEXP = 0.3;
protected static final double DFLT_DEXP = 0.3;
- public LESK_TYPE leskType;
- public int win_f_size;
- public int win_b_size;
- public int depth;
+ protected LESK_TYPE leskType;
+ protected int win_f_size;
+ protected int win_b_size;
+ protected int depth;
- public boolean fathom_synonyms;
- public boolean fathom_hypernyms;
- public boolean fathom_hyponyms;
- public boolean fathom_meronyms;
- public boolean fathom_holonyms;
+ protected boolean fathom_synonyms;
+ protected boolean fathom_hypernyms;
+ protected boolean fathom_hyponyms;
+ protected boolean fathom_meronyms;
+ protected boolean fathom_holonyms;
- public double depth_weight;
- public double iexp;
- public double dexp;
+ protected double depth_weight;
+ protected double iexp;
+ protected double dexp;
+
+ public LESK_TYPE getLeskType() {
+ return leskType;
+ }
+
+ public void setLeskType(LESK_TYPE leskType) {
+ this.leskType = leskType;
+ }
+
+ public int getWin_f_size() {
+ return win_f_size;
+ }
+
+ public void setWin_f_size(int win_f_size) {
+ this.win_f_size = win_f_size;
+ }
+
+ public int getWin_b_size() {
+ return win_b_size;
+ }
+
+ public void setWin_b_size(int win_b_size) {
+ this.win_b_size = win_b_size;
+ }
+
+ public int getDepth() {
+ return depth;
+ }
+
+ public void setDepth(int depth) {
+ this.depth = depth;
+ }
+
+ public boolean isFathom_synonyms() {
+ return fathom_synonyms;
+ }
+
+ public void setFathom_synonyms(boolean fathom_synonyms) {
+ this.fathom_synonyms = fathom_synonyms;
+ }
+
+ public boolean isFathom_hypernyms() {
+ return fathom_hypernyms;
+ }
+
+ public void setFathom_hypernyms(boolean fathom_hypernyms) {
+ this.fathom_hypernyms = fathom_hypernyms;
+ }
+
+ public boolean isFathom_hyponyms() {
+ return fathom_hyponyms;
+ }
+
+ public void setFathom_hyponyms(boolean fathom_hyponyms) {
+ this.fathom_hyponyms = fathom_hyponyms;
+ }
+
+ public boolean isFathom_meronyms() {
+ return fathom_meronyms;
+ }
+
+ public void setFathom_meronyms(boolean fathom_meronyms) {
+ this.fathom_meronyms = fathom_meronyms;
+ }
+
+ public boolean isFathom_holonyms() {
+ return fathom_holonyms;
+ }
+
+ public void setFathom_holonyms(boolean fathom_holonyms) {
+ this.fathom_holonyms = fathom_holonyms;
+ }
+
+ public double getDepth_weight() {
+ return depth_weight;
+ }
+
+ public void setDepth_weight(double depth_weight) {
+ this.depth_weight = depth_weight;
+ }
+
+ public double getIexp() {
+ return iexp;
+ }
+
+ public void setIexp(double iexp) {
+ this.iexp = iexp;
+ }
+
+ public double getDexp() {
+ return dexp;
+ }
+
+ public void setDexp(double dexp) {
+ this.dexp = dexp;
+ }
public LeskParameters() {
this.setDefaults();
}
+ /**
+ * Sets default parameters
+ */
public void setDefaults() {
this.leskType = LeskParameters.DFLT_LESK_TYPE;
this.win_f_size = LeskParameters.DFLT_WIN_SIZE;
@@ -66,8 +177,10 @@
this.fathom_synonyms = true;
}
- // Parameter Validation
- // TODO make isSet for semantic feature booleans
+
+ /* (non-Javadoc)
+ * @see opennlp.tools.disambiguator.WSDParameters#isValid()
+ */
public boolean isValid() {
switch (this.leskType) {
@@ -81,16 +194,13 @@
case LESK_EXT:
case LESK_EXT_CTXT:
return (this.depth >= 0) && (this.depth_weight >= 0);
-
case LESK_EXT_CTXT_WIN:
case LESK_EXT_CTXT_WIN_BF:
return (this.depth >= 0) && (this.depth_weight >= 0)
&& (this.win_b_size >= 0) && (this.win_f_size >= 0);
-
case LESK_EXT_EXP:
case LESK_EXT_EXP_CTXT:
return (this.depth >= 0) && (this.dexp >= 0) && (this.iexp >= 0);
-
case LESK_EXT_EXP_CTXT_WIN:
case LESK_EXT_EXP_CTXT_WIN_BF:
return (this.depth >= 0) && (this.dexp >= 0) && (this.iexp >= 0)
diff --git a/opennlp-wsd/src/test/java/opennlp/tools/disambiguator/Tester.java b/opennlp-wsd/src/test/java/opennlp/tools/disambiguator/Tester.java
index c78ba80..adae7ab 100644
--- a/opennlp-wsd/src/test/java/opennlp/tools/disambiguator/Tester.java
+++ b/opennlp-wsd/src/test/java/opennlp/tools/disambiguator/Tester.java
@@ -45,40 +45,47 @@
try {
TokenizerModel = new TokenizerModel(new FileInputStream(
- "src\\test\\resources\\opennlp\\tools\\disambiguator\\en-token.bin"));
+ "src\\test\\resources\\models\\en-token.bin"));
Tokenizer tokenizer = new TokenizerME(TokenizerModel);
String[] words = tokenizer.tokenize(sentence);
-
- POSModel posTaggerModel = new POSModelLoader()
- .load(new File(
- "src\\test\\resources\\opennlp\\tools\\disambiguator\\en-pos-maxent.bin"));
- POSTagger tagger = new POSTaggerME(posTaggerModel);
-
- Constants.print("\ntokens :");
+//
+// POSModel posTaggerModel = new POSModelLoader()
+// .load(new File(
+// "src\\test\\resources\\models\\en-pos-maxent.bin"));
+//// POSTagger tagger = new POSTaggerME(posTaggerModel);
+//
+// Constants.print("\ntokens :");
Constants.print(words);
- Constants.print(tagger.tag(words));
+
+ int wordIndex= 6;
+// Constants.print(tagger.tag(words));
Constants.print("\ntesting default lesk :");
Lesk lesk = new Lesk();
- Constants.print(lesk.disambiguate(words, 6));
+ Constants.print(lesk.disambiguate(words, wordIndex));
+ Constants.printResults(lesk,lesk.disambiguate(words, wordIndex));
+
Constants.print("\ntesting with null params :");
lesk.setParams(null);
- Constants.print(lesk.disambiguate(words, 6));
+ Constants.print(lesk.disambiguate(words, wordIndex));
+ Constants.printResults(lesk,lesk.disambiguate(words, wordIndex));
Constants.print("\ntesting with default params");
lesk.setParams(new LeskParameters());
- Constants.print(lesk.disambiguate(words, 6));
+ Constants.print(lesk.disambiguate(words, wordIndex));
+ Constants.printResults(lesk,lesk.disambiguate(words, wordIndex));
Constants.print("\ntesting with custom params :");
LeskParameters leskParams = new LeskParameters();
- leskParams.leskType = LeskParameters.LESK_TYPE.LESK_BASIC_CTXT_WIN_BF;
- leskParams.win_b_size = 4;
- leskParams.depth = 3;
+ leskParams.setLeskType(LeskParameters.LESK_TYPE.LESK_BASIC_CTXT_WIN_BF);
+ leskParams.setWin_b_size(4);
+ leskParams.setDepth(3);
lesk.setParams(leskParams);
- Constants.print(lesk.disambiguate(words, 6));
-
+ Constants.print(lesk.disambiguate(words, wordIndex));
+ Constants.printResults(lesk,lesk.disambiguate(words, wordIndex));
+
/*
* Constants.print("\ntesting with wrong params should throw exception :");
* LeskParameters leskWrongParams = new LeskParameters();
