Java NLPGetter类代码示例

import com.clearnlp.nlp.NLPGetter; //导入依赖的package包/类
private static AbstractComponent[] setupComponents() {
    AbstractComponent[] components = null;

    try {
        String language = AbstractReader.LANG_EN;
        String modelType = "general-en";

        AbstractComponent tagger = NLPGetter.getComponent(modelType, language, NLPMode.MODE_POS);
        AbstractComponent morphological = NLPGetter.getComponent(modelType, language, NLPMode.MODE_MORPH);
        AbstractComponent parser = NLPGetter.getComponent(modelType, language, NLPMode.MODE_DEP);
        AbstractComponent identifier = NLPGetter.getComponent(modelType, language, NLPMode.MODE_PRED);
        AbstractComponent classifier = NLPGetter.getComponent(modelType, language, NLPMode.MODE_ROLE);
        AbstractComponent labeler = NLPGetter.getComponent(modelType, language, NLPMode.MODE_SRL);
        components = new AbstractComponent[]{tagger, morphological, parser, identifier, classifier, labeler};//, identifier, classifier, labeler};
    } catch (Exception e) {
        throw new RuntimeException(e);
    }

    return components;
}
 

import com.clearnlp.nlp.NLPGetter; //导入依赖的package包/类
public String call()
{
	AbstractSegmenter segmenter = NLPGetter.getSegmenter(s_language, NLPGetter.getTokenizer(s_language));
	BufferedReader reader = new BufferedReader(new StringReader(s_line));
	StringBuilder build = new StringBuilder();
	
	for (List<String> tokens : segmenter.getSentences(reader))
	{
		if (tokens.size() < 3)	continue;
		build.append(UTArray.join(tokens, "\n"));
		build.append("\n\n");
	}
	
	try
	{
		reader.close();
	}
	catch (IOException e) {e.printStackTrace();}
	
	return build.toString();
}
 

import com.clearnlp.nlp.NLPGetter; //导入依赖的package包/类
public void decode(LineReader reader, PrintStream fout, AbstractTokenizer tokenizer, AbstractComponent[] components)
{
	String sentence, mode = getMode();
	DEPTree tree;

	while ((sentence = reader.next()) != null)
	{
		if (sentence.trim().equals(UNConstant.EMPTY)) continue;
		tree = NLPGetter.toDEPTree(tokenizer.getTokens(sentence));
		
		for (AbstractComponent component : components)
			component.process(tree);
		
		fout.println(toString(tree, mode)+"\n");
	}
}
 

import com.clearnlp.nlp.NLPGetter; //导入依赖的package包/类
public Tokenizer(String[] args)
{
	initArgs(args);
	
	try
	{
		AbstractTokenizer tokenizer = NLPGetter.getTokenizer(s_language);
		AbstractSegmenter segmenter = i_format.equals(AbstractReader.TYPE_RAW) ? NLPGetter.getSegmenter(s_language, tokenizer) : null;
		List<String[]>    filenames = getFilenames(s_inputPath, s_inputExt, s_outputExt);
		boolean outLine = o_format.equals(AbstractReader.TYPE_LINE);
		tokenizer.setTwit(b_twit);
		
		for (String[] io : filenames)
		{
			System.out.println(io[0]);
			tokenize(tokenizer, segmenter, io[0], io[1], outLine);
		}
	}
	catch (IOException e) {e.printStackTrace();}
}
 

import com.clearnlp.nlp.NLPGetter; //导入依赖的package包/类
public void process(AbstractTokenizer tokenizer, AbstractComponent[] components, BufferedReader reader, PrintStream fout)
{
	AbstractSegmenter segmenter = NLPGetter.getSegmenter(language, tokenizer);
	DEPTree tree;
	
	for (List<String> tokens : segmenter.getSentences(reader))
	{
		tree = NLPGetter.toDEPTree(tokens);
		
		for (AbstractComponent component : components)
			component.process(tree);
		
		fout.println(tree.toStringSRL()+"\n");
	}
	
	fout.close();
}
 

import com.clearnlp.nlp.NLPGetter; //导入依赖的package包/类
public DemoCSenTypeClassifierEN(String inputFile, String outputFile) throws Exception
	{
		final String language = AbstractReader.LANG_EN;
		final String modelType = "general-en";
//		final String modelType = "medical-en";
		
		AbstractSegmenter segmenter	 = NLPGetter.getSegmenter(language, NLPGetter.getTokenizer(language));
		AbstractComponent tagger     = NLPGetter.getComponent(modelType, language, NLPMode.MODE_POS);
		AbstractComponent parser     = NLPGetter.getComponent(modelType, language, NLPMode.MODE_DEP);
		CSenTypeClassifierEN typer	 = new CSenTypeClassifierEN();
		
		BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(inputFile)));
		PrintStream fout = new PrintStream(new BufferedOutputStream(new FileOutputStream(outputFile)));
		
		process(reader, fout, segmenter, tagger, parser, typer);
		
		reader.close();
		fout.close();
	}
 

import com.clearnlp.nlp.NLPGetter; //导入依赖的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.nlp.NLPGetter; //导入依赖的package包/类
public DemoMultiParse(String modelType, String inputFile, String outputFile) throws Exception
{
	AbstractTokenizer tokenizer  = NLPGetter.getTokenizer(language);
	AbstractComponent tagger     = NLPGetter.getComponent(modelType, language, NLPMode.MODE_POS);
	AbstractComponent parser     = NLPGetter.getComponent(modelType, language, NLPMode.MODE_DEP);
	AbstractComponent identifier = NLPGetter.getComponent(modelType, language, NLPMode.MODE_PRED);
	AbstractComponent classifier = NLPGetter.getComponent(modelType, language, NLPMode.MODE_ROLE);
	AbstractComponent labeler    = NLPGetter.getComponent(modelType, language, NLPMode.MODE_SRL);
	
	AbstractComponent[] preComponents  = {tagger};	// components used before parsing
	AbstractComponent[] postComponents = {identifier, classifier, labeler};	// components used after parsing
	
	String sentence = "I know you know who I know.";
	process(tokenizer, (AbstractDEPParser)parser, preComponents, postComponents, sentence);
	process(tokenizer, (AbstractDEPParser)parser, preComponents, postComponents, UTInput.createBufferedFileReader(inputFile), UTOutput.createPrintBufferedFileStream(outputFile));
}
 

import com.clearnlp.nlp.NLPGetter; //导入依赖的package包/类
public void loadPosTagger() throws IOException {
	String model_path = prop.getProperty("pos.model");
	if (!model_path.toLowerCase().endsWith(".zip"))
		tagger = (AbstractPOSTagger) NLPGetter.getComponent(model_path, AbstractReader.LANG_EN, NLPMode.MODE_POS);
	else
		tagger = (AbstractPOSTagger) NLPGetter.getComponent(new ZipFile(model_path), AbstractReader.LANG_EN, NLPMode.MODE_POS);
}
 

import com.clearnlp.nlp.NLPGetter; //导入依赖的package包/类
private void loadPredIdentifier() throws IOException {
	String model_path = prop.getProperty("pred.model");
	if (!model_path.toLowerCase().endsWith(".zip"))
		identifier = (AbstractPredicateIdentifier) NLPGetter.getComponent(model_path, AbstractReader.LANG_EN, NLPMode.MODE_PRED);
	else
		identifier = (AbstractPredicateIdentifier) NLPGetter.getComponent(new ZipFile(model_path), AbstractReader.LANG_EN, NLPMode.MODE_PRED);
}
 

import com.clearnlp.nlp.NLPGetter; //导入依赖的package包/类
private void loadRoleClassifier() throws IOException {
	String model_path = prop.getProperty("role.model");
	if (!model_path.toLowerCase().endsWith(".zip"))
		classifier = (AbstractRolesetClassifier) NLPGetter.getComponent(model_path, AbstractReader.LANG_EN, NLPMode.MODE_ROLE);
	else
		classifier = (AbstractRolesetClassifier) NLPGetter.getComponent(new ZipFile(model_path), AbstractReader.LANG_EN, NLPMode.MODE_ROLE);
}
 

import com.clearnlp.nlp.NLPGetter; //导入依赖的package包/类
public void loadSrlLabeler() throws IOException {
	loadPredIdentifier();
	loadRoleClassifier();
	String model_path = prop.getProperty("srl.model");
	if (!model_path.toLowerCase().endsWith(".zip"))
		labeler = (AbstractSRLabeler) NLPGetter.getComponent(model_path, AbstractReader.LANG_EN, NLPMode.MODE_SRL);
	else
		labeler = (AbstractSRLabeler) NLPGetter.getComponent(new ZipFile(model_path), AbstractReader.LANG_EN, NLPMode.MODE_SRL);
}
 

import com.clearnlp.nlp.NLPGetter; //导入依赖的package包/类
/**
 * Main function
 * 
 * @param args
 * @throws Exception
 */
public static void main(String[] args) throws Exception {
	// data input
	String text = "Samsung Electronics is a South Korean multinational electronics company in Suwon, South Korea.";

	// model loading
	ClearNlpWrapper nlp = new ClearNlpWrapper(Env.CLEARNLP_CFG);
	nlp.loadAll("tokenize, ssplit, pos, parse, srl");

	// task run
	for (List<String> toks : nlp.detect(text)) {
		DEPTree units = NLPGetter.toDEPTree(toks);
		units = nlp.tag(units);
		units = nlp.parse(units);
		units = nlp.label(units);

		System.out.println("-toStringSRL--------------------------------------------------------------------");
		System.out.println(units.toStringSRL());

		System.out.println("-dependent Nodes----------------------------------------------------------------");
		StringBuffer sb = new StringBuffer();
		for (DEPNode verb : ClearNlpWrapper.getAllVerbs(units)) {
			sb.append("->(Verb) " + ClearNlpWrapper.toTaggedWord(verb) + "\n");
			for (SRLNode dep : ClearNlpWrapper.getDependents(verb)) {
				Map<String, Object> m = dep.toMap();
				sb.append(String.format("  ->(Node) id=%d, form=%s, pos=%s, drel=%s",
					m.get("id"), m.get("form"), m.get("pos"), m.get("drel")));
				if (m.get("srel") != null)
					sb.append(String.format(", srel=%s, sfunc=%s", m.get("srel"), m.get("sfunc")));
				sb.append("\n");
			}
		}
		System.out.println(JString.trimAndIndent(sb.toString(), 2));
	}
}
 

import com.clearnlp.nlp.NLPGetter; //导入依赖的package包/类
/**
 * ClearNlpWrapper Test for basic functions
 * 
 * @throws IOException
 */
public void testClearNlpWrapperForBasic() throws IOException {
	System.out.println("\n----- testClearNlpWrapperForBasic() ------------------------------");
	if (!TEST_BASIC)
		return;

	String text = "Samsung Electronics is a South Korean multinational electronics company in Suwon, South Korea.";
	text += " It is the flagship subsidiary of the Samsung Group.";

	ClearNlpWrapper nlp = new ClearNlpWrapper(Env.CLEARNLP_CFG);
	nlp.loadAll("tokenize, ssplit, pos, parse");
	assertTrue(nlp.tokenizer != null);
	assertTrue(nlp.detector != null);
	assertTrue(nlp.tagger != null);
	assertTrue(nlp.parser != null);

	assertEquals(2, nlp.detect(text).size());
	for (List<String> words : nlp.detect(text)) {
		DEPTree units = NLPGetter.toDEPTree(words);
		System.out.println("\n[Sentence] " + JString.join(" ", words));
		assertEquals(words.size(), ClearNlpWrapper.toTaggedWords(nlp.tag(units)).size());
		System.out.println("  <Tagged> " + JString.join(" ", ClearNlpWrapper.toTaggedWords(nlp.tag(units))));
		assertEquals(words.size(), ClearNlpWrapper.toTypedDependencies(nlp.parse(units)).size());
		System.out.println("  <Parsed> " + JString.join("; ", ClearNlpWrapper.toTypedDependencies(nlp.parse(units))));

		System.out.println("-parsed SemanticGraph-----------------------------------------------------------");
		SemanticGraph sgraph = StanfordNlpWrapper.toSemanticGraph(ClearNlpWrapper.toTypedDependencies(nlp.parse(units)), false);
		assertEquals(words.size(), JString.trimAndIndent(sgraph.toString(), 2).split("\n").length);
		System.out.println(JString.trimAndIndent(sgraph.toString(), 2));
	}
}
 

import com.clearnlp.nlp.NLPGetter; //导入依赖的package包/类
protected AbstractSegmenter getSegmenter(Element eConfig, boolean twit) throws IOException
{
	AbstractTokenizer tokenizer = getTokenizer(eConfig, twit);
	String language = getLanguage(eConfig);
	
	return NLPGetter.getSegmenter(language, tokenizer);
}