Java AnnotationStatistics类代码示例

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

  List<File> trainFiles = getFilesFromDirectory(options.getTrainDirectory());
  List<File> testFiles = getFilesFromDirectory(options.getTestDirectory());

  QuestionCategoryEvaluation evaluation =
      new QuestionCategoryEvaluation(options.getModelsDirectory(), options.getTrainingArguments());

  // Run Cross Validation
  List<AnnotationStatistics<String>> foldStats = evaluation.crossValidation(trainFiles, 2);
  AnnotationStatistics<String> crossValidationStats = AnnotationStatistics.addAll(foldStats);

  System.err.println("Cross Validation Results:");
  System.err.print(crossValidationStats);
  System.err.println();
  System.err.println(crossValidationStats.confusions());
  System.err.println();

  // Run Holdout Set
  AnnotationStatistics<String> holdoutStats = evaluation.trainAndTest(trainFiles, testFiles);
  System.err.println("Holdout Set Results:");
  System.err.print(holdoutStats);
  System.err.println();
  System.err.println(holdoutStats.confusions());
}
 

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

	// find training files
	List<File> allFiles = Arrays.asList(options.getTrainDirectory().listFiles(new FilenameFilter() {

		@Override
		public boolean accept(File dir, String name) {
			return name.endsWith("xmi");
		}
	}));

	AbstractEvaluation evaluator = new Evaluation(options.getModelsDirectory());
	List<AnnotationStatistics<String>> crossValidationStatsList = evaluator.crossValidation(allFiles, 5); // .trainAndTest(trainFiles,
	AnnotationStatistics<String> crossValidationStats = AnnotationStatistics.addAll(crossValidationStatsList);

	System.out.println(crossValidationStats);
	System.out.println(ClearTkUtil.toCmdLine(crossValidationStats.confusions()));
}
 

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

	// find training files
	List<File> trainFiles = Arrays.asList(options.getTrainDirectory().listFiles());

	System.err.println(trainFiles.toString());
	MentionDetectionEvaluation evaluator = new MentionDetectionEvaluation(options.getModelsDirectory());
	AnnotationStatistics<String> crossValidationStats = evaluator.trainAndTest(trainFiles, trainFiles);// AnnotationStatistics.addAll(foldStats);

	System.err.println("Cross Validation Results:");
	System.err.print(crossValidationStats);
	System.err.println();
	System.err.println(crossValidationStats.confusions());
	System.err.println();

}
 

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

  // find training files
  List<File> trainFiles = new ArrayList<File>(FileUtils.listFiles(
      options.getTrainDirectory(),
      new MascTextFileFilter(),
      FileFilterUtils.falseFileFilter()));

  // run cross validation
  EvaluateNamedEntityChunker evaluator = new EvaluateNamedEntityChunker(
      options.getModelsDirectory());
  List<AnnotationStatistics<String>> foldStats = evaluator.crossValidation(trainFiles, 2);
  AnnotationStatistics<String> crossValidationStats = AnnotationStatistics.addAll(foldStats);

  System.err.println("Cross Validation Results:");
  System.err.print(crossValidationStats);
  System.err.println();
  System.err.println(crossValidationStats.confusions());
  System.err.println();

  // train and save a model using all the data
  evaluator.trainAndTest(trainFiles, Collections.<File> emptyList());
}
 

import org.cleartk.eval.AnnotationStatistics; //导入依赖的package包/类
public ModelInfo(
    Class<ANNOTATION_TYPE> annotatedClass,
    String annotatedFeatureName,
    Function<ANNOTATION_TYPE, ? extends Object> getSpan,
    CleartkInternalModelFactory modelFactory,
    String[] trainingArguments) {
  this.annotatedClass = annotatedClass;
  this.annotatedFeatureName = annotatedFeatureName;
  this.getSpan = getSpan;
  if (this.annotatedFeatureName == null) {
    this.getOutcome = AnnotationStatistics.annotationToNull();
  } else {
    this.getOutcome = AnnotationStatistics.annotationToFeatureValue(this.annotatedFeatureName);
  }
  this.modelFactory = modelFactory;
  this.trainingArguments = trainingArguments;
}
 

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

  List<File> trainFiles = getFilesFromDirectory(options.getTrainDirectory());
  List<File> testFiles = getFilesFromDirectory(options.getTestDirectory());

  DocumentClassificationEvaluation evaluation = new DocumentClassificationEvaluation(
      options.getModelsDirectory(),
      options.getTrainingArguments());

  // Run Cross Validation
  List<AnnotationStatistics<String>> foldStats = evaluation.crossValidation(trainFiles, 2);
  AnnotationStatistics<String> crossValidationStats = AnnotationStatistics.addAll(foldStats);

  System.err.println("Cross Validation Results:");
  System.err.print(crossValidationStats);
  System.err.println();
  System.err.println(crossValidationStats.confusions());
  System.err.println();

  // Run Holdout Set
  AnnotationStatistics<String> holdoutStats = evaluation.trainAndTest(trainFiles, testFiles);
  System.err.println("Holdout Set Results:");
  System.err.print(holdoutStats);
  System.err.println();
  System.err.println(holdoutStats.confusions());
}
 

import org.cleartk.eval.AnnotationStatistics; //导入依赖的package包/类
@Override
protected AnnotationStatistics<String> test(CollectionReader collectionReader, File directory)
    throws Exception {
  AnnotationStatistics<String> stats = new AnnotationStatistics<String>();

  // Create the document classification pipeline
  AggregateBuilder builder = DocumentClassificationEvaluation.createDocumentClassificationAggregate(
      directory,
      AnnotatorMode.TEST);
  AnalysisEngine engine = builder.createAggregate();

  // Run and evaluate
  Function<UsenetDocument, ?> getSpan = AnnotationStatistics.annotationToSpan();
  Function<UsenetDocument, String> getCategory = AnnotationStatistics.annotationToFeatureValue("category");
  JCasIterator iter = new JCasIterator(collectionReader, engine);
  while (iter.hasNext()) {
    JCas jCas = iter.next();
    JCas goldView = jCas.getView(GOLD_VIEW_NAME);
    JCas systemView = jCas.getView(DocumentClassificationEvaluation.SYSTEM_VIEW_NAME);

    // Get results from system and gold views, and update results accordingly
    Collection<UsenetDocument> goldCategories = JCasUtil.select(goldView, UsenetDocument.class);
    Collection<UsenetDocument> systemCategories = JCasUtil.select(
        systemView,
        UsenetDocument.class);
    stats.add(goldCategories, systemCategories, getSpan, getCategory);
  }

  return stats;
}
 

import org.cleartk.eval.AnnotationStatistics; //导入依赖的package包/类
public EventModelInfo(
    String annotatedFeatureName,
    CleartkInternalModelFactory modelFactory,
    String[] trainingArguments) {
  super(
      Event.class,
      annotatedFeatureName,
      AnnotationStatistics.<Event> annotationToSpan(),
      modelFactory,
      trainingArguments);
}
 

import org.cleartk.eval.AnnotationStatistics; //导入依赖的package包/类
public void updateStatistics(
    AnnotationStatistics<String> statistics,
    JCas goldView,
    JCas systemView) {
  Collection<ANNOTATION_TYPE> goldAnns = JCasUtil.select(goldView, this.annotatedClass);
  Collection<ANNOTATION_TYPE> systemAnns = JCasUtil.select(systemView, this.annotatedClass);
  statistics.add(
      goldAnns,
      systemAnns,
      this.getSpan,
      this.getOutcome);
}
 

import org.cleartk.eval.AnnotationStatistics; //导入依赖的package包/类
public TimeModelInfo(
    String annotatedFeatureName,
    CleartkInternalModelFactory modelFactory,
    String[] trainingArguments) {
  super(
      Time.class,
      annotatedFeatureName,
      AnnotationStatistics.<Time> annotationToSpan(),
      modelFactory,
      trainingArguments);
}
 

import org.cleartk.eval.AnnotationStatistics; //导入依赖的package包/类
@Override
protected AnnotationStatistics<String> test(CollectionReader collectionReader, File directory) throws Exception {
  AnnotationStatistics<String> stats = new AnnotationStatistics<String>();

  AggregateBuilder builder = new AggregateBuilder();

  final String defaultViewName = CAS.NAME_DEFAULT_SOFA;
  final String goldViewName = "GoldView";
  builder.add(AnalysisEngineFactory.createEngineDescription(ViewCreatorAnnotator.class,
      ViewCreatorAnnotator.PARAM_VIEW_NAME, goldViewName));
  builder.add(UriToDocumentTextAnnotator.getDescription(), defaultViewName, goldViewName);
  builder.add(AnalysisEngineFactory.createEngineDescription(GoldQuestionCategoryAnnotator.class), defaultViewName,
      goldViewName);
  builder.add(UriToDocumentTextAnnotator.getDescription());
  builder.add(SentenceAnnotator.getDescription());
  builder.add(TokenAnnotator.getDescription());
  builder.add(PosTaggerAnnotator.getDescription());
  builder.add(DefaultSnowballStemmer.getDescription("English"));
  AnalysisEngineDescription documentClassificationAnnotator = AnalysisEngineFactory.createEngineDescription(
      QuestionCategoryAnnotator.class, CleartkAnnotator.PARAM_IS_TRAINING, false,
      GenericJarClassifierFactory.PARAM_CLASSIFIER_JAR_PATH, JarClassifierBuilder.getModelJarFile(directory));
  builder.add(documentClassificationAnnotator);

  AnalysisEngine engine = builder.createAggregate();

  // Run and evaluate
  Function<QuestionCategoryAnnotation, ?> getSpan = AnnotationStatistics.annotationToSpan();
  Function<QuestionCategoryAnnotation, String> getCategory =
      AnnotationStatistics.annotationToFeatureValue("category");
  JCasIterator iter = new JCasIterator(collectionReader, engine);
  while (iter.hasNext()) {
    JCas jCas = iter.next();
    JCas goldView = jCas.getView(goldViewName);
    JCas systemView = jCas.getView(defaultViewName);
    // Get results from system and gold views, and update results accordingly
    Collection<QuestionCategoryAnnotation> goldCategories =
        JCasUtil.select(goldView, QuestionCategoryAnnotation.class);
    Collection<QuestionCategoryAnnotation> systemCategories =
        JCasUtil.select(systemView, QuestionCategoryAnnotation.class);
    stats.add(goldCategories, systemCategories, getSpan, getCategory);
  }

  return stats;
}
 

import org.cleartk.eval.AnnotationStatistics; //导入依赖的package包/类
@Override
protected AnnotationStatistics<String> test(CollectionReader collectionReader, File modelDirectory)
		throws Exception {

	final String silverViewName = "DP";
	final String goldViewName = "GoldView";

	// define the pipeline
	AggregateBuilder aggregate = new AggregateBuilder();

	// Annotators processing the gold view:
	// * create the gold view
	// * load the text
	// * load the MASC annotations
	aggregate.add(AnalysisEngineFactory.createEngineDescription(PrepareClearTk.class,
			PrepareClearTk.PARAM_VIEW_NAME, goldViewName, PrepareClearTk.PARAM_ANNOTATION_TYPE,
			DramatisPersonae.class, PrepareClearTk.PARAM_SUBANNOTATIONS, Arrays.asList(Figure.class)));

	// Annotators processing the default (system) view:
	// * load the text
	// * parse sentences, tokens, part-of-speech tags
	// * run the named entity chunker
	aggregate.add(AnalysisEngineFactory.createEngineDescription(PrepareClearTk.class,
			PrepareClearTk.PARAM_VIEW_NAME, silverViewName, PrepareClearTk.PARAM_ANNOTATION_TYPE,
			DramatisPersonae.class, PrepareClearTk.PARAM_SUBANNOTATIONS, Arrays.asList(Figure.class)));
	aggregate.add(AnalysisEngineFactory.createEngineDescription(BreakIteratorSegmenter.class,
			BreakIteratorSegmenter.PARAM_WRITE_SENTENCE, false), CAS.NAME_DEFAULT_SOFA, silverViewName);
	aggregate.add(
			AnalysisEngineFactory.createEngineDescription(tagger, CleartkSequenceAnnotator.PARAM_IS_TRAINING, false,
					GenericJarClassifierFactory.PARAM_CLASSIFIER_JAR_PATH,
					JarClassifierBuilder.getModelJarFile(modelDirectory)),
			CAS.NAME_DEFAULT_SOFA, silverViewName);
	aggregate.add(AnalysisEngineFactory.createEngineDescription(XmiWriter.class, XmiWriter.PARAM_TARGET_LOCATION,
			"target/debug/", XmiWriter.PARAM_USE_DOCUMENT_ID, true));

	// prepare the evaluation statistics
	AnnotationStatistics<String> stats = new AnnotationStatistics<String>();
	// Function<FigureMention, ?> getSpan =
	// AnnotationStatistics.annotationToSpan();

	// iterate over each JCas to be evaluated
	JCasIterator iter = new JCasIterator(collectionReader, aggregate.createAggregate());
	while (iter.hasNext()) {
		JCas jCas = iter.next();
		JCas goldView = jCas.getView(goldViewName);
		JCas systemView = jCas.getView(silverViewName);

		// extract the named entity mentions from both gold and system views
		Collection<Figure> goldMentions, systemMentions;
		goldMentions = JCasUtil.select(goldView, Figure.class);
		systemMentions = JCasUtil.select(systemView, Figure.class);

		// compare the system mentions to the gold mentions
		stats.add(goldMentions, systemMentions, AnnotationStatistics.annotationToSpan(),
				AnnotationStatistics.annotationToFeatureValue("Gender"));
	}

	return stats;
}
 

import org.cleartk.eval.AnnotationStatistics; //导入依赖的package包/类
@Override
protected AnnotationStatistics<String> test(CollectionReader collectionReader, File modelDirectory)
		throws Exception {

	final String defaultViewName = CAS.NAME_DEFAULT_SOFA;
	final String goldViewName = "GoldView";

	// define the pipeline
	AggregateBuilder aggregate = new AggregateBuilder();

	// Annotators processing the gold view:
	// * create the gold view
	// * load the text
	// * load the MASC annotations
	aggregate.add(AnalysisEngineFactory.createEngineDescription(PrepareEvaluation.class,
			PrepareEvaluation.PARAM_GOLD_VIEW_NAME, goldViewName));

	// Annotators processing the default (system) view:
	// * load the text
	// * parse sentences, tokens, part-of-speech tags
	// * run the named entity chunker
	aggregate.add(AnalysisEngineFactory.createEngineDescription(ClearTkMentionAnnotator.class,
			CleartkSequenceAnnotator.PARAM_IS_TRAINING, false,
			GenericJarClassifierFactory.PARAM_CLASSIFIER_JAR_PATH,
			JarClassifierBuilder.getModelJarFile(modelDirectory)));
	aggregate.add(AnalysisEngineFactory.createEngineDescription(ClearAnnotation.class, ClearAnnotation.PARAM_TYPE,
			TrainingArea.class));
	aggregate.add(AnalysisEngineFactory.createEngineDescription(XmiWriter.class, XmiWriter.PARAM_TARGET_LOCATION,
			"target/debug/", XmiWriter.PARAM_USE_DOCUMENT_ID, true));

	// prepare the evaluation statistics
	AnnotationStatistics<String> stats = new AnnotationStatistics<String>();
	// Function<FigureMention, ?> getSpan =
	// AnnotationStatistics.annotationToSpan();

	// iterate over each JCas to be evaluated
	JCasIterator iter = new JCasIterator(collectionReader, aggregate.createAggregate());
	while (iter.hasNext()) {
		JCas jCas = iter.next();
		JCas goldView = jCas.getView(goldViewName);
		JCas systemView = jCas.getView(defaultViewName);

		// extract the named entity mentions from both gold and system views
		Collection<FigureMention> goldMentions, systemMentions;
		goldMentions = JCasUtil.select(goldView, FigureMention.class);
		systemMentions = JCasUtil.select(systemView, FigureMention.class);

		// compare the system mentions to the gold mentions
		stats.add(goldMentions, systemMentions);
	}

	return stats;
}
 

import org.cleartk.eval.AnnotationStatistics; //导入依赖的package包/类
@Override
protected AnnotationStatistics<String> test(CollectionReader collectionReader, File modelDirectory)
    throws Exception {

  final String defaultViewName = CAS.NAME_DEFAULT_SOFA;
  final String goldViewName = "GoldView";

  // define the pipeline
  AggregateBuilder aggregate = new AggregateBuilder();

  // Annotators processing the gold view:
  // * create the gold view
  // * load the text
  // * load the MASC annotations
  aggregate.add(AnalysisEngineFactory.createEngineDescription(
      ViewCreatorAnnotator.class,
      ViewCreatorAnnotator.PARAM_VIEW_NAME,
      goldViewName));
  aggregate.add(UriToDocumentTextAnnotator.getDescription(), defaultViewName, goldViewName);
  aggregate.add(MascGoldAnnotator.getDescription(), defaultViewName, goldViewName);

  // Annotators processing the default (system) view:
  // * load the text
  // * parse sentences, tokens, part-of-speech tags
  // * run the named entity chunker
  aggregate.add(UriToDocumentTextAnnotator.getDescription());
  aggregate.add(SentenceAnnotator.getDescription());
  aggregate.add(TokenAnnotator.getDescription());
  aggregate.add(PosTaggerAnnotator.getDescription());
  aggregate.add(AnalysisEngineFactory.createEngineDescription(
      NamedEntityChunker.class,
      CleartkSequenceAnnotator.PARAM_IS_TRAINING,
      false,
      GenericJarClassifierFactory.PARAM_CLASSIFIER_JAR_PATH,
      JarClassifierBuilder.getModelJarFile(modelDirectory)));

  // prepare the evaluation statistics
  AnnotationStatistics<String> stats = new AnnotationStatistics<String>();
  Function<NamedEntityMention, ?> getSpan = AnnotationStatistics.annotationToSpan();
  Function<NamedEntityMention, String> getCategory = AnnotationStatistics.annotationToFeatureValue("mentionType");

  // iterate over each JCas to be evaluated
  JCasIterator iter = new JCasIterator(collectionReader, aggregate.createAggregate());
  while (iter.hasNext()) {
    JCas jCas = iter.next();
    JCas goldView = jCas.getView(goldViewName);
    JCas systemView = jCas.getView(defaultViewName);

    // extract the named entity mentions from both gold and system views
    Collection<NamedEntityMention> goldMentions, systemMentions;
    goldMentions = JCasUtil.select(goldView, NamedEntityMention.class);
    systemMentions = JCasUtil.select(systemView, NamedEntityMention.class);

    // compare the system mentions to the gold mentions
    stats.add(goldMentions, systemMentions, getSpan, getCategory);
  }

  return stats;
}