/** * Create a list of Instances from a list of outcomes and a list of feature-lists. * * There must be exactly one outcome for each feature list. * * @param outcomes * The list of classifier outcomes. * @param featureLists * The list of classifier feature-lists. * @return A list of Instances produced by matchin the outcomes and feature-lists pairwise. */ public static <OUTCOME_TYPE> List<Instance<OUTCOME_TYPE>> toInstances( List<OUTCOME_TYPE> outcomes, List<List<Feature>> featureLists) { int nOutcomes = outcomes.size(); int nFeatureLists = featureLists.size(); if (nOutcomes != nFeatureLists) { String message = "expected the same number of outcomes (%d) as featureLists (%d)"; throw new IllegalArgumentException(String.format(message, nOutcomes, nFeatureLists)); } List<Instance<OUTCOME_TYPE>> instances = new ArrayList<Instance<OUTCOME_TYPE>>(); for (int i = 0; i < nOutcomes; ++i) { instances.add(new Instance<OUTCOME_TYPE>(outcomes.get(i), featureLists.get(i))); } return instances; }
/** * @param outcome * the outcome of the returned instance * @param featureData * an even number of elements corresponding to name/value pairs used to create features * @return a single instance with the provided outcome and features corresponding to the * featureData provided */ public static <T> Instance<T> createInstance(T outcome, Object... featureData) { if (featureData.length % 2 != 0) { throw new IllegalArgumentException( "feature data must consist of an even number of elements corresponding to name/value pairs used to create features. "); } Instance<T> instance = new Instance<T>(outcome); for (int i = 0; i < featureData.length;) { instance.add(new Feature(featureData[i].toString(), featureData[i + 1])); i += 2; } return instance; }
@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); }
@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); }
@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); }
@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); }
/** * @param outcome * the outcome of the returned instance * @param featureData * space delimited features. Here the features only have names (no values) corresponding * to the space delimited strings. * @return a single instance with the provided outcome and name-only string features found in the * provided featureData */ public static <T> Instance<T> createInstance(T outcome, String featureData) { Instance<T> instance = new Instance<T>(outcome); String[] columns = featureData.split(" "); for (int i = 0; i < columns.length; i++) { Feature feature = new Feature(); feature.setName(columns[i]); instance.add(feature); } return instance; }
@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); }
@Override public void process(JCas jCas) throws AnalysisEngineProcessException { for (Time time : JCasUtil.select(jCas, Time.class)) { List<Feature> features = new ArrayList<Feature>(); for (FeatureExtractor1<Time> extractor : this.featuresExtractors) { features.addAll(extractor.extract(jCas, time)); } if (this.isTraining()) { this.dataWriter.write(new Instance<String>(time.getTimeType(), features)); } else { time.setTimeType(this.classifier.classify(features)); } } }
@Override public void process(JCas jcas) throws AnalysisEngineProcessException { LOGGER.info( "Processing ..." ); for(Markable markable : JCasUtil.select(jcas, Markable.class)){ boolean outcome; List<Feature> features = new ArrayList<>(); for(FeatureExtractor1<Markable> extractor : extractors){ features.addAll(extractor.extract(jcas, markable)); } Instance<Boolean> instance = new Instance<>(features); if(this.isTraining()){ outcome = markable.getConfidence() > 0.5; instance.setOutcome(outcome); this.dataWriter.write(instance); }else{ Map<Boolean,Double> outcomes = this.classifier.score(features); markable.setConfidence(outcomes.get(true).floatValue()); } } LOGGER.info( "Finished." ); } }
@Override public void process(JCas jcas) throws AnalysisEngineProcessException { for(Markable markable : JCasUtil.select(jcas, Markable.class)){ boolean outcome; List<Feature> features = new ArrayList<>(); for(FeatureExtractor1<Markable> extractor : extractors){ features.addAll(extractor.extract(jcas, markable)); } Instance<Boolean> instance = new Instance<>(features); if(this.isTraining()){ outcome = markable.getConfidence() > 0.5; instance.setOutcome(outcome); this.dataWriter.write(instance); }else{ Map<Boolean,Double> outcomes = this.classifier.score(features); markable.setConfidence(outcomes.get(true).floatValue()); } } } }
this.dataWriter.write(new Instance<String>(label, features)); } else { if (this.classifier.classify(features).equals("Event")) {
this.dataWriter.write(new Instance<String>(outcome, features));
this.dataWriter.write(new Instance<>(category, features));
this.dataWriter.write(new Instance<String>(outcome, features));
attribute = this.getDefaultValue(); Instance<OUTCOME_TYPE> instance = new Instance<OUTCOME_TYPE>(); instance.addAll(features); instance.setOutcome(attribute);
@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(); } } } }
public void process(JCas jCas) throws AnalysisEngineProcessException { // use the extractor to create features for the document DocumentAnnotation doc = (DocumentAnnotation) jCas.getDocumentAnnotationFs(); List<Feature> features = this.extractor.extract(jCas, doc); // during training, get the label for this document from the CAS if (isTraining()) { UsenetDocument document = JCasUtil.selectSingle(jCas, UsenetDocument.class); this.dataWriter.write(new Instance<String>(document.getCategory(), features)); } // during classification, use the classifier's output to create a CAS annotation else { String category = this.classifier.classify(features); UsenetDocument document = new UsenetDocument(jCas, 0, jCas.getDocumentText().length()); document.setCategory(category); document.addToIndexes(); } } }
public void process(JCas jCas) throws AnalysisEngineProcessException { DocumentAnnotation doc = (DocumentAnnotation) jCas.getDocumentAnnotationFs(); Instance<String> instance = new Instance<String>(); instance.addAll(this.extractor.extract(jCas, doc)); if (isTraining()) { UsenetDocument document = JCasUtil.selectSingle(jCas, UsenetDocument.class); instance.setOutcome(document.getCategory()); this.dataWriter.write(instance); } else { // This is classification, so classify and create UsenetDocument annotation String result = this.classifier.classify(instance.getFeatures()); UsenetDocument document = new UsenetDocument(jCas, 0, jCas.getDocumentText().length()); document.setCategory(result); document.addToIndexes(); // System.out.println("classified " + ViewURIUtil.getURI(jCas) + " as " + result + "."); } }
TOKEN_TYPE token = (TOKEN_TYPE) tokens.next(); List<Feature> features = featureExtractor.extractFeatures(jCas, token, sentence); Instance<String> instance = new Instance<String>(); instance.addAll(features); instance.setOutcome(getTag(jCas, token));