|| || || || || ||

---

BalancedAveragePrecision.h

Go to the documentation of this file.

#ifndef Impala_Core_Training_BalancedAveragePrecision_h
#define Impala_Core_Training_BalancedAveragePrecision_h

#include "Core/Training/Evaluation.h"
#include "Core/Table/Sort.h"
//#include "Core/Table/Reverse.h"

namespace Impala
{
namespace Core
{
namespace Training
{


/*
 * a Balance version of AP (BAP)
 * see Van Gemert, Veenman, Geusebroek, "Episode-Constrained Cross-Validation in
 * Video Concept Retrieval", Transactions of Mulimedia (submitted :) )
 * It deals with the inbalance of positive shots between cross-validation folds
 * as will happen with episode constrained x-val since it is splitting videos
 * not shots.
 * theoretically more balanced than AP, and optimising BAP optimes AP.
 * however... practical... it is the same as AP when
 * dealing with large numbers of negative samples.
 */
class BalancedAveragePrecision : public Evaluation
{
public:

    BalancedAveragePrecision(Table::AnnotationTable* annotation) :
        Evaluation(annotation)
    {
    }

    virtual double
    Compute(Table::ScoreTable* table)
    {
        Sort(table, 2, false);
        return ComputeSub(table);

    }

    virtual double
    ComputeReversed(Table::ScoreTable* table)
    {
        Sort(table, 2, false);
        Reverse(table);
        return ComputeSub(table);

    }

private:

    double
    ComputeSub(Table::ScoreTable* table)
    {
        // first compute AP
        double ap = 0;
        int positiveCount = 0;
        for (int i=0 ; i<table->Size() ; i++)
        {
            Quid q = table->Get1(i);
            if (mAnnotation->IsPositive(q))
            {
                positiveCount++;
                double precision = ((double)positiveCount)/((double)(i+1));
                ap += precision;
            }
        }
        if (positiveCount > 0)
            ap /= (double)positiveCount;

        // then compute WAP (worst case AP, ie: assume all perfectly-wrong)
        double wap = 0;
        double WminusR = table->Size() - positiveCount;
        for (int i=1 ; i<=positiveCount ; i++)
        {
            wap = wap + ((double)i)/(WminusR + (double)i);
        }
        wap /= (double)positiveCount;

        // finally, compute BAP
        double bap = 1.0;
        if (wap!=1.0)
            bap = (ap - wap)/(1-wap);

        return bap;    
    }
};

}//namespace Core
}//namespace Training
}//namespace Impala

#endif

---