linreg.cpp

Go to the documentation of this file.

 
#include <iostream>
#include <stdio.h>
// include all of the openGPMP headers
#include <openGPMP/gpmp.h>
 
static gpmp::core::Logger _log_;
 
void test_train() {
    _log_.log(INFO, "OpenGPMP LinearRegression class");
 
    gpmp::core::DataTable dt;
 
    gpmp::core::DataTableStr result =
        dt.csv_read("../../data/school_scores.csv", {"Year", "GPA"});
 
    // Create a LinearRegression object
    gpmp::ml::LinearRegression reg;
 
    std::vector<std::string> columns = {"Year", "GPA"};
 
    // Load data into the LinearRegression object
    reg.get_input(result, columns);
 
    _log_.log(INFO, "Before splitting");
 
    // Printing the best fitting line before splitting
    reg.best_fit();
 
    int v1 = 2007;
    double v1_v = reg.predict(v1, reg.x);
    double v1_e = reg.error_in(v1, reg.x, reg.y);
    _log_.log(INFO,
              "Predicted value at " + std::to_string(v1) + " = " +
                  std::to_string(v1_v));
 
    _log_.log(INFO,
              "Error value at " + std::to_string(v1) + " = " +
                  std::to_string(v1_e));
 
    // Now, perform data splitting
    reg.split_data(0.3, 42, false); // 70% for training, 30% for testing
 
    _log_.log(INFO, "After splitting");
 
    // Printing the best fitting line after splitting
    reg.best_fit();
 
    double v1_v_after_split = reg.predict(v1, reg.x_test);
    double v1_e_after_split = reg.error_in(v1, reg.x_test, reg.y_test);
    printf("Predicted value at %d   = %f\n", v1, v1_v_after_split);
    printf("Error value at %d       = %f\n\n", v1, v1_e_after_split);
    _log_.log(INFO,
              "Predicted value at " + std::to_string(v1) + " = " +
                  std::to_string(v1_v_after_split));
 
    _log_.log(INFO,
              "Error value at " + std::to_string(v1) + " = " +
                  std::to_string(v1_e_after_split));
 
    // Calculate MSE and R2 score after splitting
    double mse_after_split = reg.mse(reg.x_test, reg.y_test);
    double r_squared_after_split = reg.r_sqrd(reg.x_test, reg.y_test);
 
    _log_.log(INFO, "MSE = " + std::to_string(mse_after_split));
    _log_.log(INFO, "R2 score = " + std::to_string(r_squared_after_split));
}
 
int main() {
    test_train();
    // gpmp::ml::LinearRegression reg;
    // gpmp::core::DataTable dt;
    //  gpmp::core::DataTableStr result =
    //  dt.csv_read("../../data/forestfires.csv",
    //                                                {"month", "day", "temp",
    //                                                "wind"});
 
    /*gpmp::core::DataTableStr result =
        dt.csv_read("../../data/school_scores.csv", {"Year", "GPA"});
 
    dt.display(result);
    std::vector<std::string> columns = {"Year", "GPA"};
    // pass in the datatable (result) and specify x , y columns
    reg.get_input(result, columns);
 
    // split data into 75% training and 25% testing
    reg.split_data(0.25);
 
    // declare Regression class object
 
    printf("LINEAR REGRESSION EXAMPLE ON YEAR/GPA DATA IN "
           "MATHEMATICS\n");
 
    // Printing the best fitting line
    reg.best_fit();
 
    int v1 = 1995;
    double v1_v = reg.predict(v1);
    double v1_e = reg.error_in(v1);
    printf("Predicted value at %d   = %f\n", v1, v1_v);
    printf("Error value at %d       = %f\n\n", v1, v1_e);
 
    int v2 = 1997;
    double v2_v = reg.predict(v2);
    double v2_e = reg.error_in(v2);
    printf("Predicted value at %d   = %f\n", v2, v2_v);
    printf("Error value at %d       = %f\n\n", v2, v2_e);
 
    int v3 = 1999;
    double v3_v = reg.predict(v3);
    double v3_e = reg.error_in(v3);
    printf("Predicted value at %d   = %f\n", v3, v3_v);
    printf("Error value at %d       = %f\n\n", v3, v3_e);
 
    int v4 = 2001;
    double v4_v = reg.predict(v4);
    double v4_e = reg.error_in(v4);
    printf("Predicted value at %d   = %f\n", v4, v4_v);
    printf("Error value at %d       = %f\n\n", v4, v4_e);
 
    int v5 = 2003;
    double v5_v = reg.predict(v5);
    double v5_e = reg.error_in(v5);
    printf("Predicted value at %d   = %f\n", v5, v5_v);
    printf("Error value at %d       = %f\n\n", v5, v5_e);
 
    int v6 = 2005;
    double v6_v = reg.predict(v6);
    double v6_e = reg.error_in(v6);
    printf("Predicted value at %d   = %f\n", v6, v6_v);
    printf("Error value at %d       = %f\n\n", v6, v6_e);
 
    int v7 = 2006;
    double v7_v = reg.predict(v7);
    double v7_e = reg.error_in(v7);
    printf("Predicted value at %d   = %f\n", v7, v7_v);
    printf("Error value at %d       = %f\n\n", v7, v7_e);
 
    int v8 = 2007;
    double v8_v = reg.predict(v8);
    double v8_e = reg.error_in(v8);
    printf("Predicted value at %d   = %f\n", v8, v8_v);
    printf("Error value at %d       = %f\n\n", v8, v8_e);
 
    int v10 = 2016;
    double v10_v = reg.predict(v10);
    double v10_e = reg.error_in(v10);
    printf("Predicted value at %d   = %f\n", v10, v10_v);
    printf("Error value at %d       = %f\n\n", v10, v10_e);
 
    int v11 = 2017;
    double v11_v = reg.predict(v11);
    double v11_e = reg.error_in(v11);
    printf("Predicted value at %d   = %f\n", v11, v11_v);
    printf("Error value at %d       = %f\n\n", v11, v11_e);
  */
    return 0;
}