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

---

TestMakeRandomTree.h

Go to the documentation of this file.

#ifndef Impala_Core_Feature_Test_TestMakeRandomTree_h
#define Impala_Core_Feature_Test_TestMakeRandomTree_h

#include <cppunit/extensions/HelperMacros.h>
#include <algorithm>

#include "Core/Feature/MakeRandomTree.h"

namespace Impala
{
namespace Core
{
namespace Feature
{

class TestMakeRandomTree : public CPPUNIT_NS::TestFixture
{
    CPPUNIT_TEST_SUITE(TestMakeRandomTree);
    CPPUNIT_TEST(testMakeHistogram);
    CPPUNIT_TEST(testGain);
    CPPUNIT_TEST(testSplitSet);
    CPPUNIT_TEST(testTryRandomSplit);
    CPPUNIT_TEST(testFindSplit);
    CPPUNIT_TEST(testTopLevel);
    CPPUNIT_TEST(testReferenceMatlab);
    CPPUNIT_TEST_SUITE_END();
    
public:

    void
    setUp()
    {
        mNumberClasses = 4;
        mFakeData = new AnnotatedFeatureTable
            (Vector::ColumnVectorSet(true, 3, 0), Column::ColumnInt32(0));
        mFakeData->Add(Vector::VectorReal64(0.00,-2.00, 6.00), 0);
        mFakeData->Add(Vector::VectorReal64(0.01,-2.01, 6.01), 0);
        mFakeData->Add(Vector::VectorReal64(0.02,-2.02, 6.02), 0);
        mFakeData->Add(Vector::VectorReal64(1.03, 0.03, 1.03), 1);
        mFakeData->Add(Vector::VectorReal64(2.04, 1.04, 2.04), 1);
        mFakeData->Add(Vector::VectorReal64(3.05, 0.05, 3.05), 1);
        mFakeData->Add(Vector::VectorReal64(3.06, 1.06, 1.06), 2);
        mFakeData->Add(Vector::VectorReal64(2.07, 0.07, 2.07), 2);
        mFakeData->Add(Vector::VectorReal64(1.08, 1.08, 3.08), 2);
        mFakeData->Add(Vector::VectorReal64(2.09, 0.09, 6.09), 3);
        mFakeData->Add(Vector::VectorReal64(2.10, 1.10, 6.10), 3);
        mFakeData->Add(Vector::VectorReal64(2.11, 0.11, 6.11), 3);

        for(int i=0 ; i<12 ; ++i)
        {
            mFilterAll[i] = true;
            mFilterHalf[i] = i<6;
            mFilterHalfComp[i] = i>=6;
            mFilterQuarter[i] = i<3;
            mFilterQuarterComp[i] = i>=3;
            mFilterOdd[i] = i%2 == 0;
            mFilterEven[i] = i%2 == 1;
        }
    }

    void
    tearDown()
    {
        delete mFakeData;
    }

    void
    testMakeHistogram()
    {
        Histogram::Histogram1dTem<int>* histAll =
            MakeHistogram(mFakeData, mNumberClasses, mFilterAll);
        Histogram::Histogram1dTem<int>* histHalf =
            MakeHistogram(mFakeData, mNumberClasses, mFilterHalf);
        Histogram::Histogram1dTem<int>* histOdd =
            MakeHistogram(mFakeData, mNumberClasses, mFilterOdd);
        CPPUNIT_ASSERT_EQUAL(mNumberClasses, histAll->Size());
        CPPUNIT_ASSERT_EQUAL(mNumberClasses, histHalf->Size());
        CPPUNIT_ASSERT_EQUAL(mNumberClasses, histOdd->Size());
        // this loop iterates over the four elements in the histograms and does
        // the appropriate tests.
        for(int i=0 ; i<4 ; ++i)
        {
            CPPUNIT_ASSERT_EQUAL(3, histAll->Elem(i));
            CPPUNIT_ASSERT_EQUAL((i<2) ? 3 : 0, histHalf->Elem(i));
            CPPUNIT_ASSERT_EQUAL((i%2) ? 1 : 2, histOdd->Elem(i));
        }
        delete histAll;
        delete histHalf;
        delete histOdd;
    }

    void
    testGain()
    {
        double gainHalf = Gain(mFakeData, mNumberClasses,
                               mFilterHalf, mFilterHalfComp);
        double gainQuarter = Gain(mFakeData, mNumberClasses,
                                  mFilterQuarter, mFilterQuarterComp);
        double gainOdd = Gain(mFakeData, mNumberClasses,
                              mFilterOdd, mFilterEven);
        CPPUNIT_ASSERT(gainHalf > gainQuarter);
        CPPUNIT_ASSERT(gainQuarter > gainOdd);
    }
    
    void
    testSplitSet()
    {
        bool* left;
        bool* right;
        SplitSet(left, right, 1, -1., mFakeData, mFilterAll);
        CPPUNIT_ASSERT(Util::Equal(left, mFilterQuarter, 12));
        CPPUNIT_ASSERT(Util::Equal(right, mFilterQuarterComp, 12));
        delete left;
        delete right;
        SplitSet(left, right, 2, -3., mFakeData, mFilterOdd);
        CPPUNIT_ASSERT_EQUAL(0, Util::Count(left, 12));
        CPPUNIT_ASSERT(Util::Equal(right, mFilterOdd, 12));
    }

    void
    testTryRandomSplit()
    {
        int dim;
        double val;
        double gain;
        bool filter[12] = {false};
        filter[3] = true;
        TryRandomSplit(dim, val, gain, mFakeData, filter, mNumberClasses);
        CPPUNIT_ASSERT_EQUAL(mFakeData->Get1(3)[dim], val);
        filter[3] = false;
        filter[7] = true;
        TryRandomSplit(dim, val, gain, mFakeData, filter, mNumberClasses);
        CPPUNIT_ASSERT_EQUAL(mFakeData->Get1(7)[dim], val);
    }

    void
    testFindSplitWithSeed(int seed)
    {
        Util::SetRandomSeed(seed);
        // get the gain of the first random split
        int dim;
        double val;
        double gain;
        TryRandomSplit(dim, val, gain, mFakeData, mFilterAll, mNumberClasses);
        Util::SetRandomSeed(seed);
        FindSplit(dim, val, mFakeData, mFilterAll, mNumberClasses, 20);
        bool* left;
        bool* right;
        SplitSet(left, right, dim, val, mFakeData, mFilterAll);
        // Because we reset the random seed the gain of SplitSet must be greater
        // or equal to the previously computed gain.
        CPPUNIT_ASSERT(gain <= Gain(mFakeData, mNumberClasses, left, right));
    }

    void
    testFindSplit()
    {
        testFindSplitWithSeed(1);
        testFindSplitWithSeed(2);
        testFindSplitWithSeed(3);
    }

    void
    testTopLevel()
    {
        RandomTree* tree = MakeRandomTree(mFakeData, mNumberClasses, 2, 1000);
        //we'll assume 50 tries leads to optimal results (only 12 data points)
        int dim;
        double val;
        tree->GetSplit(dim, val);
        ILOG_DEBUG("dim:"<< dim <<" val:"<< val);
        CPPUNIT_ASSERT_EQUAL(2, dim);
        CPPUNIT_ASSERT_EQUAL(6.00, val);
    }

    void
    testReferenceMatlab()
    {
        for(int i=0 ; i<3 ; ++i)
            ReferenceTest();
    }
    
    void
    ReferenceTest()
    {
        /* problem and outcome copied from reference implementation of Jasper

           data = ...
           [1 1;
            1 1;
            0 0;
            0 0;
            0 0;
            0 1;
            0 1;
            0 1;
            0 1;
            1 0;
            1 0;
            1 0;
            1 0;
            1 0];

           class = [1;1;2;2;2;3;3;3;3;4;4;4;4;4];

           % depth = 2, nTrial = 25
           [maps boundaries counts] = RandomEntropyTreeIdxTest(data, class, 2, 25);
  
           === Output ===
           gain = -0.9242
           gain = 0
           gain = 0
         */
        
        AnnotatedFeatureTable data(Vector::ColumnVectorSet(true, 2, 0),
                                   Column::ColumnInt32(0));
        data.Add(Vector::VectorReal64(1, 1), 1);
        data.Add(Vector::VectorReal64(1, 1), 1);
        data.Add(Vector::VectorReal64(0, 0), 2);
        data.Add(Vector::VectorReal64(0, 0), 2);
        data.Add(Vector::VectorReal64(0, 0), 2);
        data.Add(Vector::VectorReal64(0, 1), 3);
        data.Add(Vector::VectorReal64(0, 1), 3);
        data.Add(Vector::VectorReal64(0, 1), 3);
        data.Add(Vector::VectorReal64(0, 1), 3);
        data.Add(Vector::VectorReal64(1, 0), 4);
        data.Add(Vector::VectorReal64(1, 0), 4);
        data.Add(Vector::VectorReal64(1, 0), 4);
        data.Add(Vector::VectorReal64(1, 0), 4);
        data.Add(Vector::VectorReal64(1, 0), 4);
        RandomTree* tree = MakeRandomTree(&data, 5, 2, 25);
    }
    
private:
    int mNumberClasses;
    AnnotatedFeatureTable* mFakeData;
    bool mFilterAll[12];
    bool mFilterHalf[12];
    bool mFilterHalfComp[12];
    bool mFilterQuarter[12];
    bool mFilterQuarterComp[12];
    bool mFilterOdd[12];
    bool mFilterEven[12];
    ILOG_CLASS;
};

ILOG_CLASS_INIT(TestMakeRandomTree, Impala.Core.Feature);

CPPUNIT_TEST_SUITE_REGISTRATION( TestMakeRandomTree );
    
} // namespace Feature
} // namespace Sandbox
} // namespace Impala

#endif
    

---