当前位置：首页 > JavaScript

js实现多远

2026-03-15 02:54:45JavaScript

JavaScript 实现多元线性回归

在JavaScript中实现多元线性回归，可以通过矩阵运算库（如math.js）或手动实现最小二乘法。以下是两种常见方法：

使用数学库实现

安装math.js库：

npm install mathjs

代码示例：

const math = require('mathjs');

function multipleLinearRegression(X, y) {
  // 添加截距项（全1列）
  const X_with_intercept = X.map(row => [1, ...row]);

  // 计算 (X'X)^-1 X'y
  const XT = math.transpose(X_with_intercept);
  const XTX = math.multiply(XT, X_with_intercept);
  const XTX_inv = math.inv(XTX);
  const XTy = math.multiply(XT, y);
  const coefficients = math.multiply(XTX_inv, XTy);

  return coefficients;
}

// 示例数据：2个特征
const X = [
  [1, 2],
  [2, 3],
  [3, 4]
];
const y = [3, 5, 7];

const beta = multipleLinearRegression(X, y);
console.log('系数:', beta); // 包括截距和斜率

手动实现最小二乘法

对于小型数据集，可以手动实现矩阵运算：

function matrixMultiply(A, B) {
  return A.map((row, i) => 
    B[0].map((_, j) => 
      row.reduce((sum, val, k) => sum + val * B[k][j], 0)
    )
  );
}

function transpose(matrix) {
  return matrix[0].map((_, i) => matrix.map(row => row[i]));
}

function linearRegression(X, y) {
  const X_with_intercept = X.map(row => [1, ...row]);
  const XT = transpose(X_with_intercept);
  const XTX = matrixMultiply(XT, X_with_intercept);

  // 简单求逆（仅适用于小矩阵）
  const det = XTX[0][0] * XTX[1][1] - XTX[0][1] * XTX[1][0];
  const XTX_inv = [
    [XTX[1][1]/det, -XTX[0][1]/det],
    [-XTX[1][0]/det, XTX[0][0]/det]
  ];

  const XTy = matrixMultiply(XT, y.map(val => [val]));
  return matrixMultiply(XTX_inv, XTy);
}

使用梯度下降

对于大规模数据，梯度下降更高效：

js实现多远

function gradientDescent(X, y, learningRate = 0.01, epochs = 1000) {
  const n = X.length;
  const m = X[0].length;
  let beta = Array(m + 1).fill(0); // 包括截距

  for (let epoch = 0; epoch < epochs; epoch++) {
    const gradients = Array(m + 1).fill(0);

    for (let i = 0; i < n; i++) {
      const prediction = beta[0] + X[i].reduce((sum, val, j) => sum + val * beta[j + 1], 0);
      const error = prediction - y[i];

      gradients[0] += error;
      X[i].forEach((val, j) => {
        gradients[j + 1] += error * val;
      });
    }

    beta = beta.map((val, j) => val - (learningRate / n) * gradients[j]);
  }

  return beta;
}