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

---

mainRandomForest.cpp

Go to the documentation of this file.

#include "Basis/ConfigBase.h"
#include "Core/ApplicationFactory.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/Column/Types.h"
#include <fstream>

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, DataFactory* 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,
            const Geometry::InterestPointList& points, int n, int classId)
{
    Geometry::InterestPointList::const_iterator itPoint = points.begin();
    std::set<int> indices = Util::RandomUniqueNumbers(n, points.size());
    int index=0;
    for(std::set<int>::iterator itIndex = indices.begin() ;
        itIndex != indices.end() ; ++itIndex)
    {
        while(index<*itIndex)
        {
            ++itPoint;
            ++index;
        }
        std::vector<Real64>& v = (*itPoint)->mDescriptor;
        Vector::VectorTem<double> vector(v.size(), &v[0], true);
        featureSampling.Add(vector, classId);
    }
}
    
void
GetFeatures(Feature::AnnotatedFeatureTable& featureSampling,
            const SelectionTable& quidSampling, DataFactory* 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));
        Geometry::InterestPointList pointList;
        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, pointList, descriptor,
             dSurfParams[0], dSurfParams[1], dSurfParams[2]);
        int classId = quidSampling.Get2(i);
        ILOG_DEBUG("point list size="<< pointList.size());
        GetNSamples(featureSampling, pointList, cPointPerImage, classId);
        pointList.EraseAndDelete();
        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::ApplicationFactory factory(&options);
        DataFactory* dataFactory = factory.MakeDataFactory();
        if(!dataFactory->CanWriteCodebook())
        {
            ILOG_WARNING("codebook already exists; skipping...");
            delete dataFactory;
            return 0;
        }
        
        // get the quids of the classes
        SelectionTable quidSampling(0);
        int nrClasses;
        SelectQuids(quidSampling, nrClasses, dataFactory);
        Feature::AnnotatedFeatureTable featureSampling
            (Vector::ColumnVectorSet(true, 64, 0), Column::ColumnInt32(0));
        
        // get the features
        GetFeatures(featureSampling, quidSampling, dataFactory, 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::SetRandomSeed(i);
            Feature::RandomTree* tree = Feature::MakeRandomTree
                (&featureSampling, nrClasses, config.depth, config.tries);
            Write(tree, &forest);
            if(config.dumpTreeCounts)
                DumpTreeCounts(tree, i);
            if(config.dumpTree)
                DumpTree(tree);
            delete tree;
        }

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


} // namespace

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

---