gpmp::ml::LogReg Class Reference

Represents a Logistic Regression classifier. More...

#include <logreg.hpp>

Public Member Functions
	LogReg (double l_rate=001, int num_iters=1000, double lda=001)
	Constructor for the LogReg class. More...
	~LogReg ()
	Destructor for the LogReg class. More...
void	train (const std::vector< std::vector< double >> &X_train, const std::vector< int > &y_train)
	Trains the logistic regression model on the given training data. More...
std::vector< int >	classify (const std::vector< std::vector< double >> &X)
	Predicts the class labels for the given test data. More...
std::vector< double >	predict (const std::vector< std::vector< double >> &X_test)
	Computes the predicted probabilities for the given test data. More...
double	accuracy (const std::vector< std::vector< double >> &X_test, const std::vector< int > &y_test)
	Computes the accuracy of the model on the given test data. More...
void	feature_scaling (std::vector< std::vector< double >> &X)
	Performs feature scaling on the input feature matrix. More...
double	sigmoid (double z)
	Computes the sigmoid function value for the given input. More...
double	cost_function (const std::vector< std::vector< double >> &X, const std::vector< int > &y)
	Computes the cost function value for the given input data and labels. More...

Public Attributes
double	learning_rate
int	num_iterations
double	lambda
std::vector< double >	weights

Detailed Description

Represents a Logistic Regression classifier.

Definition at line 53 of file logreg.hpp.

Constructor & Destructor Documentation

LogReg()

gpmp::ml::LogReg::LogReg	(	double	l_rate = 001,
		int	num_iters = 1000,
		double	lda = 001
	)

Constructor for the LogReg class.

Parameters

l_rate	The learning rate for gradient descent optimization (default: 001)
num_iters	The number of iterations for gradient descent (default: 1000)
lda	The regularization parameter lambda (default: 001)

Definition at line 40 of file logreg.cpp.

    : learning_rate(l_rate), num_iterations(num_iters), lambda(lda) {
}

~LogReg()

gpmp::ml::LogReg::~LogReg

(

)

Destructor for the LogReg class.

Definition at line 44 of file logreg.cpp.

                      {
}

Member Function Documentation

accuracy()

double gpmp::ml::LogReg::accuracy	(	const std::vector< std::vector< double >> &	X_test,
		const std::vector< int > &	y_test
	)

Computes the accuracy of the model on the given test data.

Parameters

X_test	The feature matrix of the test data
y_test	The true labels of the test data

Returns

The accuracy of the model

Definition at line 99 of file logreg.cpp.

                                                         {
    std::vector<double> predictions = predict(X_test);
    int correct = 0;
    for (size_t i = 0; i < predictions.size(); ++i) {
        if ((predictions[i] >= 0.5 && y_test[i] == 1) ||
            (predictions[i] < 0.5 && y_test[i] == 0)) {
            correct++;
        }
    }
    return static_cast<double>(correct) / y_test.size();
}

classify()

std::vector< int > gpmp::ml::LogReg::classify

(

const std::vector< std::vector< double >> &

X

)

Predicts the class labels for the given test data.

Parameters

X_test

The feature matrix of the test data

Returns

A vector of predicted class labels

Definition at line 164 of file logreg.cpp.

                                                            {
    std::vector<int> classifications;
    for (size_t i = 0; i < X.size(); ++i) {
        // Add bias term to input
        std::vector<double> input = {1.0};
        input.insert(input.end(), X[i].begin(), X[i].end());
 
        // Compute the predicted value
        double predicted = sigmoid(std::inner_product(input.begin(),
                                                      input.end(),
                                                      weights.begin(),
                                                      0.0));
        int classification = predicted >= 0.5 ? 1 : 0;
        classifications.push_back(classification);
    }
    return classifications;
}

cost_function()

double gpmp::ml::LogReg::cost_function	(	const std::vector< std::vector< double >> &	X,
		const std::vector< int > &	y
	)

Computes the cost function value for the given input data and labels.

Parameters

X	The feature matrix of the data
y	The labels of the data

Returns

The value of the cost function

Definition at line 145 of file logreg.cpp.

                                                         {
    double cost = 0.0;
    for (size_t i = 0; i < X.size(); ++i) {
        // Add bias term to input
        std::vector<double> input = {1.0};
        input.insert(input.end(), X[i].begin(), X[i].end());
 
        double predicted = sigmoid(std::inner_product(input.begin(),
                                                      input.end(),
                                                      weights.begin(),
                                                      0.0));
        cost += -y[i] * log(predicted) - (1 - y[i]) * log(1 - predicted);
    }
    cost /= X.size();
    return cost;
}

feature_scaling()

void gpmp::ml::LogReg::feature_scaling

(

std::vector< std::vector< double >> &

X

)

Performs feature scaling on the input feature matrix.

Parameters

X	The feature matrix to be scaled

Definition at line 116 of file logreg.cpp.

                                                                  {
    if (X.empty()) {
        throw std::invalid_argument("Input feature matrix is empty.");
    }
 
    size_t num_features = X[0].size();
    for (size_t j = 0; j < num_features; ++j) {
        double min_val = X[0][j], max_val = X[0][j];
        for (size_t i = 1; i < X.size(); ++i) {
            if (X[i][j] < min_val) {
                min_val = X[i][j];
            }
            if (X[i][j] > max_val) {
                max_val = X[i][j];
            }
        }
 
        if (fabs(min_val - max_val) < std::numeric_limits<double>::epsilon()) {
            continue; // Skip if all values are the same
        }
 
        double range = max_val - min_val;
        for (size_t i = 0; i < X.size(); ++i) {
            X[i][j] = (X[i][j] - min_val) / range;
        }
    }
}

predict()

std::vector< double > gpmp::ml::LogReg::predict

(

const std::vector< std::vector< double >> &

X_test

)

Computes the predicted probabilities for the given test data.

Parameters

X_test

The feature matrix of the test data

Returns

A vector of predicted probabilities

Definition at line 81 of file logreg.cpp.

                                                                {
    std::vector<double> predictions;
    for (size_t i = 0; i < X_test.size(); ++i) {
        // Add bias term to input
        std::vector<double> input = {1.0};
        input.insert(input.end(), X_test[i].begin(), X_test[i].end());
 
        // Compute the predicted value
        double predicted = sigmoid(std::inner_product(input.begin(),
                                                      input.end(),
                                                      weights.begin(),
                                                      0.0));
        predictions.push_back(predicted);
    }
    return predictions;
}

sigmoid()

double gpmp::ml::LogReg::sigmoid

(

double

z

)

Computes the sigmoid function value for the given input.

Parameters

z	The input value

Returns

The sigmoid of z

Definition at line 112 of file logreg.cpp.

                                     {
    return 1.0 / (1.0 + exp(-z));
}

train()

void gpmp::ml::LogReg::train	(	const std::vector< std::vector< double >> &	X_train,
		const std::vector< int > &	y_train
	)

Trains the logistic regression model on the given training data.

Parameters

X_train	The feature matrix of the training data
y_train	The labels of the training data

Definition at line 47 of file logreg.cpp.

                                                            {
    // Initialize weights to zeros
    weights.assign(X_train[0].size() + 1, 0.0);
 
    for (int iter = 0; iter < num_iterations; ++iter) {
        std::vector<double> gradient(X_train[0].size() + 1, 0.0);
 
        for (size_t i = 0; i < X_train.size(); ++i) {
            // Add bias term to input
            std::vector<double> input = {1.0};
            input.insert(input.end(), X_train[i].begin(), X_train[i].end());
 
            // Compute the predicted value
            double predicted = sigmoid(std::inner_product(input.begin(),
                                                          input.end(),
                                                          weights.begin(),
                                                          0.0));
 
            // Compute gradient for each weight
            for (size_t j = 0; j < gradient.size(); ++j) {
                gradient[j] += (predicted - y_train[i]) * input[j];
            }
        }
 
        // Update weights using gradient descent
        for (size_t j = 0; j < weights.size(); ++j) {
            weights[j] -= learning_rate *
                          (gradient[j] / X_train.size() + lambda * weights[j]);
        }
    }
}

Member Data Documentation

lambda

double gpmp::ml::LogReg::lambda

The regularization parameter lambda

Definition at line 110 of file logreg.hpp.

learning_rate

double gpmp::ml::LogReg::learning_rate

The learning rate for gradient descent optimization

Definition at line 107 of file logreg.hpp.

num_iterations

int gpmp::ml::LogReg::num_iterations

The number of iterations for gradient descent

Definition at line 109 of file logreg.hpp.

weights

std::vector<double> gpmp::ml::LogReg::weights

The weights learned by the logistic regression model

Definition at line 112 of file logreg.hpp.

---

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

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