RejectionStrategy.h

Go to the documentation of this file.

/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * Written (W) 2012 Sergey Lisitsyn
 * Copyright (C) 2012 Sergey Lisitsyn
 */

#ifndef _REJECTIONSTRATEGY_H___
#define _REJECTIONSTRATEGY_H___

namespace shogun
{

class CRejectionStrategy : public CSGObject
{
    public:
        CRejectionStrategy() { };

        virtual ~CRejectionStrategy() { };

        virtual const char* get_name() const
        {
                return "RejectionStrategy";
        };

        virtual bool reject(SGVector<float64_t> outputs) const = 0;

};

class CThresholdRejectionStrategy : public CRejectionStrategy
{
    public:

        CThresholdRejectionStrategy() :
            CRejectionStrategy(), m_threshold(0.0) { };

        CThresholdRejectionStrategy(float64_t threshold) :
            CRejectionStrategy(), m_threshold(threshold) { };

        virtual ~CThresholdRejectionStrategy() {};

        virtual const char* get_name() const
        {
            return "ThresholdRejectionStrategy";
        }

        virtual bool reject(SGVector<float64_t> outputs) const
        {
            for (int32_t i=0; i<outputs.vlen; i++)
            {
                if (outputs[i]>m_threshold)
                    return false;
            }
            return true;
        }

protected:

        float64_t m_threshold;


};

static const float64_t Q_test_statistic_values[10][8] = 
{
    /* 10,20,30,40,50,60,70,80,90,100 */
    {0.713,0.683,0.637,0.597,0.551,0.477,0.409,0.325},
    {0.627,0.604,0.568,0.538,0.503,0.450,0.401,0.339},
    {0.539,0.517,0.484,0.456,0.425,0.376,0.332,0.278},
    {0.490,0.469,0.438,0.412,0.382,0.337,0.295,0.246},
    {0.460,0.439,0.410,0.384,0.355,0.312,0.272,0.226},
    {0.437,0.417,0.388,0.363,0.336,0.294,0.256,0.211},
    {0.422,0.403,0.374,0.349,0.321,0.280,0.244,0.201},
    {0.408,0.389,0.360,0.337,0.310,0.270,0.234,0.192},
    {0.397,0.377,0.350,0.326,0.300,0.261,0.226,0.185},
    {0.387,0.368,0.341,0.317,0.292,0.253,0.219,0.179}
};

class CDixonQTestRejectionStrategy : public CRejectionStrategy
{
    public:

        CDixonQTestRejectionStrategy() :
            CRejectionStrategy()
        {
            s_index = 3;
        }
        
        CDixonQTestRejectionStrategy(float64_t significance_level) :
            CRejectionStrategy()
        {   
            if (significance_level==0.001)
                s_index = 0;
            else if (significance_level==0.002)
                s_index = 1;
            else if (significance_level==0.005)
                s_index = 2;
            else if (significance_level==0.01)
                s_index = 3;
            else if (significance_level==0.02)
                s_index = 4;
            else if (significance_level==0.05)
                s_index = 5;
            else if (significance_level==0.1)
                s_index = 6;
            else if (significance_level==0.2)
                s_index = 7;
            else SG_ERROR("Given significance level is not supported");
        }

        virtual ~CDixonQTestRejectionStrategy() 
        {
        }

        virtual const char* get_name() const
        {
            return "DixonQTestRejectionStrategy";
        }

        virtual bool reject(SGVector<float64_t> outputs) const
        {
            int32_t N = outputs.vlen;
            if (N<10 || N>100) 
                SG_ERROR("Given number of classes is not supported.");

            int32_t Ni = N/10 - 1;

            SGVector<float64_t> outputs_local = outputs.clone();
            CMath::qsort(outputs_local.vector,N);

            float64_t Q = 0.0;
            if (N==10)
                Q = (outputs[N-1]-outputs[N-2])/(outputs[N-1]-outputs[0]);

            if (N>=20)
                Q = (outputs[N-1]-outputs[N-4])/(outputs[N-1]-outputs[2]);

            if (Q>Q_test_statistic_values[Ni][s_index])
                return false;

            return true;
        }

private:

        int32_t s_index;

};

}
#endif