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

---

SearchJudge.h

Go to the documentation of this file.

#ifndef Impala_Core_Trec_SearchJudge_h
#define Impala_Core_Trec_SearchJudge_h

#include <vector>
#include "Basis/File.h"
#include "Basis/NativeTypes.h"
#include "Util/StringParser.h"

namespace Impala
{
namespace Core
{
namespace Trec
{


class SearchJudge
{
public:

    SearchJudge(String fileName)
    {
        Load(fileName);
    }

    void
    Load(String fileName)
    {
        File f(fileName, "r");
        mValid = f.Valid();
        if (! mValid)
            return;
        int nr = 0;
        while (! f.Eof())
        {
            String line = f.ReadLine(true);
            if (! line[0])
                continue;
            Util::StringParser p(line);
            mJudgeTopic.push_back(p.GetString(' '));
            int junk = p.GetInt();
            mJudgeShot.push_back(p.GetString(' '));
            mJudgeValue.push_back(p.GetInt(' ', false));
            nr++;
        }
        std::cout << "done reading " << nr << " qrels" << std::endl;
    }

    bool
    Valid()
    {
        return mValid;
    }

    void
    Stats()
    {
        for (int i=0 ; i<mJudgeTopic.size() ; i++)
        {
            int t = GetTopicIdx(mJudgeTopic[i]);
            mTopicNrJudged[t]++;
            if (mJudgeValue[i] == 1)
                mTopicNrRelevant[t]++;
        }
        for (int t=0 ; t<mTopicName.size() ; t++)
        {
            std::cout << "Topic " << mTopicName[t]
                      << ", nr judged = " << mTopicNrJudged[t]
                      << ", nr relevant = " << mTopicNrRelevant[t] << std::endl;
        }
    }

    bool
    HasTopic(String topic)
    {
        for (int i=0 ; i<mJudgeTopic.size() ; i++)
            if (mJudgeTopic[i] == topic)
                return true;
        return false;
    }

    int
    GetNrRelevant(String topic)
    {
        int t = GetTopicIdx(topic);
        return mTopicNrRelevant[t];
    }

    int
    GetNrJudged(String topic)
    {
        int t = GetTopicIdx(topic);
        return mTopicNrJudged[t];
    }

    std::vector<String> GetJudgedShots(String topic)
    {
        std::vector<String> shots;
        for (int i=0; i<mJudgeTopic.size(); i++)
            if (mJudgeTopic[i] == topic)
                shots.push_back(mJudgeShot[i]);
        return shots;
    }

    std::vector<int> GetJudgedValues(String topic)
    {
        std::vector<int> values;
        for (int i=0; i<mJudgeTopic.size(); i++)
            if (mJudgeTopic[i] == topic)
                values.push_back(mJudgeValue[i]);
        return values;
    }

    int
    Judge(String topic, String shot)
    {
        for (int i=0 ; i<mJudgeTopic.size() ; i++)
            if (mJudgeTopic[i] == topic)
                if (mJudgeShot[i] == shot)
                    return mJudgeValue[i];
        return -2;
    }

    // computes inferred average precision
    Real64
    Judge(String topic, std::vector<String> shots)
    {
        int unjudged = 0;
        int nonRel = 0;
        int rel = 0;
        Real64 infAP = 0;
        Real64 apAdd = 0;
        for (int s=0 ; s<shots.size() ; s++)
        {
            switch (Judge(topic, shots[s]))
            {
            case -1:
                unjudged++;
                break;
            case 0:
                nonRel++;
                break;
            case 1:
                rel++;                                          
                if (s == 0)
                {
                    infAP += 1; 
                }
                else
                {
                    Real64 k = s + 1;
                    Real64 relMin = rel - 1;
                    Real64 d = relMin + nonRel + unjudged;
                    Real64 eps = 0.00001;
                    apAdd = 1.0 / k + ((k-1) / k) *
                        (d / (k-1)) * ((relMin + eps) / (relMin + nonRel + 2*eps));
                    //std::cout << "apAdd = " << apAdd
                    //          << ", rel = " << rel << ", d = " << d << std::endl;
                    infAP += apAdd;
                }
                break;
            }
        }
        infAP /= GetNrRelevant(topic);
        return infAP;
    }

private:

    int
    GetTopicIdx(String name)
    {
        for (int i=0 ; i<mTopicName.size() ; i++)
            if (mTopicName[i] == name)
                return i;
        mTopicName.push_back(name);
        mTopicNrJudged.push_back(0);
        mTopicNrRelevant.push_back(0);
        return mTopicName.size() - 1;
    }

    bool mValid;

    // original data
    std::vector<String> mJudgeTopic;
    std::vector<String> mJudgeShot;
    std::vector<int>    mJudgeValue;

    // per topic data
    std::vector<String> mTopicName;
    std::vector<int>    mTopicNrJudged;
    std::vector<int>    mTopicNrRelevant;

};

} // namespace Trec
} // namespace Core
} // namespace Impala

#endif

---