binarysplitter.h

Go to the documentation of this file.

/*

Copyright (c) 2003, Cornell University
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

   - Redistributions of source code must retain the above copyright notice,
       this list of conditions and the following disclaimer.
   - Redistributions in binary form must reproduce the above copyright
       notice, this list of conditions and the following disclaimer in the
       documentation and/or other materials provided with the distribution.
   - Neither the name of Cornell University nor the names of its
       contributors may be used to endorse or promote products derived from
       this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
THE POSSIBILITY OF SUCH DAMAGE.

*/

// -*- C++ -*-

#if !defined _CLUS_BINARYSPLITTER_H
#define _CLUS_BINARY_SPLITTER_H

#include "vec.h"
#include <iostream>

using namespace TNT;

/// @todo This solution is very ugly. Use virtual functions to get the same result

namespace CLUS
{

/** Base class for all the splitters. Specifies the interface */
class BinarySplitter
{
protected:
    /// the number of discrete split variables (nonregressers)
    int dsplitDim;

    /// the number of continuous split variables (nonregressoers)
    int csplitDim;
    
    /// the number of regressors
    int regDim;

    /// list of discrete domain sizes
    const Vector<int>& dDomainSize;
    
    /** Indicates on what variable this node splits on.
    If -1 we have an oblique split. */
    int SplitVariable;
    
    /** Contains the coeficients of the hyperplane that separates the 2 distributions
    in the input space. This is an oblique split */
    Vector<double> SeparatingHyperplane;
    
    /** Contains the probability for a value to be in the left partition. In
    traditional classifiers is set to 1.0 or 0.0 */
    Vector<double> splitSetProbability;

public:
    BinarySplitter():dDomainSize( *( new Vector<int>() ) ),SeparatingHyperplane(), splitSetProbability()
    {}
    
    BinarySplitter(const Vector<int>& DDomainSize,int CsplitDim, int RegDim):
            dsplitDim(DDomainSize.dim()), csplitDim(CsplitDim), regDim(RegDim),
            dDomainSize(DDomainSize),SeparatingHyperplane(),
            splitSetProbability()
    { }
    
    BinarySplitter(BinarySplitter& aux):
            dsplitDim(aux.dsplitDim),   csplitDim(aux.csplitDim),
            dDomainSize(aux.dDomainSize),SeparatingHyperplane(),
            splitSetProbability()
    { }

    int GetRegDim(void)
    {
        return regDim;
    }
    int GetCSplitDim(void)
    {
        return csplitDim;
    }
    
    int GetDSplitDim(void)
    {
        return dsplitDim;
    }
    
    const Vector<int>& GetDDomainSize(void)
    {
        return dDomainSize;
    }

    /** Decides what branch to choose.  */
    int ChooseBranch(const int* Dvars, const double* Cvars)
    {
        return 0;
    }
    /** Computes probability to take first branch. Need this to accomodate probabilistic splitters */
    double ProbabilityFirstBranch(const int* Dvars, const double* Cvars)
    {
        if (ChooseBranch(Dvars,Cvars)==0)
            return 1.0;
        else
            return 0.0;
    }

    /** Initializes the data structures used in split variable selection */
    void InitializeSplitStatistics(void)
    { }
    
    /** Updates the necessary statistics for split variable selection */
    void UpdateSplitStatistics(const int* Dvars, const double* Cvars,double p1,double p2)
    { }
    
    /** Decides on a split variable and frees the data structures used in split selection.
    @return 0 if a split variable could be computed, -1 otherwise.*/
    int ComputeSplitVariable(int type)
    {
        return 0;
    }
    
    /** Ask if it is worth doing more splits in the future */
    bool MoreSplits(int branch, int Min_no_datapoints)
    {
        return false;
    }
    
    /** Cleans up all the unnecessary statistics after the decision has been made */
    void DeleteTemporaryStatistics(void)
    { }
    
    void SaveToStream(ostream& out)
    {
        out << SplitVariable << " ( ";
        if (SplitVariable==-1)
        {
            // oblique split on continuous variables
            for (int i=0; i<SeparatingHyperplane.dim(); i++)
                out << SeparatingHyperplane[i] << " ";
        }
        else
            if (SplitVariable<=-2)
            {
                // Simple continuous split
                out << SeparatingHyperplane[0] << " " << SeparatingHyperplane[-SplitVariable-1];
            }
            else
            {
                // split on discrete variable
                for (int i=0; i<splitSetProbability.dim(); i++)
                    if (splitSetProbability[i]>.5)
                        out << i << " ";
            }
        out << " )";
    }


    ~BinarySplitter(void)
    {
        // dealocate all the resources
    }

};

}

#endif // _CLUS_BINARYSPLITTER_H

---