private static void printTrialClassification(Trial trial) { for (Classification c : trial) { Instance instance = c.getInstance(); System.out.print(instance.getName() + " " + instance.getTarget() + " "); Labeling labeling = c.getLabeling(); for (int j = 0; j < labeling.numLocations(); j++){ System.out.print(labeling.getLabelAtRank(j).toString() + ":" + labeling.getValueAtRank(j) + " "); } System.out.println(); } }
/** * Classify an instance using the most frequent class label. * * @param Instance to be classified. Data field must be a FeatureVector. * @return Classification containing the labeling of the instance. */ @Override public Classification classify(Instance instance) { String mostFrequentLabelStr = this.sortedLabelMap.firstEntry().getKey(); Label mostFrequentLabel = this.labels.get(mostFrequentLabelStr); Classification mostFrequentClassification = new Classification(instance, this, mostFrequentLabel); return mostFrequentClassification; }
/** * accuracy at a given coverage percentage * @param cov coverage percentage * @return accuracy value */ public double accuracyAtCoverage(double cov) { assert(cov <= 1 && cov > 0); int numTrials = (int)(Math.round((double)classifications.size()*cov)); int numCorrect = 0; // System.out.println("NumTrials="+numTrials); for(int i= classifications.size()-1; i >= classifications.size()-numTrials; i--) { Classification temp = (Classification)classifications.get(i); if(temp.bestLabelIsCorrect()) numCorrect++; } // System.out.println("Accuracy at cov "+cov+" is "+ //(double)numCorrect/numTrials); return((double)numCorrect/numTrials); }
/** * Constructs matrix and calculates values * @param t the trial to build matrix from */ public ConfusionMatrix(Trial t) { this.trial = t; this.classifications = t; Labeling tempLabeling = ((Classification) classifications.get(0)).getLabeling(); this.numClasses = tempLabeling.getLabelAlphabet().size(); values = new int[numClasses][numClasses]; for (int i=0; i < classifications.size(); i++) { LabelVector lv = ((Classification)classifications.get(i)).getLabelVector(); Instance inst = ((Classification)classifications.get(i)).getInstance(); int bestIndex = lv.getBestIndex(); int correctIndex = inst.getLabeling().getBestIndex(); assert(correctIndex != -1); //System.out.println("Best index="+bestIndex+". Correct="+correctIndex); values[correctIndex][bestIndex]++; } }
public List<RerankerResult> probabilities(List<RerankExample> ex) { Classification classify = model.classify(ex); LabelVector labeling = (LabelVector) classify.getLabeling(); List<RerankerResult> result = Lists.newArrayListWithCapacity(ex.size()); for (int i = 0; i < ex.size(); i++) { Label rankLabel = labeling.getLabelAlphabet().lookupLabel(Integer.toString(i)); result.add(new RerankerResult(ex.get(i), labeling.value(rankLabel))); } Collections.sort(result, Ordering.<RerankerResult>natural().reverse()); return result; }
public Classification classify (Instance inst) { int numClasses = getLabelAlphabet().size(); double[] scores = new double[numClasses]; int bestIndex; double sum = 0; for (int i = 0; i < baggedClassifiers.length; i++) { Labeling labeling = baggedClassifiers[i].classify(inst).getLabeling(); labeling.addTo (scores); } MatrixOps.normalize (scores); return new Classification (inst, this, new LabelVector (getLabelAlphabet(), scores)); }
Instance inst = trainingInsts.get(i); Classification c = weakLearners[round].classify(inst); double htCorrect = c.valueOfCorrectLabel(); double htWrong = c.getLabeling().value(classIndices[i]); epsilon += weights[i] * (1 - htCorrect + htWrong); exponents[i] = 1 + htCorrect - htWrong;
LabelVector lv = classification.getLabelVector(); Label bestLabel = lv.getBestLabel(); Instance inst = (Instance)classification.getInstance(); FeatureVector fv = (FeatureVector)inst.getData(); Alphabet fdict = fv.getAlphabet(); carrier.setTarget(((LabelAlphabet)getTargetAlphabet()).lookupLabel(classification.bestLabelIsCorrect() ? "correct" : "incorrect")); carrier.setData(new FeatureVector ((Alphabet) getDataAlphabet(), features, false));
LabelVector lv = c.getLabelVector(); int bestIndex = lv.getBestIndex(); double [] values = new double[lv.numLocations()]; if (i != bestIndex) values[i] = 0.0; else values[i] = cpc.getLabelVector().value("correct"); if(c.bestLabelIsCorrect()){ numCorrectInstances++; totalCorrect+=cpc.getLabelVector().value("correct"); totalIncorrectCorrect+=cpc.getLabelVector().value("incorrect"); String correct = new String("correct"); if(correct.equals(cpc.getLabelVector().getBestLabel().toString())) numConfidenceCorrect++; else numFalseNegative++; totalIncorrect+=cpc.getLabelVector().value("correct"); totalIncorrectIncorrect+=cpc.getLabelVector().value("incorrect"); if((new String("incorrect")).equals(cpc.getLabelVector().getBestLabel().toString())) numConfidenceCorrect++; else numFalsePositive++; return new Classification(instance, this, new LabelVector(lv.getLabelAlphabet(), values));
private static LabelVector[] getLabelVectorsFromClassifications (Classification[] c) { LabelVector[] ret = new LabelVector[c.length]; for (int i = 0; i < c.length; i++) ret[i] = c[i].getLabelVector(); return ret; }
public Classification classify (Instance instance) { int numLabels = ensemble[0].getLabelAlphabet().size(); double[] scores = new double[numLabels]; // Run each classifier on the instance, summing each one's per-class score, with a weight for (int i = 0; i < ensemble.length; i++) { Classification c = ensemble[i].classify(instance); c.getLabelVector().addTo(scores, weights[i]); } // Exponentiate and normalize scores expNormalize (scores); return new Classification (instance, this, new LabelVector (ensemble[0].getLabelAlphabet(), scores)); }
public boolean add (Classification c) { if (c.getClassifier() != this.classifier) throw new IllegalArgumentException ("Trying to add Classification from a different Classifier."); return super.add (c); }
for (int i = 0; i < t.size(); i++) { Classification classification = t.get(i); confidencePredictionTraining.add (classification, null, classification.getInstance().getName(), classification.getInstance().getSource());
static private void internalTest() throws IOException { Classifier classifier = train(internalData, internalTargets, 1.0, null); System.out.println("Training accuracy = " + test(classifier, internalData, internalTargets)); Classification cl = classify(classifier, internalInstance); Labeling lab = cl.getLabeling(); LabelAlphabet labels = lab.getLabelAlphabet(); for (int c = 0; c < labels.size(); c++) System.out.print(labels.lookupObject(c) + " " + lab.value(c) + " "); System.out.println(); }
/** * Constructs matrix and calculates values * @param t the trial to build matrix from */ public ConfusionMatrix(Trial t) { this.trial = t; this.classifications = t; Labeling tempLabeling = ((Classification) classifications.get(0)).getLabeling(); this.numClasses = tempLabeling.getLabelAlphabet().size(); values = new int[numClasses][numClasses]; for (int i=0; i < classifications.size(); i++) { LabelVector lv = ((Classification)classifications.get(i)).getLabelVector(); Instance inst = ((Classification)classifications.get(i)).getInstance(); int bestIndex = lv.getBestIndex(); int correctIndex = inst.getLabeling().getBestIndex(); assert(correctIndex != -1); //System.out.println("Best index="+bestIndex+". Correct="+correctIndex); values[correctIndex][bestIndex]++; } }
public Classification classify (Instance inst) { int numClasses = getLabelAlphabet().size(); double[] scores = new double[numClasses]; int bestIndex; double sum = 0; for (int i = 0; i < baggedClassifiers.length; i++) { Labeling labeling = baggedClassifiers[i].classify(inst).getLabeling(); labeling.addTo (scores); } MatrixOps.normalize (scores); return new Classification (inst, this, new LabelVector (getLabelAlphabet(), scores)); }
Instance inst = trainingInsts.get(i); Classification c = weakLearners[round].classify(inst); double htCorrect = c.valueOfCorrectLabel(); double htWrong = c.getLabeling().value(classIndices[i]); epsilon += weights[i] * (1 - htCorrect + htWrong); exponents[i] = 1 + htCorrect - htWrong;
LabelVector lv = classification.getLabelVector(); Label bestLabel = lv.getBestLabel(); Instance inst = (Instance)classification.getInstance(); FeatureVector fv = (FeatureVector)inst.getData(); Alphabet fdict = fv.getAlphabet(); carrier.setTarget(((LabelAlphabet)getTargetAlphabet()).lookupLabel(classification.bestLabelIsCorrect() ? "correct" : "incorrect")); carrier.setData(new FeatureVector ((Alphabet) getDataAlphabet(), features, false));
LabelVector lv = c.getLabelVector(); int bestIndex = lv.getBestIndex(); double [] values = new double[lv.numLocations()]; if (i != bestIndex) values[i] = 0.0; else values[i] = cpc.getLabelVector().value("correct"); if(c.bestLabelIsCorrect()){ numCorrectInstances++; totalCorrect+=cpc.getLabelVector().value("correct"); totalIncorrectCorrect+=cpc.getLabelVector().value("incorrect"); String correct = new String("correct"); if(correct.equals(cpc.getLabelVector().getBestLabel().toString())) numConfidenceCorrect++; else numFalseNegative++; totalIncorrect+=cpc.getLabelVector().value("correct"); totalIncorrectIncorrect+=cpc.getLabelVector().value("incorrect"); if((new String("incorrect")).equals(cpc.getLabelVector().getBestLabel().toString())) numConfidenceCorrect++; else numFalsePositive++; return new Classification(instance, this, new LabelVector(lv.getLabelAlphabet(), values));
private static LabelVector[] getLabelVectorsFromClassifications (Classification[] c) { LabelVector[] ret = new LabelVector[c.length]; for (int i = 0; i < c.length; i++) ret[i] = c[i].getLabelVector(); return ret; }