/** * @return the actual classes for constructing a * {@link ClassificationEvaluator} */ private Map<OBJECT, Set<ANNOTATION>> getActual() { final Map<OBJECT, Set<ANNOTATION>> actual = new HashMap<OBJECT, Set<ANNOTATION>>(); for (final Annotated<OBJECT, ANNOTATION> ao : testData) { actual.put(ao.getObject(), new HashSet<ANNOTATION>(ao.getAnnotations())); } return actual; }
/** * @return the queries for constructing a {@link RetrievalEvaluator} */ private Set<ANNOTATION> getQueries() { final Set<ANNOTATION> testAnnotations = new HashSet<ANNOTATION>(); for (final Annotated<OBJECT, ANNOTATION> item : testData) { testAnnotations.addAll(item.getAnnotations()); } testAnnotations.retainAll(annotator.getAnnotations()); return testAnnotations; }
/** * @return the objects for constructing a {@link ClassificationEvaluator} */ private Collection<OBJECT> getObjects() { final List<OBJECT> objects = new ArrayList<OBJECT>(); for (final Annotated<OBJECT, ANNOTATION> ao : testData) { objects.add(ao.getObject()); } return objects; }
/** * Construct the {@link AnnotatedListHelper} with the given list. * @param list the list */ public AnnotatedListHelper(List<? extends Annotated<OBJECT, ANNOTATION>> list) { this.data = list; for (int i=0; i<list.size(); i++) { Annotated<OBJECT, ANNOTATION> item = list.get(i); //only want to add one index/annotation, so make a set Set<ANNOTATION> annotations = new HashSet<ANNOTATION>(item.getAnnotations()); for (ANNOTATION annotation : annotations) { TIntArrayList indices = index.get(annotation); if (indices == null) index.put(annotation, indices = new TIntArrayList()); indices.add(i); } } }
public AnnotationEvaluationEngine(Annotator<OBJECT, ANNOTATION> annotator, Dataset<? extends Annotated<OBJECT, ANNOTATION>> testData) { for (final Annotated<OBJECT, ANNOTATION> item : testData) { final OBJECT obj = item.getObject(); results.put(obj, annotator.annotate(obj)); } }
@Override public void train(Annotated<OBJECT, ANNOTATION> annotated) { objectCache.add(annotated.getAnnotations(), annotated.getObject()); isInvalid = true; }
final Collection<ANNOTATION> anns = x.getAnnotations();
@Override public FEATURE get(int index) { return extractor.extractFeature( data.get(indices.get(index)).getObject() ); }
@Override public void train(Annotated<FACE, PERSON> annotated) { faceCache.add(annotated.getAnnotations(), annotated.getObject()); isInvalid = true; }
@Override public void train(List<? extends Annotated<OBJECT, ANNOTATION>> data) { final HashSet<ANNOTATION> annotationsSet = new HashSet<ANNOTATION>(); final TIntIntHashMap nAnnotationCounts = new TIntIntHashMap(); int maxVal = 0; for (final Annotated<OBJECT, ANNOTATION> sample : data) { final Collection<ANNOTATION> annos = sample.getAnnotations(); annotationsSet.addAll(annos); nAnnotationCounts.adjustOrPutValue(annos.size(), 1, 1); if (annos.size() > maxVal) maxVal = annos.size(); } annotations = new ArrayList<ANNOTATION>(annotationsSet); rnd = new Uniform(0, annotations.size() - 1, new MersenneTwister()); numAnnotations.train(data); }
@Override public FEATURE get(int index) { return extractor.extractFeature( data.get(selectedIndices.get(index)).getObject() ); }
@Override public void train(final Annotated<OBJECT, ANNOTATION> annotated) { this.nn = null; this.features.add(this.extractor.extractFeature(annotated.getObject())); final Collection<ANNOTATION> anns = annotated.getAnnotations(); this.annotations.add(anns); this.annotationsSet.addAll(anns); }
@Override public <O, A> void train(List<? extends Annotated<O, A>> data) { TIntIntHashMap nAnnotationCounts = new TIntIntHashMap(); int maxVal = 0; for (Annotated<O, A> sample : data) { Collection<A> annos = sample.getAnnotations(); nAnnotationCounts.adjustOrPutValue(annos.size(), 1, 1); if (annos.size()>maxVal) maxVal = annos.size(); } //build distribution and rng for the number of annotations double [] distr = new double[maxVal+1]; for (int i=0; i<=maxVal; i++) distr[i] = nAnnotationCounts.get(i); numAnnotations = new EmpiricalWalker(distr, Empirical.NO_INTERPOLATION, new MersenneTwister()); }
annotationsList = new ArrayList<ANNOTATION>(annotations); final int featureLength = extractor.extractFeature(data.get(0).getObject()).length();
/** * @return the relevant docs for constructing a {@link RetrievalEvaluator} */ private Map<ANNOTATION, Set<OBJECT>> getRelevant(Collection<ANNOTATION> queries) { final Map<ANNOTATION, Set<OBJECT>> relevant = new HashMap<ANNOTATION, Set<OBJECT>>(); for (final ANNOTATION query : queries) { final HashSet<OBJECT> rset = new HashSet<OBJECT>(); relevant.put(query, rset); for (final Annotated<OBJECT, ANNOTATION> item : testData) { if (item.getAnnotations().contains(query)) { rset.add(item.getObject()); } } } return relevant; }
@Override public void train(List<? extends Annotated<OBJECT, ANNOTATION>> data) { final TIntIntHashMap nAnnotationCounts = new TIntIntHashMap(); final TObjectIntHashMap<ANNOTATION> annotationCounts = new TObjectIntHashMap<ANNOTATION>(); int maxVal = 0; for (final Annotated<OBJECT, ANNOTATION> sample : data) { final Collection<ANNOTATION> annos = sample.getAnnotations(); for (final ANNOTATION s : annos) { annotationCounts.adjustOrPutValue(s, 1, 1); } nAnnotationCounts.adjustOrPutValue(annos.size(), 1, 1); if (annos.size() > maxVal) maxVal = annos.size(); } // build distribution and rng for each annotation annotations = new ArrayList<ANNOTATION>(); final TDoubleArrayList probs = new TDoubleArrayList(); annotationCounts.forEachEntry(new TObjectIntProcedure<ANNOTATION>() { @Override public boolean execute(ANNOTATION a, int b) { annotations.add(a); probs.add(b); return true; } }); annotationProbability = new EmpiricalWalker(probs.toArray(), Empirical.NO_INTERPOLATION, new MersenneTwister()); numAnnotations.train(data); }
@Override public void train(Annotated<OBJECT, ANNOTATION> annotated) { final FEATURE fv = extractor.extractFeature(annotated.getObject()); featureCache.add(annotated.getAnnotations(), fv); isInvalid = true; }
@Override public void train(List<? extends Annotated<OBJECT, ANNOTATION>> data) { final List<IndependentPair<FEATURE, ANNOTATION>> featureData = new ArrayList<IndependentPair<FEATURE, ANNOTATION>>(); for (final Annotated<OBJECT, ANNOTATION> a : data) { final FEATURE f = extractor.extractFeature(a.getObject()); for (final ANNOTATION ann : a.getAnnotations()) featureData.add(IndependentPair.pair(f, ann)); } model.estimate(featureData); }
private void addRow(Matrix F, Matrix W, int r, Annotated<OBJECT, ANNOTATION> data) { final double[] fv = extractor.extractFeature(data.getObject()).asDoubleVector(); addRow(F, W, r, fv, data.getAnnotations()); }
@Override public void train(List<? extends Annotated<OBJECT, ANNOTATION>> data) { final Set<ANNOTATION> termsSet = new HashSet<ANNOTATION>(); for (final Annotated<OBJECT, ANNOTATION> d : data) termsSet.addAll(d.getAnnotations()); terms = new ArrayList<ANNOTATION>(termsSet); final int termLen = terms.size(); final int trainingLen = data.size(); final Annotated<OBJECT, ANNOTATION> first = data.get(0); final double[] fv = extractor.extractFeature(first.getObject()).asDoubleVector(); final int featureLen = fv.length; final Matrix F = new Matrix(trainingLen, featureLen); final Matrix W = new Matrix(trainingLen, termLen); addRow(F, W, 0, fv, first.getAnnotations()); for (int i = 1; i < trainingLen; i++) { addRow(F, W, i, data.get(i)); } final Matrix pinvF = PseudoInverse.pseudoInverse(F, k); transform = pinvF.times(W); }