#include <naive_bayes.h>

Public Member Functions
	EnsembleNaiveBayes (const std::vector< MultidimArray< double > > &features, const Matrix1D< double > &priorProbs, int discreteLevels, int numberOfClassifiers, double samplingFeatures, double samplingIndividuals, const std::string &newJudgeCombination)
	Constructor. More...

	~EnsembleNaiveBayes ()
	Destructor. More...

	EnsembleNaiveBayes (const EnsembleNaiveBayes &other)
	Copy constructor. More...

EnsembleNaiveBayes &	operator= (const EnsembleNaiveBayes &other)
	Assignment. More...

void	setCostMatrix (const Matrix2D< double > &cost)
	Set cost matrix. More...

int	doInference (const Matrix1D< double > &newFeatures, double &cost, MultidimArray< int > &votes, Matrix1D< double > &classesProbs, Matrix1D< double > &allCosts)
	Returns the class with the largest probability given a set of features. More...

Public Attributes
std::vector< NaiveBayes *>	ensemble
	Ensemble of classifiers. More...

std::vector< MultidimArray< int > >	ensembleFeatures
	Ensemble of features for each classifier. More...

int	K
	Number of classes. More...

std::string	judgeCombination
	Judge combination. More...

Detailed Description

Ensemble NaiveBayes classifier.

Definition at line 127 of file naive_bayes.h.

Constructor & Destructor Documentation

◆ EnsembleNaiveBayes() [1/2]

EnsembleNaiveBayes::EnsembleNaiveBayes	(	const std::vector< MultidimArray< double > > &	features,
		const Matrix1D< double > &	priorProbs,
		int	discreteLevels,
		int	numberOfClassifiers,
		double	samplingFeatures,
		double	samplingIndividuals,
		const std::string &	newJudgeCombination
	)

Constructor.

Definition at line 431 of file naive_bayes.cpp.

 {
     int NFeatures=XSIZE(features[0]);
     int NsubFeatures=CEIL(NFeatures*samplingFeatures);
     K=features.size();
     judgeCombination=newJudgeCombination;
 
 #ifdef WEIGHTED_SAMPLING
     // Measure the classification power of each variable
     auto *nb_weights=new NaiveBayes(features, priorProbs, discreteLevels);
     MultidimArray<double> weights=nb_weights->__weights;
     delete nb_weights;
     double sumWeights=weights.sum();
 #endif
 
     for (int n=0; n<numberOfClassifiers; n++)
     {
         // Produce the set of features for this subclassifier
         MultidimArray<int> subFeatures(NsubFeatures);
         FOR_ALL_ELEMENTS_IN_ARRAY1D(subFeatures)
         {
 #ifdef WEIGHTED_SAMPLING
             double random_sum_weight=rnd_unif(0,sumWeights);
             int j=0;
             do
             {
                 double wj=DIRECT_A1D_ELEM(weights,j);
                 if (wj<random_sum_weight)
                 {
                     random_sum_weight-=wj;
                     j++;
                     if (j==NFeatures)
                     {
                         j=NFeatures-1;
                         break;
                     }
                 }
                 else
                     break;
             }
             while (true);
             DIRECT_A1D_ELEM(subFeatures,i)=j;
 #else
 
             DIRECT_A1D_ELEM(subFeatures,i)=round(rnd_unif(0,NFeatures-1));
 #endif
 
         }
 
         // Container for the new training sample
         std::vector< MultidimArray<double> >  newFeatures;
 
         // Produce the data set for each class
         for (int k=0; k<K; k++)
         {
             int NIndividuals=YSIZE(features[k]);
             int NsubIndividuals=CEIL(NIndividuals*samplingIndividuals);
             MultidimArray<int> subIndividuals(NsubIndividuals);
             FOR_ALL_ELEMENTS_IN_ARRAY1D(subIndividuals)
             subIndividuals(i)=ROUND(rnd_unif(0,NsubIndividuals-1));
 
             MultidimArray<double> newFeaturesK;
             newFeaturesK.initZeros(NsubIndividuals,NsubFeatures);
             const MultidimArray<double>& features_k=features[k];
             FOR_ALL_ELEMENTS_IN_ARRAY2D(newFeaturesK)
             DIRECT_A2D_ELEM(newFeaturesK,i,j)=DIRECT_A2D_ELEM(features_k,
                                               DIRECT_A1D_ELEM(subIndividuals,i),
                                               DIRECT_A1D_ELEM(subFeatures,j));
 
             newFeatures.push_back(newFeaturesK);
         }
 
         // Create a Naive Bayes classifier with this data
         auto *nb=new NaiveBayes(newFeatures, priorProbs, discreteLevels);
         ensemble.push_back(nb);
         ensembleFeatures.push_back(subFeatures);
     }
 }

◆ ~EnsembleNaiveBayes()

EnsembleNaiveBayes::~EnsembleNaiveBayes ( )

Destructor.

Definition at line 516 of file naive_bayes.cpp.

 {
     int nmax=ensemble.size();
     for (int n=0; n<nmax; n++)
         delete ensemble[n];
 }

◆ EnsembleNaiveBayes() [2/2]

EnsembleNaiveBayes::EnsembleNaiveBayes ( const EnsembleNaiveBayes & other )

inline

Copy constructor.

Definition at line 154 of file naive_bayes.h.

     {
         *this=other;
     }

Member Function Documentation

◆ doInference()

int EnsembleNaiveBayes::doInference	(	const Matrix1D< double > &	newFeatures,
		double &	cost,
		MultidimArray< int > &	votes,
		Matrix1D< double > &	classesProbs,
		Matrix1D< double > &	allCosts
	)

Returns the class with the largest probability given a set of features.

Definition at line 550 of file naive_bayes.cpp.

 {
     int nmax=ensemble.size();
     MultidimArray<double> minCost;
     MultidimArray<double> maxCost;
     votes.initZeros(K);
     minCost.initZeros(K);
     minCost.initConstant(1);
     maxCost.initZeros(K);
     maxCost.initConstant(1);
     double bestMinCost=0;
     int bestClass=0;
     MultidimArray<double> newFeaturesn;
     for (int n=0; n<nmax; n++)
     {
         double costn;
         newFeaturesn.initZeros(XSIZE(ensembleFeatures[n]));
         FOR_ALL_ELEMENTS_IN_ARRAY1D(newFeaturesn)
         newFeaturesn(i)=newFeatures(ensembleFeatures[n](i));
         int k=ensemble[n]->doInference(newFeaturesn, costn, classesProbs, allCosts);
         votes(k)++;
         if (minCost(k)>0 || minCost(k)>costn)
             minCost(k)=costn;
         if (maxCost(k)>0 || maxCost(k)<costn)
             maxCost(k)=costn;
         if (minCost(k)<bestMinCost)
         {
             bestMinCost=minCost(k);
             bestClass=k;
         }
     }
     if      (judgeCombination[bestClass]=='m')
         cost=minCost(bestClass);
     else if (judgeCombination[bestClass]=='M')
         cost=maxCost(bestClass);
     else
         cost=minCost(bestClass);
     return bestClass;
 }

◆ operator=()

EnsembleNaiveBayes & EnsembleNaiveBayes::operator= ( const EnsembleNaiveBayes & other )

Assignment.

Definition at line 524 of file naive_bayes.cpp.

 {
     size_t imax=ensemble.size();
     for (size_t i=0; i<imax; ++i)
         delete ensemble[i];
     ensemble.clear();
     imax=other.ensemble.size();
     for (size_t i=0; i<imax; ++i)
         ensemble.emplace_back(new NaiveBayes(*(other.ensemble[i])));
 
     ensembleFeatures=other.ensembleFeatures;
     K=other.K;
     judgeCombination=other.judgeCombination;
     return *this;
 }

◆ setCostMatrix()

void EnsembleNaiveBayes::setCostMatrix ( const Matrix2D< double > & cost )

Set cost matrix.

Definition at line 542 of file naive_bayes.cpp.

 {
     int nmax=ensemble.size();
     for (int n=0; n<nmax; n++)
         ensemble[n]->setCostMatrix(cost);
 }

Member Data Documentation

◆ ensemble

std::vector< NaiveBayes * > EnsembleNaiveBayes::ensemble

Ensemble of classifiers.

Definition at line 131 of file naive_bayes.h.

◆ ensembleFeatures

std::vector< MultidimArray<int> > EnsembleNaiveBayes::ensembleFeatures

Ensemble of features for each classifier.

Definition at line 134 of file naive_bayes.h.

◆ judgeCombination

std::string EnsembleNaiveBayes::judgeCombination

Judge combination.

Definition at line 140 of file naive_bayes.h.

◆ K

int EnsembleNaiveBayes::K

Number of classes.

Definition at line 137 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

Public Member Functions

Public Attributes