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

---

mainConceptLearnClient.cpp

Go to the documentation of this file.

// since we are not using libraries:
#include "Link/ImpalaLib.cpp"

#include "Util/StringParser.h"
#include "Core/VideoSet/MakeSegmentationDocument.h"
#include "Core/Trec/ActiveLearnEngineQuids.h"

namespace Impala {
namespace Application {

//using namespace Visualization;

class ConceptLearnClient
{
public:

    ConceptLearnClient()
    {
        CmdOptions& options = CmdOptions::GetInstance();

        mALE = new ActiveLearnEngineQuids();

        ILOG_INFO("Starting online learning...");
        DoActiveLearning();
    }

    Quid
    ParseQuid(std::string line)
    {
        ILOG_DEBUG("parsing Q = " << line);
        char *cline = (char*)line.c_str();
        char * pch;
        pch = strtok (cline,"(,)");

        pch = strtok (NULL, "(,)");

        int qclass = atoi(pch);
        pch = strtok (NULL, "(,)");
        int qset = atoi(pch);
        pch = strtok (NULL, "(,)");
        int qobject = atoi(pch);
        pch = strtok (NULL, "(,)");
        int qid = atoi(pch);
        pch = strtok (NULL, "(,)");

        return (((Quid) qclass) << QUID_CLASS_SHIFT) |
        (((Quid) qset) << QUID_SET_SHIFT) |
        (((Quid) qobject) << QUID_OBJECT_SHIFT) |
        (((Quid) qid) << QUID_ID_SHIFT);
    }

    void
    DoActiveLearning()
    {
        Timer tim;
        int ctim = tim.SplitTime();
        int manReset;

        manReset = 1;

        bool done = false;

        while (!done)
        {
            // load stage or print stage?
            if (!mALE->RequestSubmitted())
            {
                ILOG_INFO("Sending data to ALE...");
                // load stage:

                mALE->PrepRequest();

                // read positive keyframes from file:

                std::ifstream f("quids_positive.txt");
                while (! f.eof() )
                {
                    std::string line;
                    f >> line;
                    if (line == "") break;
                    Quid q = ParseQuid(line);
                    if (q<0) {
                        continue;
                    }

                    ILOG_DEBUG("Positive:" << QuidObj(q));
                    mALE->AddPositive(q);
                }
                f.close();


                // read negatives:

                std::ifstream fneg("quids_negative.txt");
                while (! fneg.eof() )
                {
                    std::string line;
                    fneg >> line;
                    if (line == "") break;
                    Quid q = ParseQuid(line);
                    if (q<0) {
                        continue;
                    }
                    ILOG_DEBUG("Negative:" << QuidObj(q));
                    mALE->AddNegative(q);
                }
                fneg.close();

                if (!mALE->Ready())
                {
                    ILOG_ERROR("ALE not ready. Aborting.");
                    return;
                }

                // submit request:
                mALE->SubmitRequest();
                // .. and wait!

                while (ctim+4 > tim.SplitTime());
                ctim = tim.SplitTime();

            } else {
                if (mALE->HasResults())
                {
                    // retrieve sage:
                    ILOG_INFO("Receiving data...");
                    std::list<Core::Trec::QuidResult> quids = mALE->RetrieveResults();
        
                    if (quids.size() > 0 && mALE->GetErrCount() < 200)
                    {
                        std::ostringstream b;
                        b << "result.txt";
                        std::string ofname = b.str();
                        std::ofstream out(ofname.c_str(), std::ios::out);
                        std::list<Core::Trec::QuidResult>::iterator i = quids.begin();
                        while (i != quids.end())
                        {
                            out << "001 Q0 " << QuidObj(i->quid) << " " << i->rank << " " << i->score << std::endl;
                            //out << "0" << topic << " Q0 " << shotname << " " << i->rank << " " << i->score << std::endl;
                            i++;
                        }
                        out.close();
                        manReset = 1;
                    } else {
                        ILOG_INFO("Results not yet valid, retrying...");
                        // wait a while...
                        while (ctim+3 > tim.SplitTime());
                        ctim = tim.SplitTime();
                    }
                    
                    manReset++;
                    if (manReset >3) 
                    {
                            ILOG_ERROR("We have waited too long, resetting...");
                            mALE->PrepareNewID();
                            manReset = 1;
                    } /*else 
                    {
                        ILOG_ERROR("FAILURE: could not find results for this set.");
                        done = true;
                    } */
                } else {
                    // no results yet, wait some more.
                    while (ctim+3 > tim.SplitTime());
                    ctim = tim.SplitTime();
                }
            }

        }

    }



private:

    ActiveLearnEngineQuids*          mALE;

    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(ConceptLearnClient, Application);

int
mainConceptLearnClient(int argc, char* argv[])
{
    CmdOptions& options = CmdOptions::GetInstance();
    options.Initialise(true, false, true);


    if (!options.ParseArgs(argc, argv, "", 0))
        return 1;

    std::cout << "starting ConceptLearnClient..." << std::endl;
    ConceptLearnClient* c = new ConceptLearnClient();

    return 1;
}

} // namespace Application
} // namespace Impala

int
main(int argc, char* argv[])
{
    return Impala::Application::mainConceptLearnClient(argc, argv);
}

---