Java GenericJarClassifierFactory类代码示例

import org.cleartk.ml.jar.GenericJarClassifierFactory; //导入依赖的package包/类
public static void classifyTestFile(String modelDirectory, File testPosFile, String language)
		throws ResourceInitializationException, UIMAException, IOException {

	CollectionReader testPosFileReader = FilesCollectionReader.getCollectionReaderWithSuffixes(testPosFile.getAbsolutePath(),
			NERReader.CONLL_VIEW, testPosFile.getName());

	AnalysisEngine nerReader = createEngine(NERReader.class);
	AnalysisEngine snowballStemmer = createEngine(SnowballStemmer.class, SnowballStemmer.PARAM_LANGUAGE, language);
	AnalysisEngine nerAnnotator = createEngine(NERAnnotator.class,

			NERAnnotator.PARAM_FEATURE_EXTRACTION_FILE, "src/main/resources/feature/features.xml",
			GenericJarClassifierFactory.PARAM_CLASSIFIER_JAR_PATH, modelDirectory + "model.jar");
	AnalysisEngine nerWriter = createEngine(NERWriter.class,
			NERWriter.PARAM_NULL_TYPE, "O",
			NERWriter.PARAM_EXPECTED_ENTITY_TYPE_NUM, 9,
			NERWriter.PARAM_FILENAME, "src/test/resources/evaluation/eval.txt",
			NERWriter.PARAM_VERBOSE, true);
	
	runPipeline(
			testPosFileReader,
			nerReader,
			snowballStemmer,
			nerAnnotator,
			nerWriter);
}
 

import org.cleartk.ml.jar.GenericJarClassifierFactory; //导入依赖的package包/类
public static void main(String[] args) throws Exception {
  Options options = CliFactory.parseArguments(Options.class, args);
  CollectionReader reader = UriCollectionReader.getCollectionReaderFromDirectory(options.getTestDirectory(),
      UriCollectionReader.RejectSystemFiles.class, UriCollectionReader.RejectSystemDirectories.class);
  AggregateBuilder builder = new AggregateBuilder();
  builder.add(UriToDocumentTextAnnotator.getDescription());
  builder.add(SentenceAnnotator.getDescription());
  builder.add(TokenAnnotator.getDescription());
  builder.add(PosTaggerAnnotator.getDescription());
  builder.add(DefaultSnowballStemmer.getDescription("English"));
  builder.add(AnalysisEngineFactory.createEngineDescription(QuestionCategoryAnnotator.class,
      CleartkAnnotator.PARAM_IS_TRAINING, false, GenericJarClassifierFactory.PARAM_CLASSIFIER_JAR_PATH,
      JarClassifierBuilder.getModelJarFile(options.getModelsDirectory())));
  SimplePipeline.runPipeline(reader, builder.createAggregateDescription(),
      AnalysisEngineFactory.createEngineDescription(PrintClassificationsAnnotator.class));
}
 

import org.cleartk.ml.jar.GenericJarClassifierFactory; //导入依赖的package包/类
public static AnalysisEngineDescription getEngineDescription(String genderModelUrl)
		throws ResourceInitializationException {
	String tmpView = "tmp:Dramatis Personae";

	AggregateBuilder b = new AggregateBuilder();

	b.add(AnalysisEngineFactory.createEngineDescription(PrepareClearTk.class, PrepareClearTk.PARAM_VIEW_NAME,
			tmpView, PrepareClearTk.PARAM_ANNOTATION_TYPE, DramatisPersonae.class,
			PrepareClearTk.PARAM_SUBANNOTATIONS, Arrays.asList(Figure.class, FigureType.class)));
	b.add(AnalysisEngineFactory.createEngineDescription(BreakIteratorSegmenter.class,
			BreakIteratorSegmenter.PARAM_WRITE_SENTENCE, false), CAS.NAME_DEFAULT_SOFA, tmpView);
	b.add(AnalysisEngineFactory.createEngineDescription(ClearTkGenderAnnotator.class,
			GenericJarClassifierFactory.PARAM_CLASSIFIER_JAR_PATH, genderModelUrl), CAS.NAME_DEFAULT_SOFA, tmpView);
	b.add(AnalysisEngineFactory.createEngineDescription(MapBackFeature.class, MapBackFeature.PARAM_ANNOTATION_TYPE,
			Figure.class, MapBackFeature.PARAM_VIEW_NAME, tmpView, MapBackFeature.PARAM_FEATURE_NAME, "Gender"));

	return b.createAggregateDescription();
}
 

import org.cleartk.ml.jar.GenericJarClassifierFactory; //导入依赖的package包/类
public static void classifyTestFile(File aClassifierJarPath, File testPosFile, File outputFile,
        File aNodeResultFile, List<Integer> aSentencesIds, String dataZipFile)
            throws UIMAException, IOException
{
    runPipeline(
            FilesCollectionReader.getCollectionReaderWithSuffixes(testPosFile.getAbsolutePath(),
                    NERReader.CONLL_VIEW, testPosFile.getName()),
            createEngine(NERReader.class, NERReader.DATA_ZIP_FILE, dataZipFile),
            createEngine(NERAnnotator.class, NERAnnotator.PARAM_FEATURE_EXTRACTION_FILE,
                    aClassifierJarPath.getAbsolutePath() + "/feature.xml",
                    NERAnnotator.FEATURE_FILE, aClassifierJarPath.getAbsolutePath(),
                    GenericJarClassifierFactory.PARAM_CLASSIFIER_JAR_PATH,
                    aClassifierJarPath.getAbsolutePath() + "/model.jar"),
            createEngine(EvaluatedNERWriter.class, EvaluatedNERWriter.OUTPUT_FILE, outputFile,
                    EvaluatedNERWriter.IS_GOLD, false, EvaluatedNERWriter.NOD_OUTPUT_FILE,
                    aNodeResultFile, EvaluatedNERWriter.SENTENCES_ID, aSentencesIds));
}
 

import org.cleartk.ml.jar.GenericJarClassifierFactory; //导入依赖的package包/类
@Test
public void testAnnotatorDescriptor() throws Exception {
  HideOutput hider = new HideOutput();
  BuildTestExamplePosModel.main();
  hider.restoreOutput();

  String modelFileName = JarClassifierBuilder.getModelJarFile(
      ExamplePosAnnotator.DEFAULT_OUTPUT_DIRECTORY).getPath();
  AnalysisEngineDescription posTaggerDescription = ExamplePosAnnotator.getClassifierDescription(modelFileName);
  AnalysisEngine engine = AnalysisEngineFactory.createEngine(posTaggerDescription);

  Object classifierJar = engine.getConfigParameterValue(GenericJarClassifierFactory.PARAM_CLASSIFIER_JAR_PATH);
  Assert.assertEquals(modelFileName, classifierJar);

  engine.collectionProcessComplete();
}
 

import org.cleartk.ml.jar.GenericJarClassifierFactory; //导入依赖的package包/类
public AggregateBuilder buildExtractAggregate() throws ResourceInitializationException {
  AggregateBuilder builder = new AggregateBuilder();

  builder.add(AnalysisEngineFactory.createEngineDescription(
      XMIReader.class,
      XMIReader.PARAM_XMI_DIRECTORY,
      this.xmiDirectory));

  // This will extract the features for summarization
  builder.add(AnalysisEngineFactory.createEngineDescription(
      SumBasicAnnotator.class,
      CleartkAnnotator.PARAM_IS_TRAINING,
      false,
      GenericJarClassifierFactory.PARAM_CLASSIFIER_JAR_PATH,
      JarClassifierBuilder.getModelJarFile(this.modelDirectory),
      SumBasicAnnotator.PARAM_TOKEN_FIELD,
      this.tokenField.name(),
      SumBasicAnnotator.PARAM_STOPWORDS_URI,
      this.stopwordsFile.toURI()));

  if (this.sentencesOutFile != null && this.outputSentences) {
    builder.add(SummarySentenceWriterAnnotator.getDescription(sentencesOutFile, this.outputScores));
  }
  return builder;
}
 

import org.cleartk.ml.jar.GenericJarClassifierFactory; //导入依赖的package包/类
/**
 * Constructor, creates an AnalysisEngine with a CRF classifier.
 */
public CrfClassifier(String configurationFile) {
    try {
        initialise(configurationFile);
        classifier = createEngine(AspectAnnotator.class,
                GenericJarClassifierFactory.PARAM_CLASSIFIER_JAR_PATH,
                crfModelFolder + "model.jar");

    } catch (ResourceInitializationException e) {
        e.printStackTrace();
    }
}
 

import org.cleartk.ml.jar.GenericJarClassifierFactory; //导入依赖的package包/类
private void classifyTestFile(File testPosFile, String language, String evaluationOutputFile, String featureExtractorConfigFile)
        throws UIMAException, IOException {

    CollectionReader testPosFileReader = FilesCollectionReader.getCollectionReaderWithSuffixes(testPosFile.getAbsolutePath(),
            NERReader.CONLL_VIEW, testPosFile.getName());

    AnalysisEngine nerReader = createEngine(NERReader.class);

    AnalysisEngine snowballStemmer = createEngine(SnowballStemmer.class, SnowballStemmer.PARAM_LANGUAGE, language);

    AnalysisEngine nerAnnotator = createEngine(NERAnnotator.class,
            NERAnnotator.PARAM_FEATURE_EXTRACTION_FILE, FEATURE_EXTRACTOR_CONFIG_DIRECTORY + featureExtractorConfigFile,
            GenericJarClassifierFactory.PARAM_CLASSIFIER_JAR_PATH, getModelDir() + "model.jar");

    AnalysisEngine nerWriter = createEngine(NERWriter.class,
            NERWriter.PARAM_NULL_TYPE, "O",
            NERWriter.PARAM_EXPECTED_ENTITY_TYPE_NUM, 9,
            NERWriter.PARAM_FILENAME, EVALUATION_OUTPUT_DIRECTORY + evaluationOutputFile,
            NERWriter.PARAM_VERBOSE, false);

    runPipeline(
            testPosFileReader,
            nerReader,
            snowballStemmer,
            nerAnnotator,
            nerWriter);
}
 

import org.cleartk.ml.jar.GenericJarClassifierFactory; //导入依赖的package包/类
/**
 * Constructor, creates an AnalysisEngine with a CRF classifier.
 * @param modelDirectory the directory where the model is located
 */
public CrfClassifier(String modelDirectory) {
    try {
        classifier = AnalysisEngineFactory.createEngine(AspectAnnotator.class,
                GenericJarClassifierFactory.PARAM_CLASSIFIER_JAR_PATH,
                modelDirectory + "model.jar");
    } catch (ResourceInitializationException e) {
        e.printStackTrace();
    }
}
 

import org.cleartk.ml.jar.GenericJarClassifierFactory; //导入依赖的package包/类
public static AnalysisEngineDescription getClassifierDescription(String modelFileName)
    throws ResourceInitializationException {
  return AnalysisEngineFactory.createEngineDescription(
      ExamplePosAnnotator.class,
      GenericJarClassifierFactory.PARAM_CLASSIFIER_JAR_PATH,
      modelFileName);
}
 

import org.cleartk.ml.jar.GenericJarClassifierFactory; //导入依赖的package包/类
public static void main(String[] args) throws Exception {
  Options options = CliFactory.parseArguments(Options.class, args);

  // ////////////////////////////////////////
  // Create collection reader to load URIs
  // ////////////////////////////////////////
  CollectionReader reader = UriCollectionReader.getCollectionReaderFromDirectory(
      options.getTestDirectory(),
      UriCollectionReader.RejectSystemFiles.class,
      UriCollectionReader.RejectSystemDirectories.class);

  // ////////////////////////////////////////
  // Create document classification pipeline
  // ////////////////////////////////////////
  AggregateBuilder builder = new AggregateBuilder();

  // Convert URIs in CAS URI View to Plain Text
  builder.add(UriToDocumentTextAnnotator.getDescription());

  // NLP pre-processing components
  builder.add(SentenceAnnotator.getDescription()); // Sentence segmentation
  builder.add(TokenAnnotator.getDescription()); // Tokenization
  builder.add(DefaultSnowballStemmer.getDescription("English")); // Stemming

  // Simple document classification annotator
  builder.add(AnalysisEngineFactory.createEngineDescription(
      BasicDocumentClassificationAnnotator.class,
      CleartkAnnotator.PARAM_IS_TRAINING,
      false,
      GenericJarClassifierFactory.PARAM_CLASSIFIER_JAR_PATH,
      JarClassifierBuilder.getModelJarFile(options.getModelsDirectory())));

  // //////////////////////////////////////////////////////////////////////////////
  // Run pipeline and classify documents
  // //////////////////////////////////////////////////////////////////////////////
  SimplePipeline.runPipeline(
      reader,
      builder.createAggregateDescription(),
      AnalysisEngineFactory.createEngineDescription(PrintClassificationsAnnotator.class));
}
 

import org.cleartk.ml.jar.GenericJarClassifierFactory; //导入依赖的package包/类
public static AnalysisEngineDescription getClassifierDescription(File classifierJarFile)
    throws ResourceInitializationException {
  return AnalysisEngineFactory.createEngineDescription(
      DocumentClassificationAnnotator.class,
      GenericJarClassifierFactory.PARAM_CLASSIFIER_JAR_PATH,
      classifierJarFile.toString());
}
 

import org.cleartk.ml.jar.GenericJarClassifierFactory; //导入依赖的package包/类
public static void main(String[] args) throws Exception {
  Options options = CliFactory.parseArguments(Options.class, args);

  // a reader that loads the URIs of the text file
  CollectionReader reader = UriCollectionReader.getCollectionReaderFromFiles(Arrays.asList(options.getTextFile()));

  // assemble the classification pipeline
  AggregateBuilder aggregate = new AggregateBuilder();

  // an annotator that loads the text from the training file URIs
  aggregate.add(UriToDocumentTextAnnotator.getDescription());

  // annotators that identify sentences, tokens and part-of-speech tags in the text
  aggregate.add(SentenceAnnotator.getDescription());
  aggregate.add(TokenAnnotator.getDescription());
  aggregate.add(PosTaggerAnnotator.getDescription());

  // our NamedEntityChunker annotator, configured to classify on the new texts
  aggregate.add(AnalysisEngineFactory.createEngineDescription(
      NamedEntityChunker.class,
      CleartkSequenceAnnotator.PARAM_IS_TRAINING,
      false,
      GenericJarClassifierFactory.PARAM_CLASSIFIER_JAR_PATH,
      JarClassifierBuilder.getModelJarFile(options.getModelDirectory())));

  // a very simple annotator that just prints out any named entities we found
  aggregate.add(AnalysisEngineFactory.createEngineDescription(PrintNamedEntityMentions.class));

  // run the classification pipeline on the new texts
  SimplePipeline.runPipeline(reader, aggregate.createAggregateDescription());
}
 

import org.cleartk.ml.jar.GenericJarClassifierFactory; //导入依赖的package包/类
public AnalysisEngineDescription getAnnotatorDescription(File directory, Model.Params params)
    throws ResourceInitializationException {
  return AnalysisEngineFactory.createEngineDescription(
  this.annotatorClass,
  GenericJarClassifierFactory.PARAM_CLASSIFIER_JAR_PATH,
  JarClassifierBuilder.getModelJarFile(this.getModelDirectory(directory, params)));
}
 

import org.cleartk.ml.jar.GenericJarClassifierFactory; //导入依赖的package包/类
public AnalysisEngineDescription getAnnotatorDescription(String modelFileName)
    throws ResourceInitializationException {
  AnalysisEngineDescription desc = getBaseDescription();
  ResourceCreationSpecifierFactory.setConfigurationParameters(
      desc,
      GenericJarClassifierFactory.PARAM_CLASSIFIER_JAR_PATH,
      modelFileName);
  return desc;
}