LogisticRegression.hpp

Go to the documentation of this file.

#ifndef LOGISTIC_REGRESSION_HPP
#define LOGISTIC_REGRESSION_HPP
 
#include <vector>
#include <cmath>
#include <stdexcept>
#include <numeric>
#include <algorithm>
 
class LogisticRegression {
public:
    LogisticRegression(double learningRate = 0.01, int iterations = 1000, bool useBias = true)
        : learningRate_(learningRate), iterations_(iterations), useBias_(useBias) {}
 
    void train(const std::vector<std::vector<double>>& features, const std::vector<int>& labels) {
        if (features.empty() || labels.empty()) {
            throw std::invalid_argument("Features and labels must not be empty.");
        }
        if (features.size() != labels.size()) {
            throw std::invalid_argument("The number of feature vectors must match the number of labels.");
        }
 
        size_t numSamples = features.size();
        size_t numFeatures = features[0].size();
 
        // Validate that all feature vectors have the same size
        for (const auto& feature : features) {
            if (feature.size() != numFeatures) {
                throw std::invalid_argument("All feature vectors must have the same number of elements.");
            }
        }
 
        // Initialize weights if they haven't been initialized yet
        if (weights_.empty()) {
            weights_ = std::vector<double>(numFeatures, 0.0);
            if (useBias_) {
                bias_ = 0.0;
            }
        }
 
        for (int iter = 0; iter < iterations_; ++iter) {
            std::vector<double> gradients(numFeatures, 0.0);
            double biasGradient = 0.0;
 
            for (size_t i = 0; i < numSamples; ++i) {
                double prediction = predictProbability(features[i]);
                double error = prediction - labels[i];
 
                for (size_t j = 0; j < numFeatures; ++j) {
                    gradients[j] += error * features[i][j];
                }
 
                if (useBias_) {
                    biasGradient += error;
                }
            }
 
            // Update weights and bias
            for (size_t j = 0; j < numFeatures; ++j) {
                weights_[j] -= learningRate_ * (gradients[j] / numSamples);
            }
 
            if (useBias_) {
                bias_ -= learningRate_ * (biasGradient / numSamples);
            }
        }
    }
 
    int predict(const std::vector<double>& features) const {
        return predictProbability(features) >= 0.5 ? 1 : 0;
    }
 
    double predictProbability(const std::vector<double>& features) const {
        if (features.size() != weights_.size()) {
            throw std::invalid_argument("Feature vector size does not match the number of weights.");
        }
 
        double z = std::inner_product(features.begin(), features.end(), weights_.begin(), 0.0);
        if (useBias_) {
            z += bias_;
        }
        return sigmoid(z);
    }
 
private:
    double learningRate_;               
    int iterations_;                    
    std::vector<double> weights_;       
    double bias_ = 0.0;                 
    bool useBias_;                      
 
    double sigmoid(double z) const {
        if (z >= 0) {
            double exp_neg_z = std::exp(-z);
            return 1.0 / (1.0 + exp_neg_z);
        } else {
            double exp_z = std::exp(z);
            return exp_z / (1.0 + exp_z);
        }
    }
};
 
#endif // LOGISTIC_REGRESSION_HPP