gpmp::ml::BayesMultiNom Class Reference

#include <bayes_clf.hpp>

Public Member Functions
	BayesMultiNom (double alpha_param=1.0, bool fit_prior_param=true, const std::vector< double > &class_prior={})
	Constructor for BayesMultiNom class. More...
	~BayesMultiNom ()
	Destructor for BayesMultiNom class. More...
void	train (const std::vector< std::vector< size_t >> &data, const std::vector< std::string > &labels)
	Train the classifier with a set of labeled data. More...
std::string	predict (const std::vector< size_t > &new_data) const
	Predict the class of a new data point. More...
void	display () const
	Display the learned probabilities. More...

Public Attributes
double	alpha
	Additive smoothing parameter for the Multinomial distribution. More...
bool	fit_prior
	Flag indicating whether to learn class prior probabilities during training. More...
std::unordered_map< std::string, double >	class_probs
	Map storing the probabilities of each class. More...
std::unordered_map< std::string, std::vector< double > >	feature_probs
	Map storing the probabilities of features for each class. More...
std::vector< double >	class_log_prior
	Vector storing the logarithm of the class prior probabilities. More...

Detailed Description

Definition at line 245 of file bayes_clf.hpp.

Constructor & Destructor Documentation

BayesMultiNom()

gpmp::ml::BayesMultiNom::BayesMultiNom	(	double	alpha_param = 1.0,
		bool	fit_prior_param = true,
		const std::vector< double > &	class_prior = {}
	)

Constructor for BayesMultiNom class.

Parameters

alpha_param	Additive smoothing parameter
fit_prior_param	Whether to learn class prior probabilities or not
class_prior	Prior probabilities of the classes

Definition at line 344 of file bayes_clf.cpp.

    : alpha(alpha_param), fit_prior(fit_prior_param),
      class_log_prior(class_prior.begin(), class_prior.end()) {
}

~BayesMultiNom()

gpmp::ml::BayesMultiNom::~BayesMultiNom

(

)

Destructor for BayesMultiNom class.

Definition at line 351 of file bayes_clf.cpp.

                                    {
}

Member Function Documentation

display()

void gpmp::ml::BayesMultiNom::display

(

)

const

Display the learned probabilities.

Note

This method is for debugging purposes

Definition at line 441 of file bayes_clf.cpp.

                                        {
    std::cout << "Class Probabilities:\n";
    for (const auto &entry : class_probs) {
        std::cout << entry.first << ": " << entry.second << "\n";
    }
 
    std::cout << "\nFeature Probabilities:\n";
    for (const auto &class_entry : feature_probs) {
        std::cout << class_entry.first << ":\n";
        for (size_t j = 0; j < class_entry.second.size(); ++j) {
            std::cout << "  Feature " << j << ": " << class_entry.second[j]
                      << "\n";
        }
    }
 
    std::cout << "\nClass Log Priors:\n";
    for (const auto &log_prior : class_log_prior) {
        std::cout << log_prior << "\n";
    }
}

predict()

std::string gpmp::ml::BayesMultiNom::predict

(

const std::vector< size_t > &

new_data

)

const

Predict the class of a new data point.

Parameters

new_data

A vector of size_t representing the features of the new data point

Returns

The predicted class label as a string

Definition at line 420 of file bayes_clf.cpp.

                                                                    {
    double max_prob = -std::numeric_limits<double>::infinity();
    std::string predicted_class;
 
    for (const auto &entry : class_probs) {
        const std::string &label = entry.first;
        double probability = log(entry.second);
 
        for (size_t j = 0; j < new_data.size(); ++j) {
            probability += new_data[j] * log(feature_probs.at(label).at(j));
        }
 
        if (probability > max_prob) {
            max_prob = probability;
            predicted_class = label;
        }
    }
 
    return predicted_class;
}

train()

void gpmp::ml::BayesMultiNom::train	(	const std::vector< std::vector< size_t >> &	data,
		const std::vector< std::string > &	labels
	)

Train the classifier with a set of labeled data.

Parameters

data	A vector of vectors representing the training instances
labels	A vector of strings representing the corresponding class labels

Definition at line 354 of file bayes_clf.cpp.

                                        {
    size_t num_instances = data.size();
    size_t num_features = data[0].size();
 
    // count class occurrences
    for (const auto &label : labels) {
        class_probs[label] += 1.0;
    }
 
    // count feature occurrences for each class
    for (size_t i = 0; i < num_instances; ++i) {
        const std::string &label = labels[i];
        const std::vector<size_t> &features = data[i];
 
        class_probs[label] += 1.0;
 
        // Initialize feature_probs[label] if not present
        if (feature_probs.find(label) == feature_probs.end()) {
            feature_probs[label] = std::vector<double>(num_features, 0.0);
        }
 
        for (size_t j = 0; j < num_features; ++j) {
            feature_probs[label][j] += features[j];
        }
    }
 
    // calculate class probabilities and feature probabilities
    double smoothing_factor = alpha * num_features;
    for (const auto &entry : class_probs) {
        const std::string &label = entry.first;
        double class_count = entry.second;
 
        // calculate class probability
        class_probs[label] =
            (class_count + alpha) / (num_instances + smoothing_factor);
 
        // calculate feature probabilities
        for (size_t j = 0; j < feature_probs[label].size(); ++j) {
            feature_probs[label][j] = (feature_probs[label][j] + alpha) /
                                      (class_count + smoothing_factor);
        }
    }
 
    // calculate class log priors
    if (fit_prior) {
        double total = std::accumulate(
            class_probs.begin(),
            class_probs.end(),
            0.0,
            [](double sum, const auto &entry) { return sum + entry.second; });
 
        for (auto &entry : class_probs) {
            entry.second /= total;
        }
 
        std::transform(
            class_probs.begin(),
            class_probs.end(),
            class_log_prior.begin(),
            [total](const auto &entry) { return log(entry.second); });
    }
}

Referenced by main().

Member Data Documentation

alpha

gpmp::ml::BayesMultiNom::alpha

Additive smoothing parameter for the Multinomial distribution.

Definition at line 251 of file bayes_clf.hpp.

class_log_prior

gpmp::ml::BayesMultiNom::class_log_prior

Vector storing the logarithm of the class prior probabilities.

Used for faster computation during prediction

Definition at line 277 of file bayes_clf.hpp.

class_probs

gpmp::ml::BayesMultiNom::class_probs

Map storing the probabilities of each class.

The key is the class label (string), and the value is the probability (double).

Definition at line 264 of file bayes_clf.hpp.

feature_probs

gpmp::ml::BayesMultiNom::feature_probs

Map storing the probabilities of features for each class.

The key is the class label (string), and the value is a vector of feature probabilities.

Definition at line 271 of file bayes_clf.hpp.

fit_prior

gpmp::ml::BayesMultiNom::fit_prior

Flag indicating whether to learn class prior probabilities during training.

Definition at line 257 of file bayes_clf.hpp.

---

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

• include/openGPMP/ml/bayes_clf.hpp
• modules/ml/bayes_clf.cpp