LeafNode Class Reference

#include <naive_bayes.h>

Public Member Functions
	LeafNode (const std::vector< MultidimArray< double > > &leafFeatures, int _discrete_levels=8)
	Constructor. More...
double	assignProbability (double value, int k) const
	Assign probability to a value within the PDF of a given class. More...
double	computeWeight () const
	Compute weight of this leaf as a classifier. More...

Public Attributes
int	__discreteLevels
std::vector< IrregularHistogram1D >	__leafPDF
int	K

Friends
std::ostream &	operator<< (std::ostream &_out, const LeafNode &leaf)
	Show. More...

Detailed Description

Leaf node class.

This class is for a single feature. After receiving a set of features, it discretizes the features and builds the probability density function in an irregular histogram. There is an irregular histogram for each class.

Definition at line 45 of file naive_bayes.h.

Constructor & Destructor Documentation

LeafNode()

LeafNode::LeafNode	(	const std::vector< MultidimArray< double > > &	leafFeatures,
		int	_discrete_levels = 8
	)

Constructor.

Definition at line 127 of file naive_bayes.cpp.

{
    __discreteLevels = discrete_levels;
    K = leafFeatures.size();
    if (__discreteLevels==0)
    {
        // This is a dummy node for features that cannot classify
        MultidimArray<int> newBins(1);
        A1D_ELEM(newBins,0)=0;
        Histogram1D hist;
        hist.resize(1);
        A1D_ELEM(hist,0)=1;
        IrregularHistogram1D irregHist;
        for (int k=0; k<K; k++)
        {
            irregHist.init(hist, newBins);
            irregHist.selfNormalize();
            __leafPDF.push_back(irregHist);
        }
    }
    else
    {
        // Compute the minimum and maximum of each class
        double minval=0.;
        double maxval=0.;
        for(int k=0; k<K; k++)
        {
            double minvalk=0.;
            double maxvalk=0.;
            leafFeatures[k].computeDoubleMinMax(minvalk, maxvalk);
            if (k==0)
            {
                minval=minvalk;
                maxval=maxvalk;
            }
            else
            {
                minval=std::min(minval,minvalk);
                maxval=std::max(maxval,maxvalk);
            }
        }
        if (minval==maxval)
        {
            __discreteLevels=0;
            return;
        }

        // Compute the PDF of each class
        std::vector<Histogram1D> hist(K);
        for (int k=0; k<K; k++)
        {
            // There is variation of this feature for this class
            compute_hist(leafFeatures[k], hist[k], minval, maxval, 100);
            hist[k] += 1; // Apply Laplace correction
        }

        // Split the histograms into discrete_level (power of 2) bins
        std::queue< Matrix1D<int> > intervals;
        std::queue< Matrix1D<int> > splittedIntervals;
        Matrix1D<int> limits(2);
        VECTOR_R2(limits,0,99);
        intervals.push(limits);
        int imax=ROUND(log2(__discreteLevels));
        for (int i=0; i<imax; i++)
        {
            // Split all the intervals in the queue
            while (!intervals.empty())
            {
                Matrix1D<int> currentInterval = intervals.front();
                intervals.pop();
                int lsplit = splitHistogramsUsingEntropy(hist,
                             currentInterval(0), currentInterval(1));
                VECTOR_R2(limits,currentInterval(0),lsplit);
                splittedIntervals.push(limits);
                VECTOR_R2(limits,lsplit+1, currentInterval(1));
                splittedIntervals.push(limits);
            }

            // Copy the splitted intervals to the interval list
            while (!splittedIntervals.empty())
            {
                intervals.push(splittedIntervals.front());
                splittedIntervals.pop();
            }
        }

        // Compute the bins of the split
        MultidimArray<int> newBins(__discreteLevels);
        imax=intervals.size();
        for (int i=0; i<imax; i++)
        {
            if (i<__discreteLevels)
                A1D_ELEM(newBins,i) = intervals.front()(1);
            intervals.pop();
        }

        // Compute now the irregular histograms
        IrregularHistogram1D irregHist;
        for (int k=0; k<K; k++)
        {
            irregHist.init(hist[k], newBins);
            irregHist.selfNormalize();
            __leafPDF.push_back(irregHist);
        }
    }
}

Member Function Documentation

assignProbability()

double LeafNode::assignProbability	(	double	value,
		int	k
	)		const

Assign probability to a value within the PDF of a given class.

Definition at line 244 of file naive_bayes.cpp.

{
    const IrregularHistogram1D& hist=__leafPDF[k];
    int index = hist.val2Index(value);
    return DIRECT_A1D_ELEM(hist.__hist,index);
}

computeWeight()

double LeafNode::computeWeight

(

)

const

Compute weight of this leaf as a classifier.

Definition at line 252 of file naive_bayes.cpp.

{
    double retval=0;
    for (int k1=0; k1<K; k1++)
        for (int k2=0; k2<K; k2++)
        {
            if (k1==k2)
                continue;
            retval+=KLDistance(
                        __leafPDF[k1].getHistogram(),
                        __leafPDF[k2].getHistogram());
        }
    return (retval/(K*K-K));
}

Friends And Related Function Documentation

operator<<

std::ostream& operator<< ( std::ostream &  _out, const LeafNode &  leaf  )

friend

Show.

Definition at line 268 of file naive_bayes.cpp.

{
    for (int k=0; k<leaf.K; k++)
        _out << "Histogram of class " << k << "=\n"
        << leaf.__leafPDF[k] << std::endl;
    _out << "Classification power=" << leaf.computeWeight() << std::endl;
    return _out;
}

Member Data Documentation

__discreteLevels

int LeafNode::__discreteLevels

Definition at line 49 of file naive_bayes.h.

__leafPDF

std::vector< IrregularHistogram1D > LeafNode::__leafPDF

Definition at line 52 of file naive_bayes.h.

K

int LeafNode::K

Definition at line 55 of file naive_bayes.h.

---

The documentation for this class was generated from the following files:

• xmipp/libraries/classification/naive_bayes.h
• xmipp/libraries/classification/naive_bayes.cpp