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

---

ActiveLearnEngineQuids.h

Go to the documentation of this file.

#ifndef ActiveLearnEngineQuids_h
#define ActiveLearnEngineQuids_h

#include "Basis/ILog.h"
#include "Core/Table/SimilarityTableSet.h"
#include "Util/Database.h"
#include "Core/Trec/QuidResult.h"

#include "Basis/Timer.h"

namespace Impala {

namespace Application {

//using namespace Visualization::GUI;
//using namespace Core::Trec;

typedef Core::Table::TableTem<Core::Column::ColumnTem<Int32>, Core::Column::ColumnTem<double> > ShotWithWeight;

class ActiveLearnEngineQuids
{
public:
    typedef std::list<Core::Trec::QuidResult>                       QuidResultList;

    ActiveLearnEngineQuids()
    {
        mAnnotations = new Core::Table::AnnotationTable();
        mTimer = new Timer();
        mTimer->Start();
        srand( time(NULL) );
        mInfoSent = false;
        mActiveID = "start";
        mErrCount = 0;

        mALDatabase = new Util::Database("activelearning");
        mALDatabase->SetOverride(true);
    }

    void
    PrepareNewID()
    {
        mActiveID = "al" + mTimer->SplitTimeStr();
        mInfoSent = false;
    }

    std::string
    GetID()
    {
        return mActiveID;
    }

    bool
    RequestSubmitted()
    {
        return mInfoSent;
    }

    int
    GetErrCount()
    {
        return mErrCount;
    }

    void
    PrepRequest()
    {
        if (mInfoSent)
            return;

        PrepareNewID();

        ILOG_DEBUG("SubmitRequest(), ID for submit = " << GetID());

        mAnnotations->SetEmpty();

    }


    void
    AddPositive(Quid q)
    {
        mAnnotations->AddPositive(q);
    }

    void
    AddNegative(Quid q)
    {
        mAnnotations->AddNegative(q);
    }

    void
    AddRandomNegatives(int number)
    {
        ILOG_DEBUG("adding " << number << " random examples as negative...");
        Core::Table::QuidTable allquids;
        Core::Table::Read(&allquids, "unc-both2-2sift-p112213.columns.tab", &Util::Database::GetInstance() );
        ILOG_DEBUG("Found " << allquids.Size() << " quids.");
        for (int i=0; i<number; i++)
        {
            int rnd = ( (1.0 * rand()) / RAND_MAX) * allquids.Size();
            Quid randomquid = allquids.Get1(rnd);
            if (QuidClass(randomquid) != QUID_CLASS_IMAGE)
                AddNegative(randomquid);
//            int randomkeyframe = rnd * (mThreadSet->GetKeyframes()->GetNrKeyframes()-1);
//            Quid randomkeyquid = mThreadSet->GetKeyframes()->GetQuidFrame(randomkeyframe);
//            AddNegative(randomkeyquid);
        }
    }

    void
    SubmitRequest()
    {
        if (mInfoSent)
            return;

        if (mAnnotations->GetNrPositive() == 0)
        {
            ILOG_WARN("No positive examples, ALE request not submitted.");
            return;
        }

        if (mAnnotations->GetNrNegative() == 0)
        {
            ILOG_WARN("No negative examples and random selection disabled, ALE request not submitted.");
            return;
        }

        ILOG_DEBUG("Using table with " << mAnnotations->GetNrPositive() << " positive shots and " << mAnnotations->GetNrNegative() << " negative shots.");

        String dir = "Annotations/" + QuidClassToString(QUID_CLASS_FRAME) + "/" + "conceptsActiveLearn.txt";        
        String filename = mALDatabase->GetFilePath(dir, GetID() + ".tab", true, false);

        ILOG_DEBUG("Writing to " << filename << "...");

        Core::Table::Write(mAnnotations, filename, mALDatabase, true);

        ILOG_DEBUG("Signalling active learning engine...");
        
        String startlearnfile = mALDatabase->GetFilePath(dir, "startlearner.txt", true, false);

        Util::IOBuffer *slf = mALDatabase->GetIOBuffer(
                                startlearnfile, false, false, "tmp");
        if (!slf)
        {
            ILOG_WARN("No startlearnfile, ALE request not submitted.");
            return;
        }
        slf->IOBuffer::Puts(GetID());
        delete slf;

        ILOG_DEBUG("Signal sent.");
        mInfoSent = true;
    }

    bool
    HasResults()
    {
        ILOG_DEBUG("Locating results...");

        String dir =
            "SimilarityIndex/conceptsActiveLearn.txt/activelearn/activelearn";

        String path = mALDatabase->GetFilePath(dir, "names.txt", false, false);
        Core::Table::SimilarityTableSet *conceptSet = 
            Core::Table::SimilarityTableSet::MakeFromFile(path, mALDatabase);

        Core::Table::SimilarityTableSet::RankTableType* rank = conceptSet->GetRankTable(GetID());

        //QuidResultList out;

        if (!rank)
        {
            ILOG_DEBUG("ID " << GetID() << " not (yet) found.");
            delete conceptSet;
            return false;
        }
        delete conceptSet;
        ILOG_DEBUG("ID " << GetID() << " found!");
        return true;
    }

    QuidResultList
    RetrieveResults()
    {
        ILOG_DEBUG("Retrieving results...");

        String dir =
            "SimilarityIndex/conceptsActiveLearn.txt/activelearn/activelearn";

        String path = mALDatabase->GetFilePath(dir, "names.txt", false, false);

        Core::Table::SimilarityTableSet *conceptSet = 
            Core::Table::SimilarityTableSet::MakeFromFile(path, mALDatabase);

        Core::Table::SimilarityTableSet::RankTableType* rank = conceptSet->GetRankTable(GetID());

        QuidResultList out;

        if (!rank)
        {
            ILOG_DEBUG("Could not find ID, no data present. :'(");
            delete conceptSet;
            return out;
        }

        mInfoSent = false;

        int results = 5000;

        ILOG_DEBUG("Concept loaded, converting to list...");
        // find the Thread using the "concept" name

        std::map<int,bool> noduplicates;
        int rrank = 1;
        mErrCount = 0;
        int dropcount = 0;
        for (int i=0; i<results; i++)
        {

            Quid q = rank->Get1(i);
/*            if (QuidSet(q) == 23) {
                dropcount++; 
                // ILOG_DEBUG("silent drop of result " << i <<": from topic set.");
                mErrCount++;
                continue;
            } */
/*            if (QuidSet(q) != 11 && QuidSet(q) != 12) {
                ILOG_ERROR("data not from trec2008devel or test set, dropping results.");
                // added to limit effects of race condition
                // which happens when the server is still writing results and the
                // user already is loading the file. A better approach would be to
                // rewrite this entire file to use network comms instead of thumper
                // based comms instead.
                mErrCount++;
                mInfoSent = true;
                delete conceptSet;
                return out;
            }
*/

            if (q != 0)
            {
                Core::Trec::QuidResult r;
                r.quid = q;
                r.rank = rrank++;
                r.score = conceptSet->GetSimTable(GetID())->Get1(conceptSet->FindQuid(q));
                //ILOG_DEBUG("quid " << QuidObj(q) << " has score " << r.score);
                out.push_back(r);
            }
        }
       
        if (dropcount > 0)
            ILOG_DEBUG("there were " << dropcount << " silent drops from results");
        if (mErrCount > 0)
            ILOG_DEBUG("there were " << mErrCount << " errors while receiving results");

        delete conceptSet;

        return out;
    }

    bool
    Ready()
    {
        // return true iff input is correct, and engine is ready to learn new results.

        if (mAnnotations->GetNrPositive() == 0)
        {
            ILOG_WARN("No positive examples, ALE not ready.");
            return false;
        }

        if (mAnnotations->GetNrNegative() == 0)
        {
            ILOG_WARN("No negative examples, ALE not ready.");
            return false;
        }


        return true;
    }

private:

    std::string mActiveID;
    Core::Table::AnnotationTable *mAnnotations;
    Util::Database *mALDatabase;
    bool mInfoSent;

    int mErrCount;

    Timer* mTimer;
    ILOG_VAR_DEC;

};
ILOG_VAR_INIT(ActiveLearnEngineQuids, Core.Trec);


}

}


#endif

---