Java DEPTree类代码示例

import com.clearnlp.dependency.DEPTree; //导入依赖的package包/类
@Override
public void countAccuracy(DEPTree sTree, Object[] gSHeads)
{
	StringIntPair[][] heads = (StringIntPair[][])gSHeads;
	int i, size = sTree.size();
	StringIntPair[] gHeads;
	List<SRLArc>    sHeads;
	
	for (i=1; i<size; i++)
	{
		sHeads = sTree.get(i).getSHeads();
		gHeads = heads[i];
		
		p_total += sHeads.size();
		r_total += gHeads.length;
		
		for (StringIntPair p : gHeads)
			for (DEPArc arc : sHeads)
				if (arc.getNode().id == p.i && arc.isLabel(p.s))
					n_correct++;
	}
}
 

import com.clearnlp.dependency.DEPTree; //导入依赖的package包/类
@SuppressWarnings("deprecation")
public void testPrint()
{
	String filename = "src/test/resources/generation/manner.txt";
	SRLReader fin = new SRLReader(0, 1, 2, 3, 4, 5, 6, 7);
	fin.open(UTInput.createBufferedFileReader(filename));
	LGAnswerGenerator lg = new LGAnswerGenerator();
	DEPTree rTree, qTree;
	
	int[] rVerbIDs = {2}, qVerbIDs = {6};
	
	rTree = fin.next();
	rTree.setDependents();
	DEPLibEn.postLabel(rTree);
	
	System.out.println("D:"+rTree.toStringRaw());
	
	int i; for (i=0; (qTree = fin.next()) != null; i++)
	{
		qTree.setDependents();
		DEPLibEn.postLabel(qTree);
		System.out.println("--------");
		System.out.println("Q:"+qTree.toStringRaw());
		System.out.println("A:"+lg.getAnswer(qTree, rTree, qVerbIDs[i], rVerbIDs[i], " "));
	}
}
 

import com.clearnlp.dependency.DEPTree; //导入依赖的package包/类
protected List<DEPTree> getTrees(JointReader reader, String[] filenames)
{
	List<DEPTree> trees = Lists.newArrayList();
	DEPTree tree;
	
	for (String filename : filenames)
	{
		reader.open(UTInput.createBufferedFileReader(filename));
		
		while ((tree = reader.next()) != null)
			trees.add(tree);
		
		reader.close();
	}
	
	return trees;
}
 

import com.clearnlp.dependency.DEPTree; //导入依赖的package包/类
static public String generateSentenceFromImperative(String prefix, DEPTree tree, boolean switchUnI) 
{
	tree = tree.clone();
	tree.setDependents();
	if (switchUnI) LGLibEn.convertUnI(tree);
	if (prefix.isEmpty())	LGLibEn.convertFirstFormToUpperCase(tree);
	else					LGLibEn.convertFirstFormToLowerCase(tree);
	
	StringBuilder build = new StringBuilder();
	
	build.append(prefix);
	build.append(UNConstant.SPACE);
	build.append(LGLibEn.getForms(tree, false, UNConstant.SPACE));
	
	DEPNode last = tree.get(tree.size()-1);
	
	if (!last.isPos(CTLibEn.POS_PERIOD))
		build.append(UNPunct.PERIOD);
	
	return build.toString();
}
 

import com.clearnlp.dependency.DEPTree; //导入依赖的package包/类
public void process(BufferedReader reader, PrintStream fout, AbstractSegmenter segmenter, AbstractComponent tagger, AbstractComponent parser, CSenTypeClassifierEN typer)
{
	DEPTree tree;
	
	for (List<String> tokens : segmenter.getSentences(reader))
	{
		tree = NLPGetter.toDEPTree(tokens);		// put tokens into dependency tree
		tagger.process(tree);					// part-of-speech tagging
		parser.process(tree);					// dependency parsing
		tree.setDependents();
		
		for (DEPNode root : tree.getRoots())
		{
			if (typer.isInterrogative(root))
			{
				fout.println(UTArray.join(tokens, " ")+"\n");
				fout.println(tree.toStringDEP()+"\n");
				break;
			}
		}
	}
}
 

import com.clearnlp.dependency.DEPTree; //导入依赖的package包/类
/** {@link LGAsk#generateAskFromQuestion(DEPTree, String)}. */
private void convertYouToUser(DEPTree tree, DEPNode head)
{
	if (head.isLemma(ENPronoun.YOU) || head.isLemma(ENPronoun.YOURSELF))
	{
		head.form = head.lemma = USER;
		head.pos  = CTLibEn.POS_NN;
		matchUserVerb(head);
		tree.add(tree.indexOf(head), getNode(head, UNConstant.THE, UNConstant.THE, CTLibEn.POS_DT, DEPLibEn.DEP_DET, null));
	}
	else if (head.isLemma(ENPronoun.YOUR) || head.isLemma(ENPronoun.YOURS))
	{
		int idx = tree.indexOf(head);
		
		head.form = head.lemma = USER;
		head.pos  = CTLibEn.POS_NN;
		
		tree.add(idx  , getNode(head, UNConstant.THE, UNConstant.THE, CTLibEn.POS_DT, DEPLibEn.DEP_DET, null));
		tree.add(idx+2, getNode(head, UNConstant.APOSTROPHE_S, UNConstant.APOSTROPHE_S, CTLibEn.POS_POS, DEPLibEn.DEP_POSSESSIVE, null));
	}
	
	for (DEPArc arc : head.getDependents())
		convertYouToUser(tree, arc.getNode());
}
 

import com.clearnlp.dependency.DEPTree; //导入依赖的package包/类
/** Generates a question from a declarative sentence with "ask". */
public DEPTree generateQuestionFromAsk(DEPTree tree)
{
	tree = tree.clone();
	tree.setDependents();
	
	DEPNode root = tree.getFirstRoot();
	if (root == null) return null;
	DEPNode dep, dobj = null;
	
	for (DEPArc arc : root.getDependents())
	{
		dep = arc.getNode();
		
		if (MPLibEn.isVerb(dep.pos))
			return generateQuestion(dep, getPrevDependents(tree, root, dep));
		else if (dep.isLabel(DEPLibEn.DEP_DOBJ))
			dobj = dep;
	}
	
	if (dobj != null && (dep = dobj.getFirstDependentByLabel(DEPLibEn.DEP_CCOMP)) != null)
		return generateQuestion(dep, null);
	
	return null;
}
 

import com.clearnlp.dependency.DEPTree; //导入依赖的package包/类
private List<DEPNode> getPrevDependents(DEPTree tree, DEPNode root, DEPNode verb)
{
	List<DEPNode> list = Lists.newArrayList();
	int i, size = root.id;
	DEPNode node;
	
	for (i=1; i<size; i++)
	{
		node = tree.get(i);
		
		if (node.isDependentOf(root))
		{
			node.setHead(verb);
			list.addAll(node.getSubNodeSortedList());				
		}
	}
	
	return list;
}
 

import com.clearnlp.dependency.DEPTree; //导入依赖的package包/类
/** Called by {@link LGAsk#generateQuestionFromAsk(DEPTree, String)}. */
public DEPTree generateQuestion(DEPNode verb, List<DEPNode> prevNodes)
{
	Set<DEPNode> added = new HashSet<DEPNode>();
	DEPTree tree = new DEPTree();
	DEPNode rel, aux;
	
	if (prevNodes != null)
	{
		tree.addAll(prevNodes);
		added.addAll(prevNodes);
	}
	
	verb.setHead(tree.get(0), DEPLibEn.DEP_ROOT);
	rel = setRelativizer(tree, verb, added);
	
	aux = setAuxiliary(tree, verb, added, rel);
	setRest(tree, verb, added);
	resetDEPTree(tree, verb);
	if (aux != null) matchNumber(verb, aux);
	
	return tree;
}
 

import com.clearnlp.dependency.DEPTree; //导入依赖的package包/类
public List<Pair<String,String>> getShortAnswers(List<DEPTree> rTrees, List<ArgInfo> rArgs, String conjunction, String delim, boolean verbose, boolean trivialize)
{
	List<Pair<String,String>> answers = new ArrayList<Pair<String,String>>();
	Pair<DEPTree,SRLTree> p;
	ArgInfo rArg;
	int i;
	
	for (i=rTrees.size()-1; i>=0; i--)
	{
		rArg = rArgs.get(i);
		p = getTrees(rTrees.get(i), rArg.getPredicateId());
		answers.add(getShortAnswer(p.o1, p.o2, rArg, delim, verbose, trivialize));
		rTrees.set(i, p.o1);
	}
	
	return answers;
}
 

import com.clearnlp.dependency.DEPTree; //导入依赖的package包/类
@Deprecated
public String getAnswer(DEPTree qdTree, DEPTree rdTree, int qVerbID, int rVerbID, String delim)
{
	qdTree = qdTree.clone();	qdTree.setDependents();
	rdTree = rdTree.clone();	rdTree.setDependents();
	
	SRLTree qsTree = qdTree.getSRLTree(qVerbID);
	SRLTree rsTree = rdTree.getSRLTree(rVerbID);
	
	stripUnnecessaries(rsTree.getPredicate());
	SRLLib.relinkRelativeClause(rsTree);
	SRLLib.relinkCoordination(rsTree);
	LGLibEn.convertUnI(qdTree);
	LGLibEn.convertUnI(rdTree);

	if (isShortAnswer(qsTree, rsTree))
		return getShortAnswer(qdTree, rdTree, qsTree, rsTree, delim);
	else
		return getLongAnswer(qdTree, qsTree, rsTree.getPredicate(), delim);
}
 

import com.clearnlp.dependency.DEPTree; //导入依赖的package包/类
static public String getForms(DEPTree tree, boolean useCoref, String delim)
{
	StringBuilder build = new StringBuilder();
	int i, size = tree.size();
	DEPNode prev = null, curr;
	String s;

	for (i=1; i<size; i++)
	{
		curr = tree.get(i);
		addForm(build, curr, prev, useCoref, delim);
		prev = curr;
	}

	s = build.toString();
	
	if (s.startsWith(delim))
		s = s.substring(delim.length());
	
	return UTString.convertFirstCharToUpper(s);
}
 

import com.clearnlp.dependency.DEPTree; //导入依赖的package包/类
/** Called by {@link #process(DEPTree)}. */
private TagState initialize(DEPTree tree, byte flag)
{
	TagState state = new TagState(tree);
	simplifyForms(tree, flag);
	
	if (flag != FLAG_DECODE)
	{
		state.setGoldLabels(tree.getPOSTags());
		
		if (flag != FLAG_COLLECT)
			tree.clearPOSTags();
	}
	
	return state;
}
 

import com.clearnlp.dependency.DEPTree; //导入依赖的package包/类
/** Sets semantic heads of the specific dependency tree given the input lines. */
private void setSHeads(List<String[]> lines, DEPTree tree)
{
	int i, headId, size = tree.size();
	String heads, label;
	String[] tmp;
	DEPNode node;
	
	tree.initSHeads();

	for (i=1; i<size; i++)
	{
		node  = tree.get(i);
		heads = lines.get(i-1)[i_sheads];
		if (heads.equals(AbstractColumnReader.BLANK_COLUMN))	continue;

		for (String head : heads.split(DEPLib.DELIM_HEADS))
		{
			tmp    = head.split(DEPLib.DELIM_HEADS_KEY);
			headId = Integer.parseInt(tmp[0]);
			label  = tmp[1];
			
			node.addSHead(tree.get(headId), label);				
		}
	}
}
 

import com.clearnlp.dependency.DEPTree; //导入依赖的package包/类
@Override
public DEPTree next()
{
	DEPTree tree = null;
	
	try
	{
		List<String[]> lines = readLines();
		if (lines == null)	return null;
		
		tree = getDAG(lines);
	}
	catch (Exception e) {e.printStackTrace();}
	
	return tree;
}