Linear_Regression.cpp

#include <iostream>
#include <fstream>
#include <sstream>
#include <vector>
#include <string>
#include <cmath>
#include <iomanip>
#include <map>
#include <algorithm>

using namespace std;

class LabelEncoder {
    map<string, double> mapping;
    int next_code = 0;
public:
    double encode(const string &s) {
        if (mapping.find(s) == mapping.end()) {
            mapping[s] = next_code++;
        }
        return mapping[s];
    }
};

LabelEncoder weatherEnc, trafficEnc, priorityEnc, timeEnc, vehicleEnc;

vector<string> parseCSVLine(const string &line) {
    vector<string> tokens;
    string token;
    bool inside_quotes = false;

    for (char c : line) {
        if (c == '"') {
            inside_quotes = !inside_quotes;
        } else if (c == ',' && !inside_quotes) {
            tokens.push_back(token);
            token.clear();
        } else {
            token += c;
        }
    }
    tokens.push_back(token); 
    return tokens;
}

void parseLocation(string locStr, vector<double> &row) {
    locStr.erase(remove(locStr.begin(), locStr.end(), '"'), locStr.end());
    locStr.erase(remove(locStr.begin(), locStr.end(), '('), locStr.end());
    locStr.erase(remove(locStr.begin(), locStr.end(), ')'), locStr.end());
    
    stringstream ss(locStr);
    string segment;
    while(getline(ss, segment, ',')) {
        try {
            row.push_back(stod(segment));
        } catch(...) { row.push_back(0.0); }
    }
}

bool loadCSV(const string &filename, vector<vector<double>> &X, vector<double> &y) {
    ifstream file(filename);
    if (!file.is_open()) {
        cerr << "Error: Could not open file: " << filename << endl;
        return false;
    }

    string line;
    getline(file, line); 

    int lineNum = 1;
    while (getline(file, line)) {
        lineNum++;
        if (line.empty() || line.back() == '\r') if(!line.empty()) line.pop_back(); 
        if (line.empty()) continue;

        vector<string> tokens = parseCSVLine(line);
        
        if (tokens.size() < 15) continue;

        vector<double> features;
        double target = 0.0;

        try {
            parseLocation(tokens[1], features); 

            parseLocation(tokens[2], features);

            features.push_back(stod(tokens[3]));

            features.push_back(weatherEnc.encode(tokens[4]));

            features.push_back(trafficEnc.encode(tokens[5]));

            features.push_back(stod(tokens[6]));
            features.push_back(priorityEnc.encode(tokens[7]));

            features.push_back(timeEnc.encode(tokens[8]));

            features.push_back(vehicleEnc.encode(tokens[9]));

            features.push_back(stod(tokens[10]));

            features.push_back(stod(tokens[11]));
            target = stod(tokens[12]);

            features.push_back(stod(tokens[13]));

            features.push_back(stod(tokens[14]));

            X.push_back(features);
            y.push_back(target);

        } catch (const exception &e) {
            cerr << "Skipping line " << lineNum << ": Parsing error." << endl;
            continue;
        }
    }
    file.close();
    return true;
}

void featureScaling(vector<vector<double>> &X, vector<double> &mean, vector<double> &stddev) {
    if (X.empty()) return;
    int n = X.size();
    int m = X[0].size();
    mean.assign(m, 0.0);
    stddev.assign(m, 0.0);

    for (int j = 0; j < m; ++j) {
        for (int i = 0; i < n; ++i) mean[j] += X[i][j];
        mean[j] /= n;
    }
    for (int j = 0; j < m; ++j) {
        for (int i = 0; i < n; ++i) stddev[j] += pow(X[i][j] - mean[j], 2);
        stddev[j] = sqrt(stddev[j] / n);
    }
    for (int i = 0; i < n; ++i)
        for (int j = 0; j < m; ++j)
            if (stddev[j] > 1e-9) X[i][j] = (X[i][j] - mean[j]) / stddev[j];
}

double predict(const vector<double> &row, const vector<double> &weights, double bias) {
    double res = bias;
    for (size_t i = 0; i < weights.size(); ++i) res += weights[i] * row[i];
    return res;
}

void trainModel(vector<vector<double>> &X, vector<double> &y, vector<double> &weights, double &bias, double lr, int epochs) {
    int n = X.size();
    int m = X[0].size();
    weights.assign(m, 0.0);
    bias = 0.0;
    vector<double> dw(m);
    
    cout << "Training on " << n << " samples with " << m << " features..." << endl;

    for (int i = 0; i < epochs; ++i) {
        fill(dw.begin(), dw.end(), 0.0);
        double db = 0.0;
        double cost = 0.0;

        for (int k = 0; k < n; ++k) {
            double err = predict(X[k], weights, bias) - y[k];
            cost += err * err;
            for (int j = 0; j < m; ++j) dw[j] += err * X[k][j];
            db += err;
        }

        for (int j = 0; j < m; ++j) weights[j] -= (lr * 2 / n) * dw[j];
        bias -= (lr * 2 / n) * db;

        if (i % 500 == 0) cout << "Epoch " << i << " Cost: " << cost/n << endl;
    }
}

int main() {
    vector<vector<double>> X;
    vector<double> y;

    if (!loadCSV("Food_Delivery_Time_Prediction.csv", X, y)) return -1;

    vector<double> mean, stddev;
    featureScaling(X, mean, stddev);

    vector<double> weights;
    double bias;
    trainModel(X, y, weights, bias, 0.01, 3000); 

    cout << "\n--- Final Model ---\n";
    cout << "Bias: " << bias << endl;
    cout << "Weights: ";
    for(double w : weights) cout << w << " ";
    cout << endl;

    return 0;
}