public static double LexicalSimilarityScoreMin(
ArrayList<TaggedWord> taggedWords1,
ArrayList<TaggedWord> taggedWords2,
DISCOSimilarity discoRAM,
LexicalizedParser lp) {
// System.out.println(taggedWords1.size() + "," + taggedWords2.size());
// array of edge weights with default weight 0
int length1 = taggedWords1.size();
int length2 = taggedWords2.size();
int arrSize = Math.max(length1, length2);
double[][] array = new double[arrSize][arrSize];
for (int i = 0; i < arrSize; i++) {
for (int j = 0; j < arrSize; j++) {
array[i][j] = 0;
}
}
for (int i = 0; i < length1; i++) {
for (int j = 0; j < length2; j++) {
String word1 = taggedWords1.get(i).word();
String word2 = taggedWords2.get(j).word();
double edgeWeight = 0;
// LSA Similarity
// edgeWeight = LSASimilarity.LSAWordSimilarity(word1, word2);
// DISCO Similarity
// DISCOSimilarity discoObj = new DISCOSimilarity();
try {
if (word1.compareToIgnoreCase(word2) == 0) edgeWeight = 1;
else {
edgeWeight = discoRAM.similarity2(word1, word2);
// edgeWeight = LSASimilarity.LSAWordSimilarity(word1, word2);
}
} catch (Exception ex) {
ex.printStackTrace();
}
array[i][j] = edgeWeight;
}
}
// System.out.println("Hungarian starts " + arrSize);
double finalScore;
String sumType = "max";
int minLength = Math.min(length1, length2);
finalScore = HungarianAlgorithm.hgAlgorithm(array, sumType) / minLength * 5;
// finalScore = HungarianAlgorithm.hgAlgorithm(array, sumType)/arrSize * 5;
return finalScore;
}
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);
}
public static double LexicalSimilarityScoreMax(
ArrayList<TaggedWord> taggedWords1,
ArrayList<TaggedWord> taggedWords2,
DISCOSimilarity discoRAM,
LexicalizedParser lp) {
// System.out.println(taggedWords1.size() + "," + taggedWords2.size());
// array of edge weights with default weight 0
int length1 = taggedWords1.size();
int length2 = taggedWords2.size();
int arrSize = Math.max(length1, length2);
double[][] array = new double[arrSize][arrSize];
for (int i = 0; i < arrSize; i++) {
for (int j = 0; j < arrSize; j++) {
array[i][j] = 0;
}
}
for (int i = 0; i < length1; i++) {
for (int j = 0; j < length2; j++) {
String word1 = taggedWords1.get(i).word();
String posTag1 = taggedWords1.get(i).tag();
String word2 = taggedWords2.get(j).word();
String posTag2 = taggedWords2.get(j).tag();
ArrayList<TaggedWord> newList1 = new ArrayList<TaggedWord>();
if (posTag1.length() >= 3 && posTag1.substring(0, 3).equals("NNP")) {
newList1.add(taggedWords1.get(i));
} else {
String[] words = word1.split(" ");
for (int k = 0; k < words.length; k++) newList1.add(new TaggedWord(words[k], posTag1));
}
ArrayList<TaggedWord> newList2 = new ArrayList<TaggedWord>();
if (posTag2.length() >= 3 && posTag2.substring(0, 3).equals("NNP")) {
newList2.add(taggedWords2.get(j));
} else {
String[] words = word2.split(" ");
for (int k = 0; k < words.length; k++) newList2.add(new TaggedWord(words[k], posTag2));
}
double edgeWeight = LexicalSimilarityScoreMin(newList1, newList2, discoRAM, lp);
array[i][j] = edgeWeight;
}
}
// System.out.println("Hungarian starts " + arrSize);
double finalScore;
String sumType = "max";
// int minLength = Math.min(length1, length2);
// finalScore = HungarianAlgorithm.hgAlgorithm(array, sumType)/minLength * 5;
finalScore = HungarianAlgorithm.hgAlgorithm(array, sumType) / arrSize * 5;
return finalScore;
}
/**
* returns the node of a tree which represents the lowest common ancestor of nodes t1 and t2
* dominated by root. If either t1 or or t2 is not dominated by root, returns null.
*/
public static Tree getLowestCommonAncestor(Tree t1, Tree t2, Tree root) {
List<Tree> t1Path = pathFromRoot(t1, root);
List<Tree> t2Path = pathFromRoot(t2, root);
if (t1Path == null || t2Path == null) return null;
int min = Math.min(t1Path.size(), t2Path.size());
Tree commonAncestor = null;
for (int i = 0; i < min && t1Path.get(i).equals(t2Path.get(i)); ++i) {
commonAncestor = t1Path.get(i);
}
return commonAncestor;
}
protected void tallyInternalNode(Tree lt, List parents) {
// form base rule
String label = lt.label().value();
Rule baseR = ltToRule(lt);
ruleToLabel.put(baseR, label);
// act on each history depth
for (int depth = 0, maxDepth = Math.min(HISTORY_DEPTH(), parents.size());
depth <= maxDepth;
depth++) {
List history = new ArrayList(parents.subList(0, depth));
// tally each history level / rewrite pair
rulePairs.incrementCount(new Pair(baseR, history), 1);
labelPairs.incrementCount(new Pair(label, history), 1);
}
}
public static double LexicalSimilarity2Level(
String sentence1, String sentence2, DISCOSimilarity discoRAM, LexicalizedParser lp) {
Tree parse1 = lp.apply(sentence1);
Tree parse2 = lp.apply(sentence2);
int phraseSizeLimit = 2;
ArrayList<ArrayList<TaggedWord>> phrasesList1 = getPhrases(parse1, phraseSizeLimit);
ArrayList<ArrayList<TaggedWord>> phrasesList2 = getPhrases(parse2, phraseSizeLimit);
int length1 = phrasesList1.size();
int length2 = phrasesList2.size();
int arrSize = Math.max(length1, length2);
double[][] array = new double[arrSize][arrSize];
for (int i = 0; i < arrSize; i++) {
for (int j = 0; j < arrSize; j++) {
array[i][j] = 0;
}
}
for (int i = 0; i < length1; i++) {
for (int j = 0; j < length2; j++) {
double edgeWeight = 0;
ArrayList<TaggedWord> taggedWords1 = phrasesList1.get(i);
ArrayList<TaggedWord> taggedWords2 = phrasesList2.get(j);
// edgeWeight = LexicalSimilarityScore(taggedWords1, taggedWords2, discoRAM, lp)/5.0;
edgeWeight = BestWordMatchEdgeWeight(taggedWords1, taggedWords2, discoRAM);
array[i][j] = edgeWeight;
}
}
// System.out.println("Hungarian starts " + arrSize);
double finalScore;
String sumType = "max";
// int minLength = Math.min(length1, length2);
// finalScore = HungarianAlgorithm.hgAlgorithm(array, sumType)/minLength * 5;
if (arrSize == 0) finalScore = 0;
else finalScore = HungarianAlgorithm.hgAlgorithm(array, sumType) / arrSize * 5;
return finalScore;
}
/**
* Get the top few clauses from this searcher, cutting off at the given minimum probability.
*
* @param thresholdProbability The threshold under which to stop returning clauses. This should be
* between 0 and 1.
* @return The resulting {@link edu.stanford.nlp.naturalli.SentenceFragment} objects, representing
* the top clauses of the sentence.
*/
public List<SentenceFragment> topClauses(double thresholdProbability) {
List<SentenceFragment> results = new ArrayList<>();
search(
triple -> {
assert triple.first <= 0.0;
double prob = Math.exp(triple.first);
assert prob <= 1.0;
assert prob >= 0.0;
assert !Double.isNaN(prob);
if (prob >= thresholdProbability) {
SentenceFragment fragment = triple.third.get();
fragment.score = prob;
results.add(fragment);
return true;
} else {
return false;
}
});
return results;
}
/** Get lowest common ancestor of all the nodes in the list with the tree rooted at root */
public static Tree getLowestCommonAncestor(List<Tree> nodes, Tree root) {
List<List<Tree>> paths = new ArrayList<List<Tree>>();
int min = Integer.MAX_VALUE;
for (Tree t : nodes) {
List<Tree> path = pathFromRoot(t, root);
if (path == null) return null;
min = Math.min(min, path.size());
paths.add(path);
}
Tree commonAncestor = null;
for (int i = 0; i < min; ++i) {
Tree ancestor = paths.get(0).get(i);
boolean quit = false;
for (List<Tree> path : paths) {
if (!path.get(i).equals(ancestor)) {
quit = true;
break;
}
}
if (quit) break;
commonAncestor = ancestor;
}
return commonAncestor;
}
public static double LexicalSimilarityScoreWordNet(
String sentence1, String sentence2, LeskWSD tm, LexicalizedParser lp, WordNetSimilarity ws) {
ArrayList<TaggedWord> taggedWordsPrev1 = Preprocess(StanfordParse(sentence1, lp));
ArrayList<TaggedWord> taggedWordsPrev2 = Preprocess(StanfordParse(sentence2, lp));
ArrayList<TaggedWord> taggedWords1 = new ArrayList<TaggedWord>();
ArrayList<TaggedWord> taggedWords2 = new ArrayList<TaggedWord>();
WordNetSense[] sensesPrev1 = tm.LeskJWI(sentence1);
WordNetSense[] sensesPrev2 = tm.LeskJWI(sentence2);
// System.out.println("Senses found!");
ArrayList<WordNetSense> senses1 = new ArrayList<WordNetSense>();
ArrayList<WordNetSense> senses2 = new ArrayList<WordNetSense>();
for (int i = 0; i < taggedWordsPrev1.size(); i++) {
String word = taggedWordsPrev1.get(i).word();
String posTag = taggedWordsPrev1.get(i).tag();
if (posTag.length() >= 2 && posTag.substring(0, 2).equals("NN")) {
taggedWords1.add(new TaggedWord(word, "NN"));
senses1.add(sensesPrev1[i]);
} else if (posTag.length() >= 2 && posTag.substring(0, 2).equals("VB")) {
taggedWords1.add(new TaggedWord(word, "VB"));
senses1.add(sensesPrev1[i]);
}
}
for (int i = 0; i < taggedWordsPrev2.size(); i++) {
String word = taggedWordsPrev2.get(i).word();
String posTag = taggedWordsPrev2.get(i).tag();
if (posTag.length() >= 2 && posTag.substring(0, 2).equals("NN")) {
taggedWords2.add(new TaggedWord(word, "NN"));
senses2.add(sensesPrev2[i]);
} else if (posTag.length() >= 2 && posTag.substring(0, 2).equals("VB")) {
taggedWords2.add(new TaggedWord(word, "VB"));
senses2.add(sensesPrev2[i]);
}
}
// System.out.println(taggedWords1.size() + "," + taggedWords2.size());
// array of edge weights with default weight 0
int length1 = taggedWords1.size();
int length2 = taggedWords2.size();
int arrSize = Math.max(length1, length2);
double[][] array = new double[arrSize][arrSize];
for (int i = 0; i < arrSize; i++) {
for (int j = 0; j < arrSize; j++) {
array[i][j] = 0;
}
}
for (int i = 0; i < length1; i++) {
for (int j = 0; j < length2; j++) {
String word1 = taggedWords1.get(i).word();
String posTag1 = taggedWords1.get(i).tag();
String word2 = taggedWords2.get(j).word();
String posTag2 = taggedWords2.get(j).tag();
double edgeWeight = 0;
// LSA Similarity
// edgeWeight = LSASimilarity.LSAWordSimilarity(word1, word2);
// DISCO Similarity
// DISCOSimilarity discoObj = new DISCOSimilarity();
try {
if (word1.compareToIgnoreCase(word2) == 0) edgeWeight = 1;
else {
// edgeWeight = ws.wuPalmerSimilarity(senses1.get(i), senses2.get(j));
edgeWeight = ws.linSimilarity(senses1.get(i), senses2.get(j));
}
} catch (Exception ex) {
ex.printStackTrace();
}
array[i][j] = edgeWeight;
}
}
// System.out.println("Hungarian starts " + arrSize);
double finalScore;
String sumType = "max";
int minLength = Math.min(length1, length2);
// finalScore = HungarianAlgorithm.hgAlgorithm(array, sumType)/minLength * 5;
if (arrSize == 0) finalScore = 0;
else finalScore = HungarianAlgorithm.hgAlgorithm(array, sumType) / arrSize * 5;
return finalScore;
}
/**
* Do max language model markov segmentation. Note that this algorithm inherently tags words as it
* goes, but that we throw away the tags in the final result so that the segmented words are
* untagged. (Note: for a couple of years till Aug 2007, a tagged result was returned, but this
* messed up the parser, because it could use no tagging but the given tagging, which often wasn't
* very good. Or in particular it was a subcategorized tagging which never worked with the current
* forceTags option which assumes that gold taggings are inherently basic taggings.)
*
* @param s A String to segment
* @return The list of segmented words.
*/
private ArrayList<HasWord> segmentWordsWithMarkov(String s) {
int length = s.length();
// Set<String> POSes = (Set<String>) POSDistribution.keySet(); // 1.5
int numTags = POSes.size();
// score of span with initial word of this tag
double[][][] scores = new double[length][length + 1][numTags];
// best (length of) first word for this span with this tag
int[][][] splitBacktrace = new int[length][length + 1][numTags];
// best tag for second word over this span, if first is this tag
int[][][] POSbacktrace = new int[length][length + 1][numTags];
for (int i = 0; i < length; i++) {
for (int j = 0; j < length + 1; j++) {
Arrays.fill(scores[i][j], Double.NEGATIVE_INFINITY);
}
}
// first fill in word probabilities
for (int diff = 1; diff <= 10; diff++) {
for (int start = 0; start + diff <= length; start++) {
int end = start + diff;
StringBuilder wordBuf = new StringBuilder();
for (int pos = start; pos < end; pos++) {
wordBuf.append(s.charAt(pos));
}
String word = wordBuf.toString();
for (String tag : POSes) {
IntTaggedWord itw = new IntTaggedWord(word, tag, wordIndex, tagIndex);
double score = lex.score(itw, 0, word, null);
if (start == 0) {
score += Math.log(initialPOSDist.probabilityOf(tag));
}
scores[start][end][itw.tag()] = score;
splitBacktrace[start][end][itw.tag()] = end;
}
}
}
// now fill in word combination probabilities
for (int diff = 2; diff <= length; diff++) {
for (int start = 0; start + diff <= length; start++) {
int end = start + diff;
for (int split = start + 1; split < end && split - start <= 10; split++) {
for (String tag : POSes) {
int tagNum = tagIndex.indexOf(tag, true);
if (splitBacktrace[start][split][tagNum] != split) {
continue;
}
Distribution<String> rTagDist = markovPOSDists.get(tag);
if (rTagDist == null) {
continue; // this happens with "*" POS
}
for (String rTag : POSes) {
int rTagNum = tagIndex.indexOf(rTag, true);
double newScore =
scores[start][split][tagNum]
+ scores[split][end][rTagNum]
+ Math.log(rTagDist.probabilityOf(rTag));
if (newScore > scores[start][end][tagNum]) {
scores[start][end][tagNum] = newScore;
splitBacktrace[start][end][tagNum] = split;
POSbacktrace[start][end][tagNum] = rTagNum;
}
}
}
}
}
}
int nextPOS = ArrayMath.argmax(scores[0][length]);
ArrayList<HasWord> words = new ArrayList<HasWord>();
int start = 0;
while (start < length) {
int split = splitBacktrace[start][length][nextPOS];
StringBuilder wordBuf = new StringBuilder();
for (int i = start; i < split; i++) {
wordBuf.append(s.charAt(i));
}
String word = wordBuf.toString();
// String tag = tagIndex.get(nextPOS);
// words.add(new TaggedWord(word, tag));
words.add(new Word(word));
if (split < length) {
nextPOS = POSbacktrace[start][length][nextPOS];
}
start = split;
}
return words;
}
// CDM 2007: I wonder what this does differently from segmentWordsWithMarkov???
private ArrayList<TaggedWord> basicSegmentWords(String s) {
int length = s.length();
// Set<String> POSes = (Set<String>) POSDistribution.keySet(); // 1.5
// best score of span
double[][] scores = new double[length][length + 1];
// best (last index of) first word for this span
int[][] splitBacktrace = new int[length][length + 1];
// best tag for word over this span
int[][] POSbacktrace = new int[length][length + 1];
for (int i = 0; i < length; i++) {
Arrays.fill(scores[i], Double.NEGATIVE_INFINITY);
}
// first fill in word probabilities
for (int diff = 1; diff <= 10; diff++) {
for (int start = 0; start + diff <= length; start++) {
int end = start + diff;
StringBuilder wordBuf = new StringBuilder();
for (int pos = start; pos < end; pos++) {
wordBuf.append(s.charAt(pos));
}
String word = wordBuf.toString();
// for (String tag : POSes) { // 1.5
for (Iterator<String> iter = POSes.iterator(); iter.hasNext(); ) {
String tag = iter.next();
IntTaggedWord itw = new IntTaggedWord(word, tag, wordIndex, tagIndex);
double newScore =
lex.score(itw, 0, word, null) + Math.log(lex.getPOSDistribution().probabilityOf(tag));
if (newScore > scores[start][end]) {
scores[start][end] = newScore;
splitBacktrace[start][end] = end;
POSbacktrace[start][end] = itw.tag();
}
}
}
}
// now fill in word combination probabilities
for (int diff = 2; diff <= length; diff++) {
for (int start = 0; start + diff <= length; start++) {
int end = start + diff;
for (int split = start + 1; split < end && split - start <= 10; split++) {
if (splitBacktrace[start][split] != split) {
continue; // only consider words on left
}
double newScore = scores[start][split] + scores[split][end];
if (newScore > scores[start][end]) {
scores[start][end] = newScore;
splitBacktrace[start][end] = split;
}
}
}
}
List<TaggedWord> words = new ArrayList<TaggedWord>();
int start = 0;
while (start < length) {
int end = splitBacktrace[start][length];
StringBuilder wordBuf = new StringBuilder();
for (int pos = start; pos < end; pos++) {
wordBuf.append(s.charAt(pos));
}
String word = wordBuf.toString();
String tag = tagIndex.get(POSbacktrace[start][end]);
words.add(new TaggedWord(word, tag));
start = end;
}
return new ArrayList<TaggedWord>(words);
}
