Linear Regression Fitter (javascript, written by Claude Code)

Claude Code wrote this javascript project from the task below. It installed and ran on a clean Ubuntu 22.04 machine as written.

Task given to the agent:

TASK: Linear Regression Fitter

Write a program that fits linear regression models to datasets, supporting simple and multiple regression, model evaluation metrics, residual analysis, and prediction on new data.

FUNCTIONAL REQUIREMENTS:
- Accept a CSV data file as a command-line argument with the target variable specified via --target flag
- Support simple linear regression (one predictor) and multiple linear regression (multiple predictors) selected via --features flag (comma-separated column names; default: all non-target columns)
- Compute regression coefficients (intercept and slopes) using the ordinary least squares (OLS) method via the normal equation or gradient descent (selectable via --method flag)
- Report model evaluation metrics: R-squared, adjusted R-squared, mean squared error (MSE), root mean squared error (RMSE), mean absolute error (MAE), and F-statistic
- Report coefficient details: estimated value, standard error, t-statistic, and p-value for each coefficient
- Perform residual analysis: compute residuals, check for normality (Shapiro-Wilk or similar test), and detect heteroscedasticity
- Support making predictions on new data via --predict flag (path to a CSV file with predictor values)
- Support data normalization/standardization via --normalize flag
- Support train/test split via --split flag (percentage for training, e.g., --split 80 for 80% train)
- Print a comprehensive model summary to console similar to statistical software output
- Save model coefficients and metrics as JSON with --output flag (default: regression_model.json)
- If no input is given, generate a sample dataset with 200 points containing a known linear relationship with noise, fit the model, display coefficients, metrics, residual analysis, and make predictions on 5 new data points
- Handle errors: multicollinearity detection (warn if condition number is high), missing values in data, non-numeric columns, and singular design matrix

Create a complete JavaScript project for a clean Ubuntu 22.04 machine with only Node.js 20+ (LTS) installed. Include:
- Source code
- package.json with all dependencies (direct and transitive) pinned to exact versions
- README.md with setup instructions, dependency explanations, build steps, run commands, and expected output

[]

/**
 * Linear Regression Fitter
 * Fits OLS linear regression with metrics (R-squared, MSE, RMSE),
 * residual analysis, and prediction capabilities.
 *
 * Dependencies: ml-regression, csv-parse
 */

const { MultivariateLinearRegression } = require('ml-regression');
const { parse } = require('csv-parse/sync');
const fs = require('fs');

class LinearRegressionFitter {
    constructor() {
        this.model = null;
        this.featureNames = [];
        this.coefficients = [];
        this.intercept = 0;
    }

    fit(X, y, featureNames = null) {
        this.featureNames = featureNames || X[0].map((_, i) => `feature_${i + 1}`);
        this.model = new MultivariateLinearRegression(X, y.map(v => [v]));

        const weights = this.model.weights;
        this.intercept = weights[weights.length - 1][0];
        this.coefficients = [];
        for (let i = 0; i < weights.length - 1; i++) {
            this.coefficients.push(weights[i][0]);
        }
    }

    predict(X) {
        return X.map(row => {
            let pred = this.intercept;
            for (let j = 0; j < row.length; j++) {
                pred += this.coefficients[j] * row[j];
            }
            return pred;
        });
    }

    computeMetrics(yTrue, yPred) {
        const n = yTrue.length;
        let ssRes = 0, ssTot = 0, mse = 0;
        const yMean = yTrue.reduce((s, v) => s + v, 0) / n;

        for (let i = 0; i < n; i++) {
            const residual = yTrue[i] - yPred[i];
            ssRes += residual * residual;
            ssTot += (yTrue[i] - yMean) * (yTrue[i] - yMean);
            mse += residual * residual;
        }
        mse /= n;

        return {
            r_squared: 1.0 - ssRes / ssTot,
            mse: mse,
            rmse: Math.sqrt(mse)
        };
    }

    residualAnalysis(yTrue, yPred) {
        const residuals = yTrue.map((v, i) => v - yPred[i]);
        const n = residuals.length;
        const mean = residuals.reduce((s, v) => s + v, 0) / n;
        const variance = residuals.reduce((s, v) => s + (v - mean) ** 2, 0) / (n - 1);
        const std = Math.sqrt(variance);

        const sorted = [...residuals].sort((a, b) => a - b);
        const median = n % 2 === 0
            ? (sorted[n / 2 - 1] + sorted[n / 2]) / 2
            : sorted[Math.floor(n / 2)];

        // Skewness and kurtosis
        const m3 = residuals.reduce((s, v) => s + ((v - mean) / std) ** 3, 0) / n;
        const m4 = residuals.reduce((s, v) => s + ((v - mean) / std) ** 4, 0) / n - 3;

        return {
            mean, std,
            min: sorted[0],
            max: sorted[n - 1],
            median,
            skewness: m3,
            kurtosis: m4
        };
    }

    printCoefficients() {
        console.log();
        console.log('='.repeat(45));
        console.log('  Model Coefficients');
        console.log('='.repeat(45));
        console.log(`  Intercept : ${this.intercept.toFixed(6)}`);
        for (let i = 0; i < this.coefficients.length; i++) {
            const name = this.featureNames[i] || `x${i + 1}`;
            console.log(`  ${name.padEnd(12)}: ${this.coefficients[i].toFixed(6)}`);
        }
        console.log('='.repeat(45));
    }

    printMetrics(metrics, label) {
        console.log();
        console.log('='.repeat(45));
        console.log(`  ${label} Set Metrics`);
        console.log('='.repeat(45));
        console.log(`  R-squared : ${metrics.r_squared.toFixed(6)}`);
        console.log(`  MSE       : ${metrics.mse.toFixed(6)}`);
        console.log(`  RMSE      : ${metrics.rmse.toFixed(6)}`);
        console.log('='.repeat(45));
    }

    printResidualAnalysis(stats) {
        console.log();
        console.log('='.repeat(45));
        console.log('  Residual Analysis');
        console.log('='.repeat(45));
        console.log(`  Mean     : ${stats.mean.toFixed(6)}`);
        console.log(`  Std Dev  : ${stats.std.toFixed(6)}`);
        console.log(`  Min      : ${stats.min.toFixed(6)}`);
        console.log(`  Max      : ${stats.max.toFixed(6)}`);
        console.log(`  Median   : ${stats.median.toFixed(6)}`);
        console.log(`  Skewness : ${stats.skewness.toFixed(6)}`);
        console.log(`  Kurtosis : ${stats.kurtosis.toFixed(6)}`);
        console.log('='.repeat(45));
    }

    toJSON(metrics, residualStats) {
        const coefMap = {};
        for (let i = 0; i < this.coefficients.length; i++) {
            coefMap[this.featureNames[i] || `x${i + 1}`] = this.coefficients[i];
        }
        return JSON.stringify({
            intercept: this.intercept,
            coefficients: coefMap,
            metrics,
            residual_analysis: residualStats
        }, null, 2);
    }
}

function loadCsv(filepath) {
    const content = fs.readFileSync(filepath, 'utf-8');
    const records = parse(content, { columns: false, skip_empty_lines: true });
    const headers = records[0];
    const data = records.slice(1).map(row => row.map(Number));
    return { headers, data };
}

function generateSyntheticData(nSamples, nFeatures, noise, seed) {
    let s = seed;
    const nextRand = () => {
        s = (s * 1103515245 + 12345) & 0x7fffffff;
        return s / 0x7fffffff;
    };
    const nextGaussian = () => {
        const u1 = nextRand(), u2 = nextRand();
        return Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2);
    };

    const trueCoefs = Array.from({ length: nFeatures }, () => nextGaussian() * 5.0);
    const data = [];

    for (let i = 0; i < nSamples; i++) {
        const row = [];
        let y = 15.0;
        for (let j = 0; j < nFeatures; j++) {
            const x = nextGaussian() * 10.0;
            row.push(x);
            y += trueCoefs[j] * x;
        }
        y += nextGaussian() * noise;
        row.push(y);
        data.push(row);
    }
    return data;
}

function trainTestSplit(data, nFeatures, testRatio, seed) {
    let s = seed;
    const nextRand = () => {
        s = (s * 1103515245 + 12345) & 0x7fffffff;
        return s / 0x7fffffff;
    };

    const xTrain = [], yTrain = [], xTest = [], yTest = [];
    for (const row of data) {
        const features = row.slice(0, nFeatures);
        const target = row[nFeatures];
        if (nextRand() < testRatio) {
            xTest.push(features);
            yTest.push(target);
        } else {
            xTrain.push(features);
            yTrain.push(target);
        }
    }
    return { xTrain, yTrain, xTest, yTest };
}

function main() {
    console.log('='.repeat(50));
    console.log('  Linear Regression Fitter (ml-regression + csv-parse)');
    console.log('='.repeat(50));

    let nFeatures = 3;
    let featureNames;
    let data;

    const args = process.argv.slice(2);

    if (args.length > 0 && fs.existsSync(args[0])) {
        const csv = loadCsv(args[0]);
        nFeatures = csv.headers.length - 1;
        featureNames = csv.headers.slice(0, nFeatures);
        data = csv.data;
        console.log(`Loaded dataset with ${data.length} rows and ${csv.headers.length} columns.`);
    } else {
        console.log('\nNo CSV file provided. Using synthetic data.\n');
        data = generateSyntheticData(200, nFeatures, 10.0, 42);
        featureNames = ['feature_1', 'feature_2', 'feature_3'];
    }

    const { xTrain, yTrain, xTest, yTest } = trainTestSplit(data, nFeatures, 0.2, 42);

    console.log(`Training samples: ${xTrain.length}`);
    console.log(`Test samples    : ${xTest.length}`);

    const lr = new LinearRegressionFitter();
    lr.fit(xTrain, yTrain, featureNames);
    lr.printCoefficients();

    const yTrainPred = lr.predict(xTrain);
    const trainMetrics = lr.computeMetrics(yTrain, yTrainPred);
    lr.printMetrics(trainMetrics, 'Training');

    const yTestPred = lr.predict(xTest);
    const testMetrics = lr.computeMetrics(yTest, yTestPred);
    lr.printMetrics(testMetrics, 'Test');

    const residualStats = lr.residualAnalysis(yTest, yTestPred);
    lr.printResidualAnalysis(residualStats);

    console.log();
    console.log('='.repeat(45));
    console.log('  Prediction Example');
    console.log('='.repeat(45));
    const displayCount = Math.min(5, xTest.length);
    for (let i = 0; i < displayCount; i++) {
        console.log(`  Sample ${i + 1}: actual=${yTest[i].toFixed(4)}, predicted=${yTestPred[i].toFixed(4)}`);
    }
    console.log('='.repeat(45));

    console.log('\nJSON Output:');
    console.log(lr.toJSON(testMetrics, residualStats));
}

main();

{
  "name": "linear-regression-fitter",
  "version": "1.0.0",
  "description": "OLS linear regression with metrics, residual analysis, and prediction",
  "main": "linearRegression.js",
  "scripts": {
    "start": "node linearRegression.js",
    "demo": "node linearRegression.js"
  },
  "dependencies": {
    "ml-regression": "^5.0.0",
    "csv-parse": "^5.5.3"
  },
  "keywords": ["regression", "machine-learning", "statistics", "ols"],
  "license": "MIT"
}

# Linear Regression Fitter (JavaScript - ml-regression + csv-parse)

Fits OLS linear regression models with comprehensive metrics (R-squared, MSE, RMSE), residual analysis, and prediction capabilities using Node.js.

## Dependencies

- **ml-regression**: Machine learning regression library for JavaScript
- **csv-parse**: CSV parsing module for Node.js

## Installation

```bash
npm install
```

## Usage

```bash
# Run with synthetic data
node linearRegression.js

# Run with a CSV file (last column is target)
node linearRegression.js data.csv
```

## Features

- Multivariate OLS linear regression via ml-regression
- CSV data loading with automatic header detection
- Synthetic data generation for demonstration
- Train/test split for model evaluation
- Regression metrics: R-squared, MSE, RMSE
- Residual analysis: mean, std, min, max, median, skewness, kurtosis
- JSON export of model coefficients and metrics