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

---

mainRandomForest.cpp

Go to the documentation of this file.

#include "Basis/ConfigBase.h"
#include "Core/Training/Factory.h"
#include "Core/Array/RGB2Intensity.h"
#include "Core/Array/PixMax.h"
#include "Core/Array/MulVal.h"
#include "Core/Feature/Surf.h"
#include "Core/Feature/MakeRandomTree.h"
#include "Core/Feature/RandomForest.h"
#include "Core/Feature/PointDescriptorTable.h"
#include "Core/Column/Types.h"
#include <fstream>

// not used, but needed because of factory. sigh...
#include "Link/Svm/LinkSvm.cpp"

namespace
{

using namespace Impala;
using namespace Core;

typedef Table::TableTem<Column::ColumnQuid,
                        Column::ColumnInt32> SelectionTable;

const int cNrImages = 50;
const int cPointPerImage = 250;
// const int cNrImages = 10;
//const int cPointPerImage = 50;
    
void
PickRandomSamples(SelectionTable& quids, Table::QuidTable* src, int classId)
{
    Util::QuasiRandomSequenceIterator it(src->Size(), 0);
    for(int i=0 ; i<cNrImages ; ++i)
    {
        quids.Add(src->Get1(*it), classId);
        ++it;
    }
}
    
void
SelectQuids(SelectionTable& quids, int& nrClasses, Training::Factory* factory)
{
    ILOG_VAR(main);
    std::vector<String> concepts = factory->MakeConceptList();
    if(concepts.size() == 0)
        ILOG_ERROR("couldn't open concept list");
    nrClasses = concepts.size();
    for(int i=0 ; i<nrClasses ; ++i)
    {
        Table::AnnotationTable* anno = factory->MakeAnnotation(concepts[i]);
        Table::QuidTable* pos = anno->GetPositive();
        ILOG_INFO(pos->Size() << " positive annotations");
        if(pos->Size() < cNrImages)
        {
            ILOG_WARN("not enough positive examples for concept "<< concepts[i]);
            continue;
        }
        PickRandomSamples(quids, pos, i);
    }
    // check size of quids for validity?
    ILOG_INFO(quids.Size() << " quids found");
}

void
GetNSamples(Feature::AnnotatedFeatureTable& featureSampling,
            Feature::PointDescriptorTable* pointData, int n, int classId)
{
    static Util::Random sRNG;
    std::set<int> indices = sRNG.RandomUniqueNumbers(n, pointData->Size());
    for(std::set<int>::iterator itIndex = indices.begin() ;
        itIndex != indices.end() ; ++itIndex)
    {
        int index = *itIndex;
        Vector::VectorTem<double> vector(pointData->GetDescriptorLength(), 
            pointData->GetDescriptorData(index), true);
        featureSampling.Add(vector, classId);
    }
}
    
void
GetFeatures(Feature::AnnotatedFeatureTable& featureSampling,
            const SelectionTable& quidSampling, Training::Factory* factory,
            int dSurfParams[3])
{
    ILOG_FUNCTION(GetFeatures);
    for(int i=0 ; i<quidSampling.Size() ; ++i)
    {
        ILOG_PROGRESS(i <<" of "<< quidSampling.Size() <<" processed", 4.);
        Quid q = quidSampling.Get1(i);
        Array::Array2dVec3UInt8* image = factory->MakeImage(q);
        if(image == 0)
            ILOG_ERROR("couldn't get image of quid "<< QuidObj(q));
        Feature::PointDescriptorTable* pointData = new 
            Feature::PointDescriptorTable(Feature::FeatureDefinition(""));
        String descriptor = factory->GetFeatureDefinition().GetName();
        ILOG_DEBUG("d="<<descriptor);
        descriptor = descriptor.substr(descriptor.find("-")+1);
        descriptor = StringReplace(descriptor, "surf", "");
        ILOG_DEBUG("d="<<descriptor);
        Feature::CalculateSurfDescriptors
            (image, pointData, descriptor,
             dSurfParams[0], dSurfParams[1], dSurfParams[2]);
        int classId = quidSampling.Get2(i);
        ILOG_DEBUG("point list size="<< pointData->Size());
        GetNSamples(featureSampling, pointData, cPointPerImage, classId);
        delete pointData;
        delete image;
    }
    ILOG_PROGRESS_DONE("all processed");
}

void
DumpDescriptors(Feature::AnnotatedFeatureTable& featureSampling)
{
    std::ofstream ofs("descriptordump.txt");
    if(ofs.is_open())
    {
        Feature::Dump(&featureSampling, ofs);
        ofs.close();
    }
}

void
DumpTree(Feature::RandomTree* tree)
{
    ILOG_FUNCTION(main);
    std::ofstream ofs("treedump.txt");
    if(ofs.is_open())
    {
        tree->Dump(ofs, 10000);
        ofs.close();
    }
    else
        ILOG_ERROR("couldn't dump trees");
}

void
DumpTreeCounts(Feature::RandomTree* tree, int i)
{
    ILOG_FUNCTION(main);
    std::ofstream ofs(("countdump"+MakeString(i)+".txt").c_str());
    if(ofs.is_open())
    {
        tree->DumpCount(ofs);
        ofs.close();
    }
    else
        ILOG_ERROR("couldn't dump tree counts");
}

void
ProjectAndDump(Feature::FeatureTable* codebook,
               Feature::AnnotatedFeatureTable& featureSampling)
{
    ILOG_FUNCTION(main);
    int codebookLength = GetCodebookLength(codebook);
    int* hist = new int[codebookLength];
    for(int i=0 ; i<codebookLength ; ++i)
        hist[i] = 0;
    Feature::RandomForest forest = ReadRandomForest(codebook);
    for(int i=0; i<featureSampling.Size(); ++i)
    {
        for(int f=0; f<forest.size(); ++f)
        {
            Feature::RandomTree* tree = forest[f];
            int codeword = tree->GetCodeWord(featureSampling.Get1(i));
            ++hist[codeword];
        }
    }
    DeleteForest(forest);
    std::ofstream ofs("projectiondump.txt");
    if(ofs.is_open())
    {
        for(int i=0 ; i<codebookLength ; ++i)
            ofs << i <<": #"<< hist[i] <<"\n";
        ofs.close();
    }
    else
        ILOG_ERROR("couldn't dump projection");
    delete hist;
}


class RandomForestConfig : public ConfigBase
{
public:
    RandomForestConfig() :
        depth(10), tries(32), dumpTree(false), dumpTreeCounts(false),
        projectAndDump(false)
    {
        // don't know about next part, defaults come from Feature::AddSurfOptions
        surfParams[0] = 3;
        surfParams[1] = 2;
        surfParams[2] = 4;
    }

    void InitOptions(CmdOptions& co)
    {
        co.AddOption(0, "dumpTree", "", "0");
        co.AddOption(0, "dumpTreeCounts", "", "0");
        co.AddOption(0, "projectAndDump", "", "0");
        co.AddOption(0, "forest-tries", "int", "32");
        co.AddOption(0, "forest-depth", "int", "10");
        Feature::AddDSurfOptions(co);
    }

    void RetrieveOptions(CmdOptions& co)
    {
        depth  = co.GetInt("forest-depth", depth);
        tries  = co.GetInt("forest-tries", tries);
        dumpTree = co.GetBool("dumpTree");
        dumpTreeCounts = co.GetBool("dumpTreeCounts");
        projectAndDump = co.GetBool("projectAndDump");
        Feature::GetDSurfOptions(co, surfParams[0], surfParams[1], surfParams[2]);
    }

private:
    int surfParams[3];
    int depth;                                   
    int tries;                                   
    bool dumpTree, dumpTreeCounts, projectAndDump;

    friend int RandomForest(int argc, char** argv);
};

int RandomForest(int argc, char** argv)
{
    ILOG_FUNCTION(main);
    RandomForestConfig config;
    CmdOptions& options = CmdOptions::GetInstance();
    options.Initialise(false, false, true);
    config.InitOptions(options);
    if (options.ParseArgs(argc, argv, "dataSet concepts 0 featureDef", 4))
    {
        // setup the application
        config.RetrieveOptions(options);
        Core::Training::Factory factory(&options, false);
        if (factory.CodebookExists())
        {
            ILOG_WARNING("codebook already exists; skipping...");
            return ILOG_ERROR_COUNT;
        }
        
        // get the quids of the classes
        SelectionTable quidSampling(0);
        int nrClasses;
        SelectQuids(quidSampling, nrClasses, &factory);
        Feature::AnnotatedFeatureTable featureSampling
            (Vector::ColumnVectorSet(true, 64, 0), Column::ColumnInt32(0));
        
        // get the features
        GetFeatures(featureSampling, quidSampling, &factory, config.surfParams);
        ILOG_INFO("got "<< featureSampling.Size() <<" samples for random forest");
        
        // make the forest
        Feature::RandomTreeTable forest(0);
        for(int i=0 ; i<4 ; ++i)
        {
            Util::Random rng;
            rng.SetSeed(i);
            Feature::RandomTree* tree = Feature::MakeRandomTree
                (&featureSampling, nrClasses, config.depth, config.tries, rng);
            Write(tree, &forest);
            if(config.dumpTreeCounts)
                DumpTreeCounts(tree, i);
            if(config.dumpTree)
                DumpTree(tree);
            delete tree;
        }

        if(forest.Size() > 0)
        {
            // save results to disk
            Feature::FeatureTable* ft = Feature::MakeFeatureTable(&forest);
            if(config.projectAndDump)
                ProjectAndDump(ft, featureSampling);
            factory.WriteCodebook(ft);
            ILOG_INFO("saved code books");
            delete ft;
        }
    }
    return ILOG_ERROR_COUNT;
}


} // namespace

int
main(int argc, char* argv[])
{
    return RandomForest(argc, argv);
}

---