Java Instance.getOutcome方法代码示例

import org.cleartk.ml.Instance; //导入方法依赖的package包/类
@Override
public Instance<OUTCOME_T> transform(Instance<OUTCOME_T> instance) {
  List<Feature> features = new ArrayList<Feature>();
  List<Feature> featuresToTransform = new ArrayList<Feature>();
  for (Feature feature : instance.getFeatures()) {
    if (this.isTransformable(feature)) {
      // Store off features for later similarity computation
      featuresToTransform.addAll(((TransformableFeature) feature).getFeatures());
    } else {
      // pass through non-transformable features
      features.add(feature);
    }
  }

  // Create centroid similarity feature
  Map<String, Double> featureMap = this.featuresToFeatureMap(featuresToTransform);
  features.add(new Feature(this.name, new Double(this.simFunction.distance(
      featureMap,
      centroidMap))));

  return new Instance<OUTCOME_T>(instance.getOutcome(), features);
}
 

import org.cleartk.ml.Instance; //导入方法依赖的package包/类
@Override
public void train(Iterable<Instance<OUTCOME_T>> instances) {
  // aggregate statistics for all features and classes
  this.mutualInfoStats = new MutualInformationStats<OUTCOME_T>(this.smoothingCount);

  for (Instance<OUTCOME_T> instance : instances) {
    OUTCOME_T outcome = instance.getOutcome();
    for (Feature feature : instance.getFeatures()) {
      if (this.isTransformable(feature)) {
        for (Feature untransformedFeature : ((TransformableFeature) feature).getFeatures()) {
          mutualInfoStats.update(this.nameFeature(untransformedFeature), outcome, 1);
        }
      }
    }
  }
  // Compute mutual information score for each feature
  Set<String> featureNames = mutualInfoStats.classConditionalCounts.rowKeySet();

  this.selectedFeatures = Ordering.natural().onResultOf(
      this.mutualInfoStats.getScoreFunction(
          this.combineScoreMethod)).reverse().immutableSortedCopy(featureNames);
  this.isTrained = true;
}
 

import org.cleartk.ml.Instance; //导入方法依赖的package包/类
@Override
public Instance<OUTCOME_T> transform(Instance<OUTCOME_T> instance) {
  List<Feature> features = new ArrayList<Feature>();
  for (Feature feature : instance.getFeatures()) {
    if (this.isTransformable(feature)) {
      for (Feature origFeature : ((TransformableFeature) feature).getFeatures()) {
        features.add(this.transform(origFeature));
      }
    } else {
      features.add(feature);
    }
  }
  return new Instance<OUTCOME_T>(instance.getOutcome(), features);
}
 

import org.cleartk.ml.Instance; //导入方法依赖的package包/类
@Override
public Instance<OUTCOME_T> transform(Instance<OUTCOME_T> instance) {
  List<Feature> features = new ArrayList<Feature>();
  for (Feature feature : instance.getFeatures()) {
    if (this.isTransformable(feature)) {
      // Filter down to selected features
      features.addAll(Collections2.filter(((TransformableFeature) feature).getFeatures(), this));
    } else {
      // Pass non-relevant features through w/o filtering
      features.add(feature);
    }
  }
  return new Instance<OUTCOME_T>(instance.getOutcome(), features);
}
 

import org.cleartk.ml.Instance; //导入方法依赖的package包/类
@Test
public void testBinaryLIBSVM() throws Exception {
  // create the data writer
  BooleanAnnotator annotator = new BooleanAnnotator();
  annotator.initialize(UimaContextFactory.createUimaContext(
      DirectoryDataWriterFactory.PARAM_OUTPUT_DIRECTORY,
      this.outputDirectoryName,
      DefaultDataWriterFactory.PARAM_DATA_WRITER_CLASS_NAME,
      LibSvmBooleanOutcomeDataWriter.class.getName()));

  // run process to produce a bunch of instances
  annotator.process(null);

  annotator.collectionProcessComplete();

  // check that the output file was written and is not empty
  BufferedReader reader = new BufferedReader(new FileReader(new File(
      this.outputDirectoryName,
      "training-data.libsvm")));
  Assert.assertTrue(reader.readLine().length() > 0);
  reader.close();

  // run the training command
  HideOutput hider = new HideOutput();
  Train.main(this.outputDirectoryName, "-c", "1.0", "-s", "0", "-t", "0");
  hider.restoreOutput();

  // read in the classifier and test it on new instances
  LibSvmBooleanOutcomeClassifierBuilder builder = new LibSvmBooleanOutcomeClassifierBuilder();
  LibSvmBooleanOutcomeClassifier classifier;
  classifier = builder.loadClassifierFromTrainingDirectory(this.outputDirectory);
  for (Instance<Boolean> instance : ExampleInstanceFactory.generateBooleanInstances(1000)) {
    List<Feature> features = instance.getFeatures();
    Boolean outcome = instance.getOutcome();
    Assert.assertEquals(outcome, classifier.classify(features));

    Map<Boolean, Double> scoredOutcomes = classifier.score(features);
    Assert.assertTrue(scoredOutcomes.get(outcome) > scoredOutcomes.get(!outcome));
  }
}
 

import org.cleartk.ml.Instance; //导入方法依赖的package包/类
@Test
public void testBooleanOutcomeLIBLINEAR() throws Exception {
  // create the data writer
  BooleanAnnotator annotator = new BooleanAnnotator();
  annotator.initialize(UimaContextFactory.createUimaContext(
      DirectoryDataWriterFactory.PARAM_OUTPUT_DIRECTORY,
      this.outputDirectoryName,
      DefaultDataWriterFactory.PARAM_DATA_WRITER_CLASS_NAME,
      LibLinearBooleanOutcomeDataWriter.class.getName()));

  // run process to produce a bunch of instances
  annotator.process(null);

  annotator.collectionProcessComplete();

  // check that the output file was written and is not empty
  LibLinearBooleanOutcomeClassifierBuilder builder = new LibLinearBooleanOutcomeClassifierBuilder();
  BufferedReader reader = new BufferedReader(new FileReader(
      builder.getTrainingDataFile(this.outputDirectory)));
  Assert.assertTrue(reader.readLine().length() > 0);
  reader.close();

  // run the training command
  HideOutput hider = new HideOutput();
  Train.main(this.outputDirectoryName, "-c", "1.0", "-s", "1");
  hider.restoreOutput();

  // read in the classifier and test it on new instances
  LibLinearBooleanOutcomeClassifier classifier;
  classifier = builder.loadClassifierFromTrainingDirectory(this.outputDirectory);
  for (Instance<Boolean> instance : ExampleInstanceFactory.generateBooleanInstances(1000)) {
    List<Feature> features = instance.getFeatures();
    Boolean outcome = instance.getOutcome();
    Assert.assertEquals(outcome, classifier.classify(features));
    Map<Boolean, Double> scoredOutcomes = classifier.score(features);
    Assert.assertTrue(scoredOutcomes.get(outcome) > scoredOutcomes.get(!outcome));
  }
}
 

import org.cleartk.ml.Instance; //导入方法依赖的package包/类
@Override
public void write(Instance<OUTCOME_TYPE> instance) throws CleartkProcessingException {
  if (instance.getOutcome() == null) {
    throw CleartkProcessingException.noInstanceOutcome(instance.getFeatures());
  }
  String outcome = this.classifierBuilder.getOutcomeEncoder().encode(instance.getOutcome());
  ContextValues contextValues = this.classifierBuilder.getFeaturesEncoder().encodeAll(instance.getFeatures());
  this.trainingDataWriter.printf("%s %s\n", outcome, contextValues.toMaxentString());
}
 

import org.cleartk.ml.Instance; //导入方法依赖的package包/类
@Test
public void testMultiClassLIBSVM() throws Exception {
  // create the data writer
  StringAnnotator annotator = new StringAnnotator();
  annotator.initialize(UimaContextFactory.createUimaContext(
      DirectoryDataWriterFactory.PARAM_OUTPUT_DIRECTORY,
      this.outputDirectoryName,
      DefaultDataWriterFactory.PARAM_DATA_WRITER_CLASS_NAME,
      LibSvmStringOutcomeDataWriter.class.getName()));

  // run process to produce a bunch of instances
  annotator.process(null);

  annotator.collectionProcessComplete();

  // check that the output files were written for each class
  BufferedReader reader = new BufferedReader(new FileReader(new File(
      this.outputDirectoryName,
      "training-data.libsvm")));
  Assert.assertTrue(reader.readLine().length() > 0);
  reader.close();

  // run the training command
  HideOutput hider = new HideOutput();
  Train.main(this.outputDirectoryName, "-c", "10", "-t", "0");
  hider.restoreOutput();

  // read in the classifier and test it on new instances
  LibSvmStringOutcomeClassifierBuilder builder = new LibSvmStringOutcomeClassifierBuilder();
  LibSvmStringOutcomeClassifier classifier;
  classifier = builder.loadClassifierFromTrainingDirectory(this.outputDirectory);
  for (Instance<String> instance : ExampleInstanceFactory.generateStringInstances(1000)) {
    List<Feature> features = instance.getFeatures();
    String outcome = instance.getOutcome();
    Assert.assertEquals(outcome, classifier.classify(features));

    Map<String, Double> scoredOutcomes = classifier.score(features);
    for (String otherOutcome : Arrays.asList("A", "B", "C")) {
      if (!otherOutcome.equals(outcome)) {
        Assert.assertTrue(scoredOutcomes.get(outcome) > scoredOutcomes.get(otherOutcome));
      }
    }
  }
}
 

import org.cleartk.ml.Instance; //导入方法依赖的package包/类
@Test
public void testStringOutcomeLIBLINEAR() throws Exception {
  // create the data writer
  StringAnnotator annotator = new StringAnnotator();
  annotator.initialize(UimaContextFactory.createUimaContext(
      DirectoryDataWriterFactory.PARAM_OUTPUT_DIRECTORY,
      this.outputDirectoryName,
      DefaultDataWriterFactory.PARAM_DATA_WRITER_CLASS_NAME,
      LibLinearStringOutcomeDataWriter.class.getName()));

  // run process to produce a bunch of instances
  annotator.process(null);

  annotator.collectionProcessComplete();

  // check that the output files were written for each class
  BufferedReader reader = new BufferedReader(new FileReader(new File(
      this.outputDirectoryName,
      "training-data.liblinear")));
  Assert.assertTrue(reader.readLine().length() > 0);
  reader.close();

  // run the training command
  HideOutput hider = new HideOutput();
  Train.main(this.outputDirectoryName, "-c", "1.0", "-s", "0");
  hider.restoreOutput();

  // read in the classifier and test it on new instances
  LibLinearStringOutcomeClassifierBuilder builder = new LibLinearStringOutcomeClassifierBuilder();
  LibLinearStringOutcomeClassifier classifier;
  classifier = builder.loadClassifierFromTrainingDirectory(this.outputDirectory);
  for (Instance<String> instance : ExampleInstanceFactory.generateStringInstances(1000)) {
    List<Feature> features = instance.getFeatures();
    String outcome = instance.getOutcome();
    Assert.assertEquals(outcome, classifier.classify(features));

    Map<String, Double> scoredOutcomes = classifier.score(features);
    for (String otherOutcome : Arrays.asList("A", "B", "C")) {
      if (!otherOutcome.equals(outcome)) {
        Assert.assertTrue(scoredOutcomes.get(outcome) > scoredOutcomes.get(otherOutcome));
      }
    }
  }
}