gpmp::ml::LinearRegression Class Reference

#include <linreg.hpp>

Public Member Functions
	LinearRegression ()
	Constructor for LinearRegression. More...
void	calculate_coeffecient ()
	Calculates the coefficient/slope of the best fitting line. More...
void	calculate_constant ()
	Calculate the constant term of the best fitting line. More...
int64_t	data_size ()
	Get the number of entries (xi, yi) in the data set. More...
long double	return_coeffecient ()
	Get the coefficient/slope of the best fitting line. More...
long double	return_constant ()
	Get the constant term of the best fitting line. More...
void	best_fit ()
	Calculates and displays the best fitting line based on training data. More...
void	get_input (const std::vector< long double > &x_data, const std::vector< long double > &y_data)
	Sets the input data for the LinearRegression class from two vectors. More...
void	get_input (const gpmp::core::DataTableStr &data, const std::vector< std::string > &columns)
	Takes input data in the form of a DataTable and prepares it for regression analysis. More...
void	get_input (const char *file)
	Takes input data from a file and prepares it for regression analysis. More...
void	split_data (double test_size, unsigned int seed, bool shuffle)
	Splits the data into training and testing sets. More...
void	show_data ()
	Display the data set. More...
long double	predict (long double _x) const
	Predict a value based on the input. More...
long double	predict (long double _x, const std::vector< long double > &x_data)
	Predict a value based on the input. More...
long double	error_in (long double num)
	Calculates the error (residual) for a given independent variable value. More...
long double	error_in (long double num, const std::vector< long double > &x_data, const std::vector< long double > &y_data)
	Calculates the error (residual) for a given independent variable value using a dataset. More...
long double	error_square ()
	Calculates the sum of squared errors for the entire dataset. More...
long double	mse (const std::vector< long double > &x_data, const std::vector< long double > &y_data) const
	Calculates the Mean Squared Error (MSE) for a dataset. More...
long double	r_sqrd (const std::vector< long double > &x_data, const std::vector< long double > &y_data) const
	Calculate the coefficient of determination (R-squared). More...
int64_t	num_rows (const char *input)
	Calculate the number of rows in a file. More...

Public Attributes
std::vector< long double >	x
std::vector< long double >	y
long double	coeff
long double	constant
long double	sum_xy
long double	sum_x
long double	sum_y
long double	sum_x_square
long double	sum_y_square
std::vector< long double >	x_train
std::vector< long double >	y_train
std::vector< long double >	x_test
std::vector< long double >	y_test

Detailed Description

Examples

linreg.cpp.

Definition at line 53 of file linreg.hpp.

Constructor & Destructor Documentation

LinearRegression()

gpmp::ml::LinearRegression::LinearRegression

(

)

Constructor for LinearRegression.

Definition at line 54 of file linreg.cpp.

                                         {
    coeff = 0;
    constant = 0;
    sum_y = 0;
    sum_y_square = 0;
    sum_x_square = 0;
    sum_x = 0;
    sum_xy = 0;
}

References coeff, constant, sum_x, sum_x_square, sum_xy, sum_y, and sum_y_square.

Member Function Documentation

best_fit()

void gpmp::ml::LinearRegression::best_fit

(

)

Calculates and displays the best fitting line based on training data.

This function calculates the best fitting line using the training data and displays the result. If training data is empty, it will also handle the case when the coefficients and constants are not calculated.

Examples

linreg.cpp.

Definition at line 110 of file linreg.cpp.

                                      {
    if (x_train.empty() || y_train.empty()) {
        // Check if training data is empty
        _log_.log(WARNING, "Training data is empty.");
 
        if (fabs(coeff - 0.0f) < std::numeric_limits<double>::epsilon() &&
            fabs(constant - 0.0f) < std::numeric_limits<double>::epsilon()) {
            // If coefficients are not calculated, calculate them
            calculate_coeffecient();
            calculate_constant();
        }
        // Display the best fitting line equation
        _log_.log(INFO,
                  "Best fitting line : y = " + std::to_string(coeff) + "x + " +
                      std::to_string(constant));
        return;
    }
 
    // Calculate the coefficients using the training data
    long double N = x_train.size();
    long double sum_xy_train = 0;
    long double sum_x_train = 0;
    long double sum_y_train = 0;
    long double sum_x_square_train = 0;
 
    for (size_t i = 0; i < N; i++) {
        // Calculate sums for the training data
        sum_xy_train += x_train[i] * y_train[i];
        sum_x_train += x_train[i];
        sum_y_train += y_train[i];
        sum_x_square_train += x_train[i] * x_train[i];
    }
 
    long double numerator = (N * sum_xy_train - sum_x_train * sum_y_train);
    long double denominator =
        (N * sum_x_square_train - sum_x_train * sum_x_train);
 
    // Calculate the coefficients of the best fitting line
    coeff = numerator / denominator;
    constant = (sum_y_train - coeff * sum_x_train) / N;
    // Display the best fitting line equation
    _log_.log(INFO,
              "Best fitting line : y = " + std::to_string(coeff) + "x + " +
                  std::to_string(constant));
}

References _log_, INFO, gpmp::core::Logger::log(), N, and WARNING.

Referenced by main(), and test_train().

calculate_coeffecient()

void gpmp::ml::LinearRegression::calculate_coeffecient

(

)

Calculates the coefficient/slope of the best fitting line.

This function calculates the coefficient of the linear regression model by analyzing the dataset.

Definition at line 66 of file linreg.cpp.

                                                   {
    // get number of datapoints
    long double N = x.size();
    // calculate numerator and denominator
    long double numerator = (N * sum_xy - sum_x * sum_y);
    long double denominator = (N * sum_x_square - sum_x * sum_x);
    // calculate the coeffecient
    coeff = numerator / denominator;
}

References N.

calculate_constant()

void gpmp::ml::LinearRegression::calculate_constant

(

)

Calculate the constant term of the best fitting line.

Definition at line 80 of file linreg.cpp.

                                                {
    long double N = x.size();
    long double numerator = (sum_y * sum_x_square - sum_x * sum_xy);
    long double denominator = (N * sum_x_square - sum_x * sum_x);
    // calculate constant
    constant = numerator / denominator;
}

References N.

data_size()

int64_t gpmp::ml::LinearRegression::data_size

(

)

Get the number of entries (xi, yi) in the data set.

Returns

Number of data entries.

Definition at line 89 of file linreg.cpp.

                                          {
    return x.size();
}

error_in() [1/2]

long double gpmp::ml::LinearRegression::error_in

(

long double

num

)

Calculates the error (residual) for a given independent variable value.

This function computes the difference between the actual dependent variable value (y) and the predicted value based on the linear regression model for a specified independent variable (x).

Parameters

num	The independent variable value for which the error is calculated.

Returns

The error (residual) between the actual and predicted values.

Examples

linreg.cpp.

Definition at line 373 of file linreg.cpp.

                                                            {
    for (int64_t i = 0; uint64_t(i) < x.size(); i++) {
        if (fabs(num - x[i]) < std::numeric_limits<double>::epsilon()) {
            return (y[i] - predict(x[i]));
        }
    }
    return 0;
}

Referenced by main(), and test_train().

error_in() [2/2]

long double gpmp::ml::LinearRegression::error_in	(	long double	num,
		const std::vector< long double > &	x_data,
		const std::vector< long double > &	y_data
	)

Calculates the error (residual) for a given independent variable value using a dataset.

This function computes the difference between the actual dependent variable value (y) and the predicted value based on the linear regression model for a specified independent variable (x).

Parameters

num	The independent variable value for which the error is calculated.
x_data	The vector of independent variable values.
y_data	The vector of actual dependent variable values.

Returns

The error (residual) between the actual and predicted values.

Definition at line 384 of file linreg.cpp.

                                                                           {
    long double prediction = predict(num, x_data);
    // Find the corresponding y value for the input x
    for (size_t i = 0; i < x_data.size(); i++) {
        if (fabs(num - x_data[i]) < std::numeric_limits<double>::epsilon()) {
            return y_data[i] - prediction;
        }
    }
    return 0;
}

error_square()

long double gpmp::ml::LinearRegression::error_square

(

)

Calculates the sum of squared errors for the entire dataset.

This function computes the sum of squared differences between the actual dependent variable values (y) and the predicted values based on the linear regression model for all data points.

Returns

The sum of squared errors for the dataset.

Definition at line 398 of file linreg.cpp.

                                                 {
    long double ans = 0;
 
    // Iterate through each data point
    for (int64_t i = 0; uint64_t(i) < x.size(); i++) {
        // Calculate the square of the error (difference between predicted and
        // actual values)
        ans += ((predict(x[i]) - y[i]) * (predict(x[i]) - y[i]));
    }
    return ans; // Return the sum of squared errors
}

get_input() [1/3]

void gpmp::ml::LinearRegression::get_input

(

const char *

file

)

Takes input data from a file and prepares it for regression analysis.

Parameters

file	The name of the file containing the data.

Definition at line 253 of file linreg.cpp.

                                                       {
    int n = num_rows(file);
    for (int64_t i = 0; i < n; i++) {
        /*
         * In a csv file, all the values of xi and yi are separated by
         * commas
         */
        char comma;
        long double xi;
        long double yi;
        std::cin >> xi >> comma >> yi;
        // Update sum of (x * y)
        sum_xy += xi * yi;
        // Update sum of x and y
        sum_x += xi;
        sum_y += yi;
        // Update sum of x squares and y squares
        sum_x_square += xi * xi;
        sum_y_square += yi * yi;
        // Append x and y values to x and y vectors
        x.push_back(xi);
        y.push_back(yi);
    }
}

get_input() [2/3]

void gpmp::ml::LinearRegression::get_input	(	const gpmp::core::DataTableStr &	data,
		const std::vector< std::string > &	columns
	)

Takes input data in the form of a DataTable and prepares it for regression analysis.

Parameters

data	The DataTable containing the data.
columns	The column names for the independent and dependent variables.

Definition at line 192 of file linreg.cpp.

                                         {
    // Clear any existing data from x and y vectors
    x.clear();
    y.clear();
    sum_xy = 0;
    sum_x = 0;
    sum_y = 0;
    sum_x_square = 0;
    sum_y_square = 0;
 
    // Ensure that columns is not empty and has at least 2 elements
    if (columns.size() < 2) {
        _log_.log(ERROR, "Input vectors must have at least 2 column names.");
        return;
    }
 
    // Find the column indices for the specified column names
    std::vector<size_t> column_indices;
    for (const auto &column_name : columns) {
        bool found = false;
        for (size_t i = 0; i < data.first.size(); ++i) {
            if (data.first[i] == column_name) {
                column_indices.push_back(i);
                found = true;
                break;
            }
        }
        if (!found) {
            _log_.log(ERROR,
                      "Column '" + column_name +
                          "' not found in DataTableStr.");
            return;
        }
    }
 
    for (const auto &row : data.second) {
        try {
            long double xi = std::stold(row[column_indices[0]]);
            long double yi = std::stold(row[column_indices[1]]);
            // Append x and y values to x and y vectors
            x.push_back(xi);
            y.push_back(yi);
            // Update sum of (x * y)
            sum_xy += xi * yi;
            // Update sum of x and y
            sum_x += xi;
            sum_y += yi;
            // Update sum of x squares and y squares
            sum_x_square += xi * xi;
            sum_y_square += yi * yi;
        } catch (const std::exception &e) {
            // Handle parsing errors here
            _log_.log(ERROR, "Error parsing data: " + std::string(e.what()));
            continue;
        }
    }
}

References _log_, ERROR, and gpmp::core::Logger::log().

get_input() [3/3]

void gpmp::ml::LinearRegression::get_input	(	const std::vector< long double > &	x_data,
		const std::vector< long double > &	y_data
	)

Sets the input data for the LinearRegression class from two vectors.

This function accepts vectors of independent and dependent variable values and initializes the class variables.

Parameters

x_data	The vector of independent variable values.
y_data	The vector of dependent variable values.

Examples

linreg.cpp.

Definition at line 157 of file linreg.cpp.

                                          {
    // Clear existing data from x and y vectors
    x.clear();
    y.clear();
    // Initialize LinearRegression class variables
    sum_xy = 0;       /* Set x*y sum */
    sum_x = 0;        /* Set sum of x */
    sum_y = 0;        /* Set sum of y */
    sum_x_square = 0; /* Set sum of x squares */
    sum_y_square = 0; /* Set sum of y squares */
 
    if (x_data.size() != y_data.size()) {
        // Check if input vectors have the same size
        _log_.log(ERROR, "Input vectors must have the same size");
        return;
    }
 
    for (size_t i = 0; i < x_data.size(); i++) {
        // Append x and y values to x and y vectors
        x.push_back(x_data[i]);
        y.push_back(y_data[i]);
        // Update sum of (x * y)
        sum_xy += x_data[i] * y_data[i];
        // Update sum of x and y
        sum_x += x_data[i];
        sum_y += y_data[i];
        // Update sum of x squares and y squares
        sum_x_square += x_data[i] * x_data[i];
        sum_y_square += y_data[i] * y_data[i];
    }
}

References _log_, ERROR, and gpmp::core::Logger::log().

Referenced by main(), and test_train().

mse()

long double gpmp::ml::LinearRegression::mse	(	const std::vector< long double > &	x_data,
		const std::vector< long double > &	y_data
	)		const

Calculates the Mean Squared Error (MSE) for a dataset.

The Mean Squared Error is a measure of the average squared differences between the actual dependent variable values and the predicted values based on the linear regression model.

Parameters

x_data	The vector of independent variable values.
y_data	The vector of actual dependent variable values.

Returns

The Mean Squared Error for the dataset. Returns -1 if input vectors have different sizes.

Examples

linreg.cpp.

Definition at line 412 of file linreg.cpp.

                                                                            {
    // Check if input vectors have the same size
    if (x_data.size() != y_data.size()) {
        return -1; // Return an error value
    }
 
    long double mse = 0.0;
    int64_t n = x_data.size();
 
    // Iterate through each data point
    for (int64_t i = 0; i < n; i++) {
        // Calculate the predicted value using the linear regression model
        long double predicted = predict(x_data[i]);
        // Calculate the error (difference between predicted and actual values)
        long double error = predicted - y_data[i];
        // Accumulate the squared error
        mse += error * error;
    }
 
    // Calculate the Mean Squared Error by dividing the accumulated squared
    // error by the number of data points
    return mse / static_cast<long double>(n);
}

Referenced by test_train().

num_rows()

int64_t gpmp::ml::LinearRegression::num_rows

(

const char *

input

)

Calculate the number of rows in a file.

Parameters

input

Path to the input file.

Returns

Number of rows in the file.

Definition at line 474 of file linreg.cpp.

                                                          {
    int64_t num = 0;
    std::string row;
 
    // create input file stream
    std::ifstream file(input);
 
    while (getline(file, row)) {
        num++;
    }
 
    return num;
}

predict() [1/2]

long double gpmp::ml::LinearRegression::predict

(

long double

_x

)

const

Predict a value based on the input.

Parameters

x	Input value.

Returns

Predicted value.

Examples

linreg.cpp.

Definition at line 356 of file linreg.cpp.

                                                                {
    return coeff * _x + constant;
}

Referenced by main(), and test_train().

predict() [2/2]

long double gpmp::ml::LinearRegression::predict	(	long double	_x,
		const std::vector< long double > &	x_data
	)

Predict a value based on the input.

Parameters

x	Input value.
x_data	X value data.

Returns

Predicted value.

Definition at line 362 of file linreg.cpp.

                                                                          {
    // Calculate the coefficient if not already calculated
    long double _coeff = return_coeffecient();
    // Calculate the constant if not already calculated
    long double _constant = return_constant();
    // TODO FIXME unused variable
    return _coeff * _x + _constant + x_data[0];
}

r_sqrd()

long double gpmp::ml::LinearRegression::r_sqrd	(	const std::vector< long double > &	x_data,
		const std::vector< long double > &	y_data
	)		const

Calculate the coefficient of determination (R-squared).

The coefficient of determination, often referred to as R-squared, is a statistical measure that represents the proportion of the variance in the dependent variable (Y) that is predictable from the independent variable (X). It quantifies the goodness of fit of the linear regression model to the data.

This function calculates the R-squared value for a linear regression model using the provided dataset of independent variable values (x_data) and dependent variable values (y_data).

Parameters

x_data	A vector of independent variable values.
y_data	A vector of corresponding dependent variable values.

Returns

The R-squared value, which is a number between 0 and 1. A higher R-squared value indicates a better fit of the model to the data.

Note

The input vectors (x_data and y_data) must have the same size.

An R-squared value of -1 is returned as an error indicator when the input vectors have different sizes.

The function uses the linear regression model's predict() method to make predictions for the independent variable values.

Examples

linreg.cpp.

Definition at line 438 of file linreg.cpp.

                                                {
    // Check if input vectors have the same size
    if (x_data.size() != y_data.size()) {
        _log_.log(ERROR, "Input vectors must have the same size.");
        return -1; // Return an error value
    }
 
    long double total_sum_of_squares = 0.0;
    long double sum_of_squared_errors = 0.0;
    int64_t n = x_data.size();
 
    long double y_mean = 0.0;
    for (int64_t i = 0; i < n; i++) {
        // Calculate the mean of the dependent variable (Y)
        y_mean += y_data[i];
    }
    y_mean /= static_cast<long double>(n);
 
    // Iterate through each data point
    for (int64_t i = 0; i < n; i++) {
        // Calculate the predicted value using the linear regression model
        long double predicted = predict(x_data[i]);
        // Calculate the error (difference between predicted and actual values)
        long double error = predicted - y_data[i];
        // Calculate the total sum of squares and sum of squared errors
        total_sum_of_squares += (y_data[i] - y_mean) * (y_data[i] - y_mean);
        sum_of_squared_errors += error * error;
    }
 
    // Calculate the R-squared value using the formula 1 - (SSE / SST)
    return 1.0 - (sum_of_squared_errors / total_sum_of_squares);
}

References _log_, ERROR, and gpmp::core::Logger::log().

Referenced by test_train().

return_coeffecient()

long double gpmp::ml::LinearRegression::return_coeffecient

(

)

Get the coefficient/slope of the best fitting line.

Returns

Coefficient/slope.

Definition at line 94 of file linreg.cpp.

                                                       {
    if (fabs(coeff - 0.0f) < std::numeric_limits<double>::epsilon()) {
        calculate_coeffecient();
    }
    return coeff;
}

return_constant()

long double gpmp::ml::LinearRegression::return_constant

(

)

Get the constant term of the best fitting line.

Returns

Constant term.

Definition at line 102 of file linreg.cpp.

                                                    {
    if (fabs(constant - 0.0f) < std::numeric_limits<double>::epsilon()) {
        calculate_constant();
    }
    return constant;
}

show_data()

void gpmp::ml::LinearRegression::show_data

(

)

Display the data set.

Definition at line 337 of file linreg.cpp.

                                       {
    for (int64_t i = 0; i < 62; i++) {
        printf("_");
    }
    printf("\n\n");
    printf("|%15s%5s %15s%5s%20s\n", "X", "", "Y", "", "|");
 
    // Display each data point in the dataset
    for (int64_t i = 0; uint64_t(i) < x.size(); i++) {
        printf("|%20Lf %20Lf%20s\n", x[i], y[i], "|");
    }
 
    for (int64_t i = 0; i < 62; i++) {
        printf("_");
    }
    printf("\n");
}

split_data()

void gpmp::ml::LinearRegression::split_data	(	double	test_size,
		unsigned int	seed,
		bool	shuffle
	)

Splits the data into training and testing sets.

This function splits the dataset into training and testing sets based on the specified test size and random seed.

Parameters

test_size	The proportion of data to be used for testing (between 0 and 1).
seed	The random seed for shuffling the data.

Examples

linreg.cpp.

Definition at line 279 of file linreg.cpp.

                                                          {
    if (x.empty() || y.empty()) {
        _log_.log(ERROR, "Training data is empty.");
        return;
    }
 
    if (test_size <= 0 || test_size >= 1) {
        _log_.log(ERROR, "Invalid `test_size`. Must be between 0 - 1.");
        return;
    }
 
    size_t data_size = x.size();
    size_t test_data_size = static_cast<size_t>(test_size * data_size);
 
    // Shuffle the data randomly if specified
    if (shuffle == true) {
        // Create vector of indices
        std::vector<size_t> indices(data_size);
        // Fill vector sequentially w/ `iota`
        std::iota(indices.begin(), indices.end(), 0);
        // Randomly shuffle vector indices from start to end
        std::shuffle(indices.begin(),
                     indices.end(),
                     std::default_random_engine(seed));
 
        // Clear training and testing data vectors
        x_train.clear();
        y_train.clear();
        x_test.clear();
        y_test.clear();
 
        // Split the data into training and testing sets based on shuffled
        // indices
        for (size_t i = 0; i < data_size; ++i) {
            if (i < test_data_size) {
                // Append x test vector with shuffled x value
                x_test.push_back(x[indices[i]]);
                y_test.push_back(y[indices[i]]);
            } else {
                // Append x training vector with suffled x value
                x_train.push_back(x[indices[i]]);
                y_train.push_back(y[indices[i]]);
            }
        }
    } else {
        // Without shuffling, split the data without changing its order by
        // assigning the first training element to the training set
        x_train.assign(x.begin(), x.begin() + data_size - test_data_size);
        y_train.assign(y.begin(), y.begin() + data_size - test_data_size);
        // Assign the 1+ testing elements to the testing test
        x_test.assign(x.begin() + data_size - test_data_size, x.end());
        y_test.assign(y.begin() + data_size - test_data_size, y.end());
    }
}

References _log_, ERROR, and gpmp::core::Logger::log().

Referenced by test_train().

Member Data Documentation

coeff

long double gpmp::ml::LinearRegression::coeff

Store the coefficient/slope in the best fitting line

Definition at line 60 of file linreg.hpp.

Referenced by LinearRegression().

constant

long double gpmp::ml::LinearRegression::constant

Store the constant term in the best fitting line

Definition at line 62 of file linreg.hpp.

Referenced by LinearRegression().

sum_x

long double gpmp::ml::LinearRegression::sum_x

Contains sum of all (i-th x)

Definition at line 66 of file linreg.hpp.

Referenced by LinearRegression().

sum_x_square

long double gpmp::ml::LinearRegression::sum_x_square

Contains sum of square of all (i-th x)

Definition at line 70 of file linreg.hpp.

Referenced by LinearRegression().

sum_xy

long double gpmp::ml::LinearRegression::sum_xy

Contains sum of product of all (i-th x) and (i-th y)

Definition at line 64 of file linreg.hpp.

Referenced by LinearRegression().

sum_y

long double gpmp::ml::LinearRegression::sum_y

Contains sum of all (i-th y)

Definition at line 68 of file linreg.hpp.

Referenced by LinearRegression().

sum_y_square

long double gpmp::ml::LinearRegression::sum_y_square

Contains sum of square of all (i-th y)

Definition at line 72 of file linreg.hpp.

Referenced by LinearRegression().

x

std::vector<long double> gpmp::ml::LinearRegression::x

Dynamic array which is going to contain all (i-th x)

Examples

linreg.cpp.

Definition at line 56 of file linreg.hpp.

Referenced by test_train().

x_test

std::vector<long double> gpmp::ml::LinearRegression::x_test

Vector holding x testing data

Examples

linreg.cpp.

Definition at line 78 of file linreg.hpp.

Referenced by test_train().

x_train

std::vector<long double> gpmp::ml::LinearRegression::x_train

Vector holding x training data

Definition at line 74 of file linreg.hpp.

y

std::vector<long double> gpmp::ml::LinearRegression::y

Dynamic array which is going to contain all (i-th y)

Examples

linreg.cpp.

Definition at line 58 of file linreg.hpp.

Referenced by test_train().

y_test

std::vector<long double> gpmp::ml::LinearRegression::y_test

Vector holding y testing data

Examples

linreg.cpp.

Definition at line 80 of file linreg.hpp.

Referenced by test_train().

y_train

std::vector<long double> gpmp::ml::LinearRegression::y_train

Vector holding y training data

Definition at line 76 of file linreg.hpp.

---

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

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