RegressionModel.cpp

#include <iostream>
#include <vector>
#include <string>
#include <regex>
#include <sstream>
#include <cstdlib>
using namespace std;

class input_handler {
    public:
    vector<double> x_data;
    vector<double> y_data;
    string userInput;
    input_handler() {
        getline(cin, userInput);
        input_pusher(userInput);
    }

    ~input_handler() {
        x_data.clear();
        y_data.clear();
    }

    void input_pusher (const string& userInput) {
        //regex digitGrabber("\\d+\\.?\\d*");
        regex puncRemover("[^0-9.-]");
        string cleaned = regex_replace(userInput, puncRemover, " ");
        istringstream stream(cleaned); 
        string tokenized_input;
        int interval = 0;
        while(stream >> tokenized_input) {
                interval++;
                if(interval % 2 != 0)
                    x_data.push_back(stod(tokenized_input));
                else
                    y_data.push_back(stod(tokenized_input));
        }
        if(y_data.size() != x_data.size()) {
            cout << "Error: unbalanced values" << endl;
            exit(1);
        }
        
    }
};

class regressionModel : public input_handler{
    public:
    double m = 0;
    double b = 0;
    double learning_rate = 0.01; //learning rate is like the how much the slope is rotating towards its desired location
    int iterations = 1000; //controls how many times the learning gets iterated

    ~regressionModel() {
        cout << "Predicted Slope: y = " << m << "x + " << b <<  endl;
        m = 0;
        b = 0;
    }

    regressionModel() {
        train();
    }

    void train() {
        int n  = x_data.size(); //amount of coordinates in order to get averages
        double prev_difference = 0.0; //holds the previous difference
        double curr_difference = 0.0; //holds the current difference
        for(int i = 0; i < iterations; i++) {
            double compilation_m = 0; // set these to zero to create new instances each iteration
            double compilation_b = 0;
            vector<double> y_prediction = predict(m, b); //execute 'y = mx + b' based off of compilation values
            curr_difference = 0; //creates new instances of the current difference
            for(int j = 0; j < n; j++) {
                //gradient descent
                compilation_m += -2 * x_data[j] * (y_data[j] - y_prediction[j]); //m has both x/y-components
                compilation_b += -2 * (y_data[j] - y_prediction[j]); //b only has a y-component

                curr_difference += (y_data[j] - (m * x_data[j] + b)) * (y_data[j] - (m * x_data[j] + b)); //square error method - takes the origianal y-value to the predicted y-vale and finds the difference
                //we multiple it to avoid negatives and to make it more zoomed in and be more accurate 
            }
            curr_difference /= n; //gets the average

            if (abs(curr_difference - prev_difference) < 1e-6) break; //if the difference is small between the last iteration, break out of the loop

            prev_difference = curr_difference; //do recursion for the previous difference
        
            m -= (learning_rate * compilation_m) / n; //gets the average with respect of the learning rate (this gets repeatadly updated till we decide to print it)
            b -= (learning_rate * compilation_b) / n;

        }
    }
    vector<double> predict(double m, double b) {
        vector<double> y_prediction;
        for(double X: x_data)
            y_prediction.push_back(m * X + b); 
        return y_prediction;
    }
};

int main () {
    regressionModel model;
    return 0;
}