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

---

AveragePrecisionConfusion.h

Go to the documentation of this file.

#ifndef Impala_Core_Table_AveragePrecisionConfusion_h
#define Impala_Core_Table_AveragePrecisionConfusion_h

#include "Core/Table/AnnotationTable.h"

namespace Impala
{
namespace Core
{
namespace Table
{


template <class T>
inline Real64*
AveragePrecisionConfusion(T* rank, AnnotationTable** annotations, int tc, int nClasses, int topN = -1)
{
    ILOG_VAR(Impala.Core.Table.AveragePrecisionConfusion);
    int positiveCount = 0;
    Real64* conf;
    if (topN == -1)
    {
        topN = rank->Size();
        conf = new Real64[topN];

        for (int i=0 ; i < topN ; i++)
            conf[i] = 0;
    }
    
    // Get total positives
    int totPos = annotations[tc]->GetNrPositive();

    for (int i=0 ; i<topN ; i++)
    {
        if (positiveCount < totPos)
        {
            Quid q = rank->Get1(i);
            if (annotations[tc]->IsPositive(q))
            {
                positiveCount++;
                double precision = ((double)positiveCount)/((double)(i+1));
                conf[tc] += precision;
            }
            else // Calculate AP loss (Best Case)
            { 
                // Direct Loss
                Real64 directLoss = ((double) positiveCount + 1) / ((double)(i+1));


                // Minimum Future Loss
                // (Occurs when next all positive examples are encountered)
                int posLeft = totPos - positiveCount - 1;
                Real64 futureLoss = 0;
                if (posLeft > 0)
                {
                    for (int j=i+2; j<=i+1+posLeft ; j++)
                    {
                        futureLoss += 1.0 / (double) j;
                    }
                }

                // Maximum extra gain
                // (Occurs when removed example is found directly after rest)
                Real64 maxGain = totPos / ((double) i + (double) posLeft + 2.0);

                // Total
                Real64 totalLoss = directLoss + futureLoss - maxGain;

                // Now determine where loss goes
                Real64 totPosClasses = 0;
                for (int j = 0; j < nClasses ; j++)
                {
                    Quid q = rank->Get1(i);
                    if (annotations[j]->IsPositive(q))
                        totPosClasses+= 1;
                }

                // Allocate loss
                for (int j = 0; j < nClasses; j++)
                {
                    Quid q = rank->Get1(i);
                    if (annotations[j]->IsPositive(q))
                        conf[j] += totalLoss / totPosClasses;
                }
            }
        }
    }
    if (annotations[tc]->GetNrPositive() > 0)
        for(int i=0; i<topN; i++)
            conf[i] /= annotations[tc]->GetNrPositive();
    return conf;
}


template <class T>
inline Real64*
AveragePrecisionJudgedConfusion(T* rank, AnnotationTable** annotations, 
                                int tc, int nClasses, int topN = -1,
                                bool apOfFoundOnly = false)
{
    ILOG_VAR(Impala.Core.Table.AveragePrecisionConfusion);
    int positiveCount = 0;
    Real64* conf;
    if (topN == -1)
    {
        topN = rank->Size();
        conf = new Real64[topN];

        for (int i=0 ; i < topN ; i++)
            conf[i] = 0;
    }
    
    // Get total positives
    int totPos = annotations[tc]->GetNrPositive();

    int i = 0;
    for (int t=0 ; t<topN ; t++)
    {
        if (positiveCount < totPos)
        {
            Quid q = rank->Get1(t);
            int qIndex = annotations[tc]->GetIndex(q);
            if (!(qIndex == annotations[tc]->Size())) // not annotated
            {
                if (annotations[tc]->IsPositive(qIndex))
                {
                    positiveCount++;
                    double precision = ((double)positiveCount)/((double)(i+1));
                    conf[tc] += precision;
                }
                else if (annotations[tc]->IsNegative(qIndex)) // Calculate AP loss (Best Case)
                { 
                    // Direct Loss
                    Real64 directLoss = ((double) positiveCount + 1) / ((double)(i+1));


                    // Minimum Future Loss
                    // (Occurs when next all positive examples are encountered)
                    int posLeft = totPos - positiveCount - 1;
                    Real64 futureLoss = 0;
                    if (posLeft > 0)
                    {
                        for (int j=i+2; j<=i+1+posLeft ; j++)
                        {
                            futureLoss += 1.0 / (double) j;
                        }
                    }

                    // Maximum extra gain
                    // (Occurs when removed example is found directly after rest)
                    Real64 maxGain = totPos / ((double) i + (double) posLeft + 2.0);

                    // Total
                    Real64 totalLoss = directLoss + futureLoss - maxGain;

                    // Now determine where loss goes
                    Real64 totPosClasses = 0;
                    for (int j = 0; j < nClasses ; j++)
                    {
                        Quid q = rank->Get1(t);
                        int qInd = annotations[j]->GetIndex(q);
                        if (annotations[j]->IsPositive(qInd))
                            totPosClasses+= 1;
                    }

                    // Allocate loss
                    for (int j = 0; j < nClasses; j++)
                    {
                        Quid q = rank->Get1(t);
                        int qInd = annotations[j]->GetIndex(q);
                        if (annotations[j]->IsPositive(qInd))
                            conf[j] += totalLoss / totPosClasses;
                    }
                }
                if (annotations[tc]->IsPositive(qIndex) || annotations[tc]->IsNegative(qIndex))
                    i++;
            }
        }
    }
    int factor = (apOfFoundOnly) ? positiveCount : annotations[tc]->GetNrPositive();
    if (factor > 0)
        for(int i=0; i<topN; i++)
            conf[i] /= factor;
    return conf;
}

} // namespace Table
} // namespace Core
} // namespace Impala

#endif

---