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

---

ActiveLearnEngine.h

Go to the documentation of this file.

#ifndef ActiveLearnEngine_h
#define ActiveLearnEngine_h

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

#include "Basis/Timer.h"

namespace Impala {

namespace Samples {

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

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

class ActiveLearnEngine
{
public:
    typedef Core::Trec::Thread                          Thread;
    typedef Core::Trec::ThreadSet                       ThreadSet;
    typedef Core::Trec::ShotResult                      ShotResult;
    typedef std::list<ShotResult>                       ShotResultList;

    ActiveLearnEngine(ThreadSet *set, Thread *positiveAnnotations,
                      Thread *negativeAnnotations)
    {
        mThreadSet = set;
        mPositive = positiveAnnotations;
        mNegative = negativeAnnotations;
        mAnnotations = new Core::Table::AnnotationTable();
        mTimer = new Timer();
        mTimer->Start();
        srand( time(NULL) );
        mInfoSent = false;
        mActiveID = "start";
        mAutoNegatives = true;
        mAutoNegativesNumber = 50;
        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
    AddAnnotations()
    {
        for (int i=0; i<mPositive->GetLength(); i++)
        {
            int shot = mPositive->GetShot(i);
            int keyframe = mThreadSet->GetKeyframes()->GetShotRKF(shot);
            Quid fquid = mThreadSet->GetKeyframes()->GetQuidFrame(keyframe);
//            ILOG_DEBUG("positive: " << QuidObj(fquid));
            mAnnotations->AddPositive(fquid);
        }

        for (int i=0; i<mNegative->GetLength(); i++)
        {
            int shot = mNegative->GetShot(i);
            int keyframe = mThreadSet->GetKeyframes()->GetShotRKF(shot);
            Quid fquid = mThreadSet->GetKeyframes()->GetQuidFrame(keyframe);
//            ILOG_DEBUG("negative: " << QuidObj(fquid));
            mAnnotations->AddNegative(fquid);
        }
        ILOG_DEBUG("Added annotations, table now with " << mAnnotations->GetNrPositive() << " positive shots and " << mAnnotations->GetNrNegative() << " negative shots.");
    }

    void
    AddPositive(Quid q)
    {
//        ILOG_DEBUG("added positive " << QuidObj(q));
        mAnnotations->AddPositive(q);
    }

    void
    AddNegative(Quid q)
    {
//        ILOG_DEBUG("added negative " << QuidObj(q));
        mAnnotations->AddNegative(q);
    }

    void
    AddRandomNegatives(int number)
    {
        ILOG_DEBUG("adding " << number << " random examples as negative...");
        for (int i=0; i<number; i++)
        {
            double rnd = ( (1.0 * rand()) / RAND_MAX);
            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)
        {
            if (mAutoNegatives) {
                ILOG_INFO("No negative examples given, selecting random subset...");
                AddRandomNegatives(mAutoNegativesNumber);
            } else {
                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());

        //ShotResultList out;

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

    ShotResultList
    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());

        ShotResultList 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;
            }
            */

            int keyframe = mThreadSet->GetKeyframes()->GetFrameId(q);

            if (keyframe < 0) {
                ILOG_WARN("erroneous result " << QuidObj(q) << " for this set, dropping.");
                mErrCount++;
                continue;
            }

            int shot = mThreadSet->GetKeyframes()->GetShotId(keyframe);

            if (shot > -1 && noduplicates.find(shot) == noduplicates.end())
            {
                ShotResult r;
                r.shotid = shot;
                r.rank = rrank++;
                r.score = conceptSet->GetSimTable(GetID())->Get1(conceptSet->FindQuid(q));
//                if (rrank < 10)
//                    ILOG_DEBUG("RECV: " << r.rank << ": " << r.shotid << " (" << r.score << ")");
                noduplicates[shot] = true;
                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.

        return true;
    }

private:


    ThreadSet *mThreadSet;
    Thread *mPositive, *mNegative;
    std::string mActiveID;
    Core::Table::AnnotationTable *mAnnotations;
    Util::Database *mALDatabase;
    bool mInfoSent;

    bool mAutoNegatives;
    int mAutoNegativesNumber;
    int mErrCount;

    Timer* mTimer;
    ILOG_VAR_DEC;

};
ILOG_VAR_INIT(ActiveLearnEngine, Core.Trec);


}

}


#endif

---