weighted_linear_regression.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <cstddef>
#include <stdexcept>
#include <utility>
#include <vector>
 
#include "pulsatrix/assert.hpp"
#include "pulsatrix/linear_algebra.hpp"
 
namespace pulsatrix {
 
[[nodiscard]] inline std::vector<float> fit_weighted_linear_regression(
    const std::vector<std::vector<float>>& samples, const std::vector<float>& targets,
    const std::vector<float>& weights, float l2_lambda) {
    if (samples.empty()) {
        throw std::invalid_argument("fit_weighted_linear_regression: samples must not be empty");
    }
    if (samples.size() != targets.size() || samples.size() != weights.size()) {
        throw std::invalid_argument(
            "fit_weighted_linear_regression: samples, targets, and weights must be the same size");
    }
 
    const auto n_features = static_cast<int64_t>(samples[0].size());
    for (const auto& row : samples) {
        if (static_cast<int64_t>(row.size()) != n_features) {
            throw std::invalid_argument("fit_weighted_linear_regression: every sample row must be the same length");
        }
    }
 
    std::vector<std::vector<float>> a(static_cast<size_t>(n_features),
                                       std::vector<float>(static_cast<size_t>(n_features), 0.0f));
    std::vector<float> b(static_cast<size_t>(n_features), 0.0f);
 
    for (size_t k = 0; k < samples.size(); ++k) {
        for (int64_t i = 0; i < n_features; ++i) {
            b[static_cast<size_t>(i)] += weights[k] * samples[k][static_cast<size_t>(i)] * targets[k];
            for (int64_t j = 0; j < n_features; ++j) {
                a[static_cast<size_t>(i)][static_cast<size_t>(j)] +=
                    weights[k] * samples[k][static_cast<size_t>(i)] * samples[k][static_cast<size_t>(j)];
            }
        }
    }
    for (int64_t i = 0; i < n_features; ++i) {
        a[static_cast<size_t>(i)][static_cast<size_t>(i)] += l2_lambda;
    }
 
    return SolveLinearSystem(std::move(a), std::move(b));
}
 
}  // namespace pulsatrix