Java Instance类代码示例

import org.cleartk.ml.Instance; //导入依赖的package包/类
@Override
public void process(JCas jcas) throws AnalysisEngineProcessException {
	for (Figure figure : JCasUtil.select(jcas, Figure.class)) {
		List<Feature> features = extractor.extract(jcas, figure);
		features.addAll(contextExtractor.extract(jcas, figure, null, Token.class, tokenExtractor));
		if (this.isTraining()) {
			String outcome = figure.getGender();
			if (outcome != null)
				this.dataWriter.write(new Instance<String>(outcome, features));
		} else {
			String category = this.classifier.classify(features);
			figure.setGender(category);
		}

	}

}
 

import org.cleartk.ml.Instance; //导入依赖的package包/类
public void process(JCas cas) throws AnalysisEngineProcessException {
  List<Feature> features = Arrays.asList(
      new Feature("A", 1.1),
      new Feature("B", 3.0),
      new Feature("C", 1.234));
  Instance<String> instance = new Instance<String>("yes", features);
  this.dataWriter.write(instance);

  features = Arrays.asList(
      new Feature("A", 2.1),
      new Feature("B", 2.0),
      new Feature("C", 2.234));
  instance = new Instance<String>("no", features);
  this.dataWriter.write(instance);

  features = Arrays.asList(
      new Feature("A", 5.1),
      new Feature("B", 5.0),
      new Feature("C", 5.234));
  instance = new Instance<String>("yes", features);
  this.dataWriter.write(instance);

}
 

import org.cleartk.ml.Instance; //导入依赖的package包/类
public static List<Instance<String>> generateStringInstances(int n) {
  Random random = new Random(42);
  List<Instance<String>> instances = new ArrayList<Instance<String>>();
  for (int i = 0; i < n; i++) {
    Instance<String> instance = new Instance<String>();
    int c = random.nextInt(3);
    if (c == 0) {
      instance.setOutcome("A");
      instance.add(new Feature("hello", random.nextInt(100) + 950));
      instance.add(new Feature("goodbye", random.nextInt(100)));
      instance.add(new Feature("farewell", random.nextInt(100)));
    } else if (c == 1) {
      instance.setOutcome("B");
      instance.add(new Feature("goodbye", random.nextInt(100) + 950));
      instance.add(new Feature("hello", random.nextInt(100)));
      instance.add(new Feature("farewell", random.nextInt(100)));
    } else {
      instance.setOutcome("C");
      instance.add(new Feature("farewell", random.nextInt(100) + 950));
      instance.add(new Feature("hello", random.nextInt(100)));
      instance.add(new Feature("goodbye", random.nextInt(100)));
    }
    instances.add(instance);
  }
  return instances;
}
 

import org.cleartk.ml.Instance; //导入依赖的package包/类
@Override
public void process(JCas jcas) throws AnalysisEngineProcessException {
  for (Sentence sentence : JCasUtil.select(jcas, Sentence.class)) {
    Instance<Boolean> instance = new Instance<Boolean>(false, this.extractor.extract(
        jcas,
        sentence));

    if (this.isTraining()) {
      this.dataWriter.write(instance);
    } else {
      Map<Boolean, Double> scoredOutcomes = this.classifier.score(instance.getFeatures());
      Double trueScore = scoredOutcomes.get(true);
      if (trueScore > 0.0) {
        SummarySentence extractedSentence = new SummarySentence(
            jcas,
            sentence.getBegin(),
            sentence.getEnd());
        extractedSentence.setScore(trueScore);
        extractedSentence.addToIndexes();
      }
    }
  }
}
 

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包/类
protected IDFMap createIdfMap(Iterable<Instance<OUTCOME_T>> instances) {
  IDFMap newIdfMap = new IDFMap();

  // Add instance's term frequencies to the global counts
  for (Instance<OUTCOME_T> instance : instances) {

    Set<String> featureNames = new HashSet<String>();
    // Grab the matching tf*idf features from the set of all features in an instance
    for (Feature feature : instance.getFeatures()) {
      if (this.isTransformable(feature)) {
        // tf*idf features contain a list of features, these are actually what get added
        // to our document frequency map
        for (Feature untransformedFeature : ((TransformableFeature) feature).getFeatures()) {
          featureNames.add(untransformedFeature.getName());
        }
      }
    }

    for (String featureName : featureNames) {
      newIdfMap.add(featureName);
    }
    newIdfMap.incTotalDocumentCount();

  }
  return newIdfMap;
}
 

import org.cleartk.ml.Instance; //导入依赖的package包/类
/**
 * Recursively look through all features in an instance to find the features this extractor is
 * responsible for extracting
 */
protected List<TransformableFeature> selectTransformableFeatures(Instance<OUTCOME_T> instance) {

  List<TransformableFeature> features = new ArrayList<TransformableFeature>();
  Stack<Feature> featuresToProcess = new Stack<Feature>();
  featuresToProcess.addAll(instance.getFeatures());

  while (!featuresToProcess.isEmpty()) {
    Feature currFeature = featuresToProcess.pop();
    if (currFeature instanceof TransformableFeature) {
      TransformableFeature transformable = (TransformableFeature) currFeature;
      if (transformable.getName().equals(this.name)) {
        features.add(transformable);
      } else {
        featuresToProcess.addAll(transformable.getFeatures());
      }
    }
  }
  return 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包/类
public void write(List<Instance<OUTCOME_TYPE>> instances) throws CleartkProcessingException {
  if (this.delegatedDataWriter == null)
    throw new IllegalStateException(
        "delegatedDataWriter must be set before calling writeSequence");

  List<Object> outcomes = new ArrayList<Object>();
  for (Instance<OUTCOME_TYPE> instance : instances) {
    List<Feature> instanceFeatures = instance.getFeatures();
    for (OutcomeFeatureExtractor outcomeFeatureExtractor : outcomeFeatureExtractors) {
      instanceFeatures.addAll(outcomeFeatureExtractor.extractFeatures(outcomes));
    }
    outcomes.add(instance.getOutcome());
    delegatedDataWriter.write(instance);
  }

}
 

import org.cleartk.ml.Instance; //导入依赖的package包/类
@Override
public void process(JCas jCas) throws AnalysisEngineProcessException {
  for (Sentence sentence : JCasUtil.select(jCas, Sentence.class)) {
    List<Instance<String>> instances = new ArrayList<Instance<String>>();
    List<Token> tokens = JCasUtil.selectCovered(jCas, Token.class, sentence);
    for (Token token : tokens) {
      Instance<String> instance = new Instance<String>();
      instance.addAll(this.extractor.extract(jCas, token));
      instance.setOutcome(token.getPos());
      instances.add(instance);
    }
    if (this.isTraining()) {
      this.dataWriter.write(instances);
    } else {
      this.classify(instances);
    }
  }
}
 

import org.cleartk.ml.Instance; //导入依赖的package包/类
@Test
public void test() {
  List<String> outcomes = Arrays.asList("X", "Y", "Z");
  List<Feature> features1 = Arrays.asList(new Feature("foo", 42), new Feature("bar", "a"));
  List<Feature> features2 = Arrays.asList(new Feature("foo", -1), new Feature("bar", "b"));
  List<Feature> features3 = Arrays.asList(new Feature("foo", 13), new Feature("bar", "c"));
  List<List<Feature>> featureLists = new ArrayList<List<Feature>>();
  featureLists.add(features1);
  featureLists.add(features2);
  featureLists.add(features3);

  List<Instance<String>> expected = new ArrayList<Instance<String>>();
  expected.add(new Instance<String>("X", features1));
  expected.add(new Instance<String>("Y", features2));
  expected.add(new Instance<String>("Z", features3));

  List<Instance<String>> actual = Instances.toInstances(outcomes, featureLists);
  Assert.assertEquals(expected, actual);
}
 

import org.cleartk.ml.Instance; //导入依赖的package包/类
@Test
public void testFeatures() {
  Instance<String> instance = new Instance<String>();

  // test an instance with no features
  Assert.assertEquals(0, instance.getFeatures().size());

  // test the .add() method
  Feature f1 = new Feature("foo", "bar");
  instance.add(f1);
  Assert.assertEquals(1, instance.getFeatures().size());
  Assert.assertEquals(f1, instance.getFeatures().get(0));

  // test the .addAll() method
  Feature f2 = new Feature(true);
  Feature f3 = new Feature("baz", 42.0);
  List<Feature> newFeatures = new ArrayList<Feature>();
  newFeatures.add(f2);
  newFeatures.add(f3);
  instance.addAll(newFeatures);
  Assert.assertEquals(3, instance.getFeatures().size());
  Assert.assertEquals(f1, instance.getFeatures().get(0));
  Assert.assertEquals(f2, instance.getFeatures().get(1));
  Assert.assertEquals(f3, instance.getFeatures().get(2));
}
 

import org.cleartk.ml.Instance; //导入依赖的package包/类
/**
 * Create a number of random Instance objects that should be easy to classify. This is primarily
 * useful for testing DataWriter and Classifier implementations.
 * 
 * @param n
 *          The number of instances
 * @return The list of newly-created instances
 */
public static List<Instance<String>> generateStringInstances(int n) {
  List<Instance<String>> instances = new ArrayList<Instance<String>>();
  for (int i = 0; i < n; i++) {
    Instance<String> instance = new Instance<String>();
    switch (ClassifierTestUtil.random.nextInt(3)) {
      case 0:
        instance.setOutcome("A");
        instance.add(new Feature("hello", -1050 + ClassifierTestUtil.random.nextInt(100)));
        break;
      case 1:
        instance.setOutcome("B");
        instance.add(new Feature("hello", -50 + ClassifierTestUtil.random.nextInt(100)));
        break;
      case 2:
        instance.setOutcome("C");
        instance.add(new Feature("hello", 950 + ClassifierTestUtil.random.nextInt(100)));
        break;
    }
    instances.add(instance);
  }
  return instances;
}
 

import org.cleartk.ml.Instance; //导入依赖的package包/类
/**
 * Create a number of random Instance objects that should be easy to classify. This is primarily
 * useful for testing DataWriter and Classifier implementations.
 * 
 * @param n
 *          The number of instances
 * @return The list of newly-created instances
 */
public static List<Instance<Boolean>> generateBooleanInstances(int n) {
  List<Instance<Boolean>> instances = new ArrayList<Instance<Boolean>>();
  for (int i = 0; i < n; i++) {
    Instance<Boolean> instance = new Instance<Boolean>();
    if (ClassifierTestUtil.random.nextInt(2) == 0) {
      instance.setOutcome(true);
      instance.add(new Feature("hello", ClassifierTestUtil.random.nextInt(1000) + 1000));
    } else {
      instance.setOutcome(false);
      instance.add(new Feature("hello", ClassifierTestUtil.random.nextInt(100)));
    }
    instances.add(instance);
  }
  return instances;
}
 

import org.cleartk.ml.Instance; //导入依赖的package包/类
public static List<Instance<Boolean>> generateBooleanInstances(int n) {
  Random random = new Random(42);
  List<Instance<Boolean>> instances = new ArrayList<Instance<Boolean>>();
  for (int i = 0; i < n; i++) {
    Instance<Boolean> instance = new Instance<Boolean>();
    if (random.nextInt(2) == 0) {
      instance.setOutcome(true);
      instance.add(new Feature("hello", random.nextInt(100) + 1000));
      instance.add(new Feature("goodbye", 500));
    } else {
      instance.setOutcome(false);
      instance.add(new Feature("goodbye", 500));
      instance.add(new Feature("hello", random.nextInt(100)));
    }
    instances.add(instance);
  }
  return instances;
}