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

---

AveragePrecisionSpeedup.h

Go to the documentation of this file.

#ifndef Impala_Core_Table_AveragePrecisionSpeedup_h
#define Impala_Core_Table_AveragePrecisionSpeedup_h

#include "Core/Table/AnnotationTable.h"
#include "Core/Table/SimilarityTableSet.h"

namespace Impala
{
namespace Core
{
namespace Table
{

// For idash project evaluation:
// Given the recall at certain points, such as 99.9%, 90%, 10%
// Output: window size (length of the returned list)
template <class T>
inline Real64
AveragePrecisionSpeedup(T* rank, AnnotationTable* groundTruth, int topN = -1)
{
    ILOG_VAR(Impala.Core.Table.AveragePrecisionSpeedup);
    Real64 ap = 0;

    Real64 pos99 = 0.999; // status = 3
    Real64 pos90 = 0.9;   // status = 2
    Real64 pos10 = 0.1;   // status = 1

    Real64 curPos = 0;

    // setting default status = 1
    int status = 1;
    Real64 curRef = pos10;

    int totalPositive = groundTruth->GetNrPositive();
    if ( 0 == totalPositive)
        return -1;

    int positiveCount = 0;
    if (topN == -1)
        topN = rank->Size();

    //std::vector<T*> rank_Rkf;
    //T* rank_tmp = new T(topN);
    //rank_tmp->SetColName(1, "id");
    //rank_Rkf.push_back(rank_tmp);

    for (int i=0 ; i<topN ; i++)
    {
        Quid q = rank->Get1(i);
        if (groundTruth->IsPositive(q))
        {
            positiveCount++;
            double precision = ((double)positiveCount)/((double)(i+1));
            ap += precision;    

            // added by Jun Wu
            // compute the measure: recall
            curPos = positiveCount*1.0/totalPositive;

            switch (status) {
            case 1:

                if (curPos > curRef)
                {
                    // reaching the point of 10%
                    Real64 ratio = (positiveCount-1)*1.0/topN;
                    fprintf(stdout," [1]recall=10.0%s %d / %d N= %d ratio= %f speedup= %.3f pos= %d\n", "%", positiveCount-1, totalPositive,topN, ratio, 0.1/ratio,i);
                    status = 2;
                    curRef = pos90;
                    
                }

                break;

            case 2:

                if (curPos > curRef)
                {
                    // reaching the point of 90%
                    Real64 ratio = (positiveCount-1)*1.0/topN;
                    fprintf(stdout," [2]recall=90.0%s %d / %d N= %d ratio= %f speedup= %.3f pos= %d\n", "%", positiveCount-1, totalPositive,topN, ratio, 0.9/ratio,i);
                    status = 3;
                    curRef = pos99;
                    
                }
                break;

            case 3:

                if (curPos > curRef)
                {
                    // reaching the point of 99.9%
                    Real64 ratio = (positiveCount-1)*1.0/topN;
                    fprintf(stdout," [3]recall=99.9%s %d / %d N= %d ratio= %f speedup= %.3f pos= %d\n", "%", positiveCount, totalPositive,topN, ratio, 0.999/ratio,i+1);
                    status = -1;
                    curRef = 1e5;
                    
                }
                break;

            default:

                break;
            }
            // end of adding, by Jun Wu

        }
    }
    if (groundTruth->GetNrPositive() > 0)
        ap /= groundTruth->GetNrPositive();
    return ap;
}


template <class T>
inline Real64
AveragePrecisionJudgedSpeedup(T* rank, AnnotationTable* groundTruth,
                       bool skipIsNegative, int topN = -1,
                       bool apOfFoundOnly = false)
{
    ILOG_VAR(Impala.Core.Table.AveragePrecisionJudgedSpeedup);
    Real64 ap = 0;

    Real64 pos99 = 0.999; // status = 3
    Real64 pos90 = 0.9;   // status = 2
    Real64 pos10 = 0.1;   // status = 1

    Real64 curPos = 0;

    // setting default status = 1
    int status = 1;
    Real64 curRef = pos10;

    int totalPositive = groundTruth->GetNrPositive();
    if ( 0 == totalPositive)
        return -1;

    int positiveCount = 0;
    int curRank = 0;
    if (topN == -1)
        topN = rank->Size();
    for (int i=0 ; i<topN ; i++)
    {
        Quid q = rank->Get1(i);
        int qIndex = groundTruth->GetIndex(q);
        if (qIndex == groundTruth->Size()) // not annotated
            continue;
        if (groundTruth->IsPositive(qIndex))
        {
            positiveCount++;
            double precision = ((double)positiveCount)/((double)(curRank+1));
            ap += precision;

            // added by Jun Wu
            // compute the measure: recall
            curPos = positiveCount*1.0/totalPositive;

            switch (status) {
            case 1:

                if (curPos > curRef)
                {
                    // reaching the point of 10%
                    Real64 ratio = (positiveCount-1)*1.0/topN;
                    fprintf(stdout," [1]recall=10.0%s %d / %d N= %d ratio= %f speedup= %.3f pos= %d\n", "%", positiveCount-1, totalPositive,topN, ratio, 0.1/ratio,i);
                    status = 2;
                    curRef = pos90;
                    
                }

                break;

            case 2:

                if (curPos > curRef)
                {
                    // reaching the point of 90%
                    Real64 ratio = (positiveCount-1)*1.0/topN;
                    fprintf(stdout," [2]recall=90.0%s %d / %d N= %d ratio= %f speedup= %.3f pos= %d\n", "%", positiveCount-1, totalPositive,topN, ratio, 0.9/ratio,i);
                    status = 3;
                    curRef = pos99;
                    
                }
                break;

            case 3:

                if (curPos > curRef)
                {
                    // reaching the point of 99.9%
                    Real64 ratio = (positiveCount-1)*1.0/topN;
                    fprintf(stdout," [3]recall=99.9%s %d / %d N= %d ratio= %f speedup= %.3f pos= %d\n", "%", positiveCount, totalPositive,topN, ratio, 0.999/ratio,i+1);
                    status = -1;
                    curRef = 1e5;
                    
                }
                break;

            default:

                break;
            }
            // end of adding, by Jun Wu
        }
        if (groundTruth->IsPositive(qIndex) || skipIsNegative
            || groundTruth->IsNegative(qIndex))
        {
            curRank++;
        }
    }
    int factor = (apOfFoundOnly) ? positiveCount : groundTruth->GetNrPositive();
    if (factor > 0)
        ap /= factor;
    return ap;
}

template <class T>
void
DumpSimilarityAndTruthData(FILE* fp, T* rank, Core::Table::SimilarityTableSet::SimTableType* sim, 
                           AnnotationTable* groundTruth, Core::Table::QuidTable* qTable,
                           int topN = -1)
//DumpSimilarityAndTruthData(FILE* fp, Core::Table::SimilarityTableSet* simSet, int index, AnnotationTable* groundTruth, int topN = -1)
{
    ILOG_VAR(Impala.Core.Table.DumpSimilarityAndTruthData);
    //Real64 ap = 0;

    //int totalPositive = groundTruth->GetNrPositive();
    //if ( 0 == totalPositive)
    //    return -1;

    int positiveCount = 0;
    if (topN == -1)
        topN = rank->Size();

    int size = qTable->Capacity();

    //T* rank = simSet->GetRankTable(index);

    for (int i=0 ; i<topN ; i++)
    {
        Quid q = rank->Get1(i);
        //std::cout << QuidObj(q) << std::endl;

        // Note: groundTruth maybe have different size with rank table.
        //int curPos111 = groundTruth->GetIndex(q);

        //int curPos = Core::Table::SimilarityTableSet::FindQuid(q);
        int curPos = Column::Find(qTable->GetColumn1(), q);

        if (curPos == size)
        {
            // if returned index is equal to table size, it mean that quid is not found.
            std::cout << "Can NOT find the Quid: " << QuidObj(q) << std::endl;
            continue;
        }

        double prob = sim->Get1(curPos);
        
        if (groundTruth->IsPositive(q))
        {
            //fprintf(fp,"%d\t%d\n", i, 1);
            fprintf(fp,"%.17f\t%d\n", prob, 1);
        }
        else if (groundTruth->IsNegative(q))
        {
            //fprintf(fp,"%d\t%d\n", i, 0);
            fprintf(fp,"%.17f\t%d\n", prob, 0);
        }
        else
        {
            //skipped shots are ignored.
        }
    }

    int x = 0;
}

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

#endif

---