MultiLinearRegression.hpp

Go to the documentation of this file.

#ifndef MULTILINEAR_REGRESSION_HPP
#define MULTILINEAR_REGRESSION_HPP
 
#include <vector>
#include <stdexcept>
#include <numeric>
#include <cmath>
 
class MultilinearRegression {
public:
    MultilinearRegression(double learningRate = 0.01, int iterations = 1000, double regularizationParameter = 0.0)
        : learningRate_(learningRate), iterations_(iterations), lambda_(regularizationParameter) {}
 
    void train(const std::vector<std::vector<double>>& features, const std::vector<double>& target) {
        if (features.empty() || features.size() != target.size()) {
            throw std::invalid_argument("Features and target data sizes do not match.");
        }
 
        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 and bias if they haven't been initialized yet
        if (weights_.empty()) {
            weights_.resize(numFeatures, 0.0);
            bias_ = 0.0;
        }
 
        for (int iter = 0; iter < iterations_; ++iter) {
            gradientDescentStep(features, target);
        }
    }
 
    double predict(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 result = std::inner_product(weights_.begin(), weights_.end(), features.begin(), 0.0);
        result += bias_;
        return result;
    }
 
    std::vector<double> getWeights() const {
        return weights_;
    }
 
    double getBias() const {
        return bias_;
    }
 
private:
    double learningRate_;            
    int iterations_;                 
    double lambda_;                  
    std::vector<double> weights_;    
    double bias_ = 0.0;              
 
    void gradientDescentStep(const std::vector<std::vector<double>>& features, const std::vector<double>& target) {
        size_t numSamples = features.size();
        size_t numFeatures = weights_.size();
 
        std::vector<double> gradients(numFeatures, 0.0);
        double biasGradient = 0.0;
 
        for (size_t i = 0; i < numSamples; ++i) {
            double prediction = predict(features[i]);
            double error = prediction - target[i];
 
            for (size_t j = 0; j < numFeatures; ++j) {
                gradients[j] += (error * features[i][j]) + (lambda_ * weights_[j]);
            }
 
            biasGradient += error;
        }
 
        // Update weights and bias
        for (size_t j = 0; j < numFeatures; ++j) {
            weights_[j] -= (learningRate_ / numSamples) * gradients[j];
        }
 
        bias_ -= (learningRate_ / numSamples) * biasGradient;
    }
};
 
#endif // MULTILINEAR_REGRESSION_HPP