Java Predicate类代码示例

import se.lth.cs.srl.corpus.Predicate; //导入依赖的package包/类
@Override
public String getCoreArgumentLabelSequence(Predicate pred,Map<Word, String> proposition) {
	Sentence s=pred.getMySentence();
	StringBuffer ret=new StringBuffer();
	for(int i=1;i<s.size();++i){
		Word w=s.get(i);
		if(pred==w){
			ret.append(" ").append(pred.getSense());
			if(useVoice)
				ret.append(isPassive(pred)?"/P":"/A"); 
		}
		if(proposition.containsKey(w)){
			Matcher m=CALSPattern.matcher(proposition.get(w));
			if(m.matches())
				ret.append(" ").append(m.group(1));
		}
	}
	return ret.toString();
}
 

import se.lth.cs.srl.corpus.Predicate; //导入依赖的package包/类
@Override
public String getDefaultSense(Predicate pred) {
	String PFeat=pred.getFeats();
	String label;
	if(PFeat.contains("postype=auxiliary")){
		label="c2";
	} else if(PFeat.contains("postype=common")) {
		label="a2";
	} else if(PFeat.contains("postype=main")) {
		label="a2";
	} else if(PFeat.contains("postype=qualificative")) {
		label="b2";
	} else if(PFeat.contains("postype=semiauxiliary")) {
		label="c2";
	} else {
		label="a2";
	}
	return pred.getLemma()+"."+label;
}
 

import se.lth.cs.srl.corpus.Predicate; //导入依赖的package包/类
@Override
public String getCoreArgumentLabelSequence(Predicate pred, Map<Word, String> proposition) {
	Sentence sen=pred.getMySentence();
	StringBuilder ret=new StringBuilder();
	for(int i=1,size=sen.size();i<size;++i){
		Word word=sen.get(i);
		if(pred==word){
			ret.append(" "+pred.getSense()+"/");
			ret.append(isPassiveVoice(pred) ? "P" : "A");
		} //Don't make this else if, since the predicate can also be its on argument
		if(proposition.containsKey(word)){
			String label=proposition.get(word);
			if(CALSPattern.matcher(label).matches())
				ret.append(" "+label);
		}
	}
	return ret.toString();
}
 

import se.lth.cs.srl.corpus.Predicate; //导入依赖的package包/类
private void addInstance(Predicate pred, LearningProblem lp) {
	String POSPrefix = getPOSPrefix(pred);
	if (POSPrefix == null) {
		POSPrefix = featureSet.POSPrefixes[0];
	}
	Collection<Integer> indices = new TreeSet<Integer>();
	Map<Integer, Double> nonbinFeats = new TreeMap<Integer, Double>();
	Integer offset = 0;
	for (Feature f : featureSet.get(POSPrefix)) {
		f.addFeatures(indices, nonbinFeats, pred, null, offset, false);
		offset += f.size(false);
	}
	Integer label = predicateReference.getLabel(pred.getLemma(), POSPrefix,
			pred.getSense());
	lp.addInstance(label, indices, nonbinFeats);
}
 

import se.lth.cs.srl.corpus.Predicate; //导入依赖的package包/类
@Override
public String getCoreArgumentLabelSequence(Predicate pred,Map<Word, String> proposition) {
	Sentence sen=pred.getMySentence();
	StringBuilder ret=new StringBuilder();
	for(int i=1,size=sen.size();i<size;++i){
		Word word=sen.get(i);
		if(pred==word){
			ret.append(" "+pred.getSense()+"/");
			ret.append(isPassiveVoice(pred) ? "P" : "A");
		}
		if(proposition.containsKey(word)){
			ret.append(" "+proposition.get(word));
		}
	}
	
	
	return ret.toString();
}
 

import se.lth.cs.srl.corpus.Predicate; //导入依赖的package包/类
public static double score(Sentence gold, Sentence parsed) {
	if (gold.getPredicates().size() == 0
			&& parsed.getPredicates().size() == 0)
		return 1;
	int tp = 0, fp = 0;
	for (Predicate pred : parsed.getPredicates()) {
		int index = parsed.indexOf(pred);
		if (gold.get(index) instanceof Predicate
				&& ((Predicate) gold.get(index)).getSense().equals(
						pred.getSense())) {
			tp++;
		} else {
			fp++;
		}
	}
	double p = (double) tp / (tp + fp);
	double r = (double) tp / (tp + fp);
	if (p + r > 0)
		return 2 * p * r / (p + r);
	else
		return 0;
}
 

import se.lth.cs.srl.corpus.Predicate; //导入依赖的package包/类
@Override
public void train() {
	models = new HashMap<String, Model>();
	// Here we need to do them one at a time, thats the whole reason why we
	// collected the Map<String,List<Predicate>> instances map. Otherwise we
	// would easily run out of filehandles.
	Iterator<String> it = instances.keySet().iterator();
	while (it.hasNext()) {
		String key = it.next();
		File dataFile = new File(Learn.learnOptions.tempDir, FILE_PREFIX
				+ key);
		LibLinearLearningProblem lp = new LibLinearLearningProblem(
				dataFile, false);
		for (Predicate pred : instances.get(key)) {
			addInstance(pred, lp);
		}
		lp.done();
		Model m = lp.train(true);
		models.put(key, m);
		it.remove(); // This way we should lose references to the words and
						// sentences we no longer need, and the gc should be
						// able to clean this up for us.
	}
}
 

import se.lth.cs.srl.corpus.Predicate; //导入依赖的package包/类
/**
 * This method works with features that have includeArgs==false. It extracts either from all words (if boolean allWords is true), or from the predicates only (if false)
 */
@Override
protected void performFeatureExtraction(Sentence s, boolean allWords) {
	if(includeArgs){
		throw new Error("You are wrong here, check your implementation.");
	} else {
		if(allWords){
			for(int i=1,size=s.size();i<size;++i)
				if(doExtractFeatures(s.get(i)))
					addMap(getFeatureString(s,i,-1));
		} else {
			for(Predicate pred:s.getPredicates())
				if(doExtractFeatures(pred))
					addMap(getFeatureString(pred,null));
		}			
	}
}
 

import se.lth.cs.srl.corpus.Predicate; //导入依赖的package包/类
@Override
public void parse(Sentence s) {
	for (Predicate pred : s.getPredicates()) {
		// System.err.println("Looking for arguments of " + pred.getSense()
		// + " ...");
		for (int i = 1, size = s.size(); i < size; ++i) {
			Word arg = s.get(i);

			Integer label = super.classifyInstance(pred, arg);
			if (label.equals(POSITIVE)) {
				pred.addArgMap(arg, "ARG");
			}

			// System.err.print(label.equals(POSITIVE)?"1":"0");
			// System.err.print(" " + arg.getForm() + ": ");
			// for(Word w : Word.findPath(pred, arg)) {
			// System.err.print(w.getDeprel() + " ");
			// }
			// System.err.println();
		}
	}

}
 

import se.lth.cs.srl.corpus.Predicate; //导入依赖的package包/类
@Override
	public void train() {
		models=new HashMap<String,Model>();
		//Here we need to do them one at a time, thats the whole reason why we collected the Map<String,List<Predicate>> instances map. Otherwise we would easily run out of filehandles.
		Iterator<String> it=instances.keySet().iterator();
		while(it.hasNext()){
			String key=it.next();
			File dataFile=new File(Learn.learnOptions.tempDir,FILE_PREFIX+key);
			LibLinearLearningProblem lp=new LibLinearLearningProblem(dataFile,false);
			for(Predicate pred:instances.get(key)){
//				if(pred.getLemma().equals("import"))
//					System.out.println("here");
				addInstance(pred,lp);
			}
			lp.done();
			Model m=lp.train(true);
			models.put(key,m);
			it.remove(); //This way we should lose references to the words and sentences we no longer need, and the gc should be able to clean this up for us.
		}
	}
 

import se.lth.cs.srl.corpus.Predicate; //导入依赖的package包/类
public static void extractLabels(Iterable<Sentence> reader,PredicateReference predicateReference,List<String> argLabels) {
	if(predicateReference==null && argLabels==null)
		return;
	System.out.println("Extracting argument labels and predicate senses.");
	Set<String> argLabelSet=new HashSet<String>();
	for(Sentence s:reader){
		for(Predicate p:s.getPredicates()){
			if(predicateReference!=null)
				predicateReference.extractSense(p);
			if(argLabels!=null)
				argLabelSet.addAll(p.getArgMap().values());
		}
	}
	if(argLabels!=null)
		argLabels.addAll(argLabelSet);
	if(predicateReference!=null)
		predicateReference.trim();
}
 

import se.lth.cs.srl.corpus.Predicate; //导入依赖的package包/类
@Override
public String getCoreArgumentLabelSequence(Predicate pred,
		Map<Word, String> proposition) {
	Sentence s = pred.getMySentence();
	StringBuffer ret = new StringBuffer();
	for (int i = 1; i < s.size(); ++i) {
		Word w = s.get(i);
		if (pred == w) {
			ret.append(" ").append(pred.getSense());
			if (useVoice)
				ret.append(isPassive(pred) ? "/P" : "/A");
		}
		if (proposition.containsKey(w)) {
			Matcher m = CALSPattern.matcher(proposition.get(w));
			if (m.matches())
				ret.append(" ").append(m.group(1));
		}
	}
	return ret.toString();
}
 

import se.lth.cs.srl.corpus.Predicate; //导入依赖的package包/类
@Override
public String getDefaultSense(Predicate pred) {
	String PFeat = pred.getFeats();
	String label;
	if (PFeat.contains("postype=auxiliary")) {
		label = "c2";
	} else if (PFeat.contains("postype=common")) {
		label = "a2";
	} else if (PFeat.contains("postype=main")) {
		label = "a2";
	} else if (PFeat.contains("postype=qualificative")) {
		label = "b2";
	} else if (PFeat.contains("postype=semiauxiliary")) {
		label = "c2";
	} else {
		label = "a2";
	}
	return pred.getLemma() + "." + label;
}
 

import se.lth.cs.srl.corpus.Predicate; //导入依赖的package包/类
@Override
public void addFeatures(Collection<Integer> indices,
		Map<Integer, Double> nonbinFeats, Predicate pred, Word arg,
		Integer offset, boolean allWords) {
	Integer i = indexOf(getFeatureString(pred, arg));
	Double d = f1.getFeatureValue(pred, arg);
	if (i != -1 && (allWords || i < predMaxIndex))
		nonbinFeats.put(i + offset, d);
}
 

import se.lth.cs.srl.corpus.Predicate; //导入依赖的package包/类
@Override
public String getLexiconURL(Predicate pred) {
	if(pred.getPOS().startsWith("V")){
		return "http://verbs.colorado.edu/propbank/framesets-english/"+pred.getLemma()+"-v.html";
	} else {
		return "http://nlp.cs.nyu.edu/meyers/nombank/nombank.1.0/frames/"+pred.getLemma()+".xml";
	}
}