Java Synset类代码示例

import edu.smu.tspell.wordnet.Synset; //导入依赖的package包/类
public static String[] getSenseBag(Synset synset) {
    String senseBag = "";

    VerbSynset verbSynset = (VerbSynset) synset;
    senseBag += getSynsetBag(verbSynset);

    VerbSynset[] troponyms = verbSynset.getTroponyms();
    for (VerbSynset troponym : troponyms)
        senseBag += getSynsetBag(troponym);

    VerbSynset[] entailments = verbSynset.getEntailments();
    for (VerbSynset entailment : entailments)
        senseBag += getSynsetBag(entailment);

    VerbSynset[] outcomes = verbSynset.getOutcomes();
    for (VerbSynset outcome : outcomes)
        senseBag += getSynsetBag(outcome);

    VerbSynset[] hypernyms = verbSynset.getHypernyms();
    for (VerbSynset hypernym : hypernyms)
        senseBag += getSynsetBag(hypernym);

    return extractWordsFromSenseBag(senseBag);
}
 

import edu.smu.tspell.wordnet.Synset; //导入依赖的package包/类
public static String[] getSenseBag(Synset synset, String word) {
    String senseBag = "";

    AdverbSynset adverbSynset = (AdverbSynset) synset;
    senseBag += getSynsetBag(adverbSynset);

    NounSynset[] topics = adverbSynset.getTopics();
    for (NounSynset topic : topics)
        senseBag += getSynsetBag(topic);

    WordSense[] pertainyms = adverbSynset.getPertainyms(word);
    for (WordSense pertainym : pertainyms)
        senseBag += getSynsetBag(pertainym.getSynset());

    WordSense[] antonyms = adverbSynset.getAntonyms(word);
    for (WordSense antonym : antonyms)
        senseBag += getSynsetBag(antonym.getSynset());

    return extractWordsFromSenseBag(senseBag);
}
 

import edu.smu.tspell.wordnet.Synset; //导入依赖的package包/类
public static String[] getSenseBag(Synset synset) {
    String senseBag = "";

    NounSynset nounSynset = (NounSynset) synset;
    senseBag += getSynsetBag(nounSynset);

    NounSynset[] hyponyms = nounSynset.getHyponyms();
    for (NounSynset hyponym : hyponyms)
        senseBag += getSynsetBag(hyponym);

    NounSynset[] meronyms = nounSynset.getMemberMeronyms();
    for (NounSynset meronym : meronyms)
        senseBag += getSynsetBag(meronym);

    return extractWordsFromSenseBag(senseBag);
}
 

import edu.smu.tspell.wordnet.Synset; //导入依赖的package包/类
private static String[] getSenseBag(Synset synset, String word) {
    if(synset == null)
        return new String[0];

    SynsetType pos = synset.getType();

    if(pos == SynsetType.NOUN) {
        return NounSenseBag.getSenseBag(synset);
    } else if (pos == SynsetType.VERB) {
        return VerbSenseBag.getSenseBag(synset);
    } else if(pos == SynsetType.ADJECTIVE) {
        return AdjectiveSenseBag.getSenseBag(synset, word);
    } else if(pos == SynsetType.ADJECTIVE_SATELLITE) {
        return AdjectiveSenseBag.getSenseBag(synset, word);
    } else if(pos == SynsetType.ADVERB) {
        return AdverbSenseBag.getSenseBag(synset, word);
    }

    return new String[0];
}
 

import edu.smu.tspell.wordnet.Synset; //导入依赖的package包/类
public double computeSimilarity(Synset synset1, String word1, Synset synset2, String word2){
    SynsetType pos1 = null, pos2 = null;

    try {
        pos1 = synset1.getType();
        pos2 = synset2.getType();
    } catch(Exception e){
        System.out.printf("ok");
    }

    if(pos1 == SynsetType.NOUN && pos2 == SynsetType.NOUN) {
        return NounSimilarity.similarity(synset1, synset2);
    } else if(pos1 == SynsetType.VERB && pos2 == SynsetType.VERB) {
        return VerbSimilarity.similarity(synset1, synset2);
    } else if(AdjectiveSimilarity.synsetTypeAdjective(pos1, pos2)) {
        return AdjectiveSimilarity.similarity(synset1, word1, synset2, word2);
    } else if(pos1 == SynsetType.ADVERB && pos2 == SynsetType.ADVERB) {
        return AdverbSimilarity.similarity(synset1, word1, synset2, word2);
    } else {
        return SynsetSimilarity.similarity(synset1, synset2);
    }
}
 

import edu.smu.tspell.wordnet.Synset; //导入依赖的package包/类
/**
 * Extract from WordNet Database the synsets of a word
 * @param wnDatabase WordNet Database
 * @param word The word that we want to extract its synsets
 * @param synsetType POS Tag of the word
 * @return Array of Synsets
 */
public static Synset[] getSynsetsFromWord(WordNetDatabase wnDatabase, String word, SynsetType synsetType) {
    Synset[] tmpSynsets;

    if(synsetType == null)
        tmpSynsets = wnDatabase.getSynsets(word);
    else {
        tmpSynsets = wnDatabase.getSynsets(word, synsetType);

        // If the synset type is an adjective, check for adjective satellite too
        if (synsetType == SynsetType.ADJECTIVE) {
            tmpSynsets = (Synset[])ArrayUtils.addAll(tmpSynsets, wnDatabase.getSynsets(word, SynsetType.ADJECTIVE_SATELLITE));
        }
    }

    return tmpSynsets;
}
 

import edu.smu.tspell.wordnet.Synset; //导入依赖的package包/类
public Synset[] convertFinalSynsets(String[] finalSenses){
    int wordIndex, senseIndex;
    String[] split;
    Synset[] synsets = new Synset[finalSenses.length];

    for (int i = 0; i < finalSenses.length; i++) {
        if(finalSenses[i] == null){
            synsets[i] = null;
        } else {
            split = finalSenses[i].split("-");

            wordIndex = Integer.parseInt(split[0]);
            senseIndex = Integer.parseInt(split[1]);

            synsets[i] = getSynset(wordIndex, senseIndex);
        }
    }

    return synsets;
}
 

import edu.smu.tspell.wordnet.Synset; //导入依赖的package包/类
public static boolean isMostlyNounInWordNet(String word) {
	Synset[] synsets = database.getSynsets(word);
	if (synsets.length == 0) {
		return true;
	}
	Synset[] n_synsets = database.getSynsets(word, SynsetType.NOUN);
	Synset[] v_synsets = database.getSynsets(word, SynsetType.VERB);
	Synset[] a_synsets = database.getSynsets(word, SynsetType.ADJECTIVE);
	Synset[] ad_synsets = database.getSynsets(word, SynsetType.ADVERB);
	//		System.out.println(word + " " + n_synsets.length + " " + a_synsets.length + ad_synsets.length);
	if (n_synsets.length != 0 && n_synsets.length > a_synsets.length && 
			n_synsets.length > ad_synsets.length) {// && n_synsets.length > v_synsets.length) {
		return true;
	}
	return false;
}
 

import edu.smu.tspell.wordnet.Synset; //导入依赖的package包/类
public static boolean isMostlyAdjectiveInWordNet(String word) {
	Synset[] synsets = database.getSynsets(word);
	if (synsets.length == 0) {
		return true;
	}
	Synset[] n_synsets = database.getSynsets(word, SynsetType.NOUN);
	Synset[] v_synsets = database.getSynsets(word, SynsetType.VERB);
	Synset[] a_synsets = database.getSynsets(word, SynsetType.ADJECTIVE);
	Synset[] ad_synsets = database.getSynsets(word, SynsetType.ADVERB);
	//		System.out.println(word + " " + n_synsets.length + " " + a_synsets.length + ad_synsets.length);
	if (a_synsets.length != 0 && a_synsets.length > n_synsets.length && 
			a_synsets.length > ad_synsets.length && a_synsets.length > v_synsets.length) {
		return true;
	}
	return false;
}
 

import edu.smu.tspell.wordnet.Synset; //导入依赖的package包/类
public static boolean canWordBeNounOrAdjInWordNet(String word) {
	Synset[] synsets = database.getSynsets(word, SynsetType.NOUN);
	if (synsets.length == 0) {
		synsets = database.getSynsets(word, SynsetType.ADJECTIVE);
		if (synsets.length == 0) {
			synsets = database.getSynsets(word);
			if (synsets.length == 0 && word.length() > 3) {
				return true;
			}
			return false;
		} else {
			return true;
		}
	} else {
		return true;
	}
}
 

import edu.smu.tspell.wordnet.Synset; //导入依赖的package包/类
/**
 * Converts unresolved pointers of a particular type to resolved
 * references to the corresponding synsets.
 * <br><p>
 * Note that on successful completion of this method that the pointers
 * that were resolved will be removed. This is done to reduce memory
 * usage since the pointers are presumed to no longer be needed given
 * that their sole purpose was to provide eventual access to their
 * corresponding synsets.
 * 
 * @param  type Type of relationships to resolve and return.
 * @return Synsets that were referenced by pointers or <code>null</code>
 *         if no pointers existed for the specified type.
 * @throws WordNetException An error occurred retrieving data.
 */
private Synset[] resolvePointers(RelationshipType type)
		throws WordNetException
{
	Synset[] synsets = null;
	SynsetPointer[] pointers = getPointers(type);
	if (pointers != null)
	{
		SynsetFactory factory = SynsetFactory.getInstance();
		synsets = new Synset[pointers.length];
		for (int i = 0; i < synsets.length; i++)
		{
			synsets[i] = factory.getSynset(pointers[i]);
		}
		clearPointers(type);
	}
	return synsets;
}
 

import edu.smu.tspell.wordnet.Synset; //导入依赖的package包/类
protected static String getSenseKeysBag(Synset synset) {
    String senseBag = "";

    String[] senseKeys = synset.getSenseKeys();
    for(String senseKey : senseKeys) {
        senseBag += senseKey.split("%")[0] + " ";
    }

    return senseBag;
}
 

import edu.smu.tspell.wordnet.Synset; //导入依赖的package包/类
protected static String getSynsetBag(Synset synset) {
    String senseBag = " ";
    String[] examples;

    senseBag += getSenseKeysBag(synset);
    senseBag += synset.getDefinition();
    examples = synset.getUsageExamples();

    for (String example1 : examples)
        senseBag += " " + example1;

    return senseBag;
}
 

import edu.smu.tspell.wordnet.Synset; //导入依赖的package包/类
public double computeSimilarity(Synset synset1, String word1, Synset synset2, String word2){
    INDArray[] senseEmbeddings = new INDArray[2];
    senseEmbeddings[0] = Nd4j.create(SenseEmbedding.getSenseEmbedding(wordVectors, synset1, word1, senseComputation));
    senseEmbeddings[1] = Nd4j.create(SenseEmbedding.getSenseEmbedding(wordVectors, synset2, word2, senseComputation));

    return computeSimilarity(senseEmbeddings, null, null, 0, 1);
}
 

import edu.smu.tspell.wordnet.Synset; //导入依赖的package包/类
/**
 * Generates the sense embedding for each synset of every word from the context window
 */
public Object[] computeSynsetRepresentations(Synset[] windowWordsSynsets, String[] windowWords, int[] synset2WordIndex) {
    Object[] windowWordsSenseEmbeddings = new INDArray[windowWordsSynsets.length];
    for (int k = 0; k < windowWordsSynsets.length; k++) {
        windowWordsSenseEmbeddings[k] = Nd4j.create(SenseEmbedding.getSenseEmbedding(wordVectors, windowWordsSynsets[k], windowWords[synset2WordIndex[k]], senseComputation));
    }

    return windowWordsSenseEmbeddings;
}