Javascript中的线性回归

我想在web浏览器中用Javascript进行最小二乘拟合

目前，用户使用HTML文本输入输入数据点信息，然后我用jQuery获取数据并用图形表示

在用户输入了他们的数据点后，我想向他们展示一条“最佳拟合线”。我想我会计算线性、多项式、指数和对数方程，然后选择一个具有最高

R^2

值的方程

不过，我似乎找不到任何能帮助我做到这一点的库。我无意中发现了它，但它完全缺少文档（据我所知），在深入研究了源代码之后，它似乎没有任何内置的线性回归功能——不过，我纯粹是基于函数名

有人知道提供简单回归分析的Javascript库吗

---

希望我能像这样使用图书馆

---

如果我在一个数组中有一组分散点

var points=[[3,4]，[15,45]，…[23,78]

，我就可以把它交给一些函数，比如

lin_reg（points）

，如果线性方程是

y=7.12 x+3

，它会返回类似

[7.12,3]

，如果线性方程是

y=7.12 x+3
什么样的线性回归？对于一些简单的东西，比如最小二乘法，我只需要自己编程：


数学不是很难理解，试一试一个小时左右，如果太难，让我知道，我可以试试

编辑：

找到了做这件事的人：

这里有一个片段，它将获取一个三元组数组（x，y，r），其中r是（x，y）数据点的权重，并返回[a，b]，使得y=a*x+b近似于数据

// return (a, b) that minimize
// sum_i r_i * (a*x_i+b - y_i)^2
function linear_regression( xyr )
{
    var i, 
        x, y, r,
        sumx=0, sumy=0, sumx2=0, sumy2=0, sumxy=0, sumr=0,
        a, b;

    for(i=0;i<xyr.length;i++)
    {   
        // this is our data pair
        x = xyr[i][0]; y = xyr[i][1]; 

        // this is the weight for that pair
        // set to 1 (and simplify code accordingly, ie, sumr becomes xy.length) if weighting is not needed
        r = xyr[i][2];  

        // consider checking for NaN in the x, y and r variables here 
        // (add a continue statement in that case)

        sumr += r;
        sumx += r*x;
        sumx2 += r*(x*x);
        sumy += r*y;
        sumy2 += r*(y*y);
        sumxy += r*(x*y);
    }

    // note: the denominator is the variance of the random variable X
    // the only case when it is 0 is the degenerate case X==constant
    b = (sumy*sumx2 - sumx*sumxy)/(sumr*sumx2-sumx*sumx);
    a = (sumr*sumxy - sumx*sumy)/(sumr*sumx2-sumx*sumx);

    return [a, b];
}

//返回最小化
//求和*（a*x\u i+b-y\u i）^2
函数线性回归（xyr）
{
var i，
x、 y，r，
sumx=0，sumy=0，sumx2=0，sumy2=0，sumxy=0，sumr=0，
a、 b；
对于（i=0；i签出
（javascript回归计算器）-纯javascript，而不是对服务器的CGI调用。数据和处理仍保留在您的计算机上。完成R风格的结果和R代码以检查工作和结果的可视化

有关OLS的嵌入式JavaScript实现以及与结果相关的统计信息，请参阅源代码

这段代码是我将GSL库函数移植到JavaScript的努力

这些代码是在GPL下发布的，因为它基本上是GPL许可的Gnu科学库（GSL）代码的逐行移植

编辑：Paul Lutus还提供了一些回归的GPL代码：
我发现

它非常简单，似乎工作得很完美

我对Math.JS的推荐也不够。
多少是基于Nic Mabon的答案

function linearRegression(x, y)
{
    var xs = 0;  // sum(x)
    var ys = 0;  // sum(y)
    var xxs = 0; // sum(x*x)
    var xys = 0; // sum(x*y)
    var yys = 0; // sum(y*y)

    var n = 0;
    for (; n < x.length && n < y.length; n++)
    {
        xs += x[n];
        ys += y[n];
        xxs += x[n] * x[n];
        xys += x[n] * y[n];
        yys += y[n] * y[n];
    }

    var div = n * xxs - xs * xs;
    var gain = (n * xys - xs * ys) / div;
    var offset = (ys * xxs - xs * xys) / div;
    var correlation = Math.abs((xys * n - xs * ys) / Math.sqrt((xxs * n - xs * xs) * (yys * n - ys * ys)));

    return { gain: gain, offset: offset, correlation: correlation };
}

函数线性回归（x，y）
{
var xs=0；//和（x）
var ys=0；//总和（y）
var xxs=0；//和（x*x）
var xys=0；//和（x*y）
var yys=0；//和（y*y）
var n=0；
对于（；n

然后y'=x*gain+offset。
我为手头的问题找到的最简单的解决方案可以在下面的帖子中找到：

请注意，除了线性方程外，它还返回R2分数，这可能很有用

**编辑**

以下是实际的代码片段：

function linearRegression(y,x){
        var lr = {};
        var n = y.length;
        var sum_x = 0;
        var sum_y = 0;
        var sum_xy = 0;
        var sum_xx = 0;
        var sum_yy = 0;

        for (var i = 0; i < y.length; i++) {

            sum_x += x[i];
            sum_y += y[i];
            sum_xy += (x[i]*y[i]);
            sum_xx += (x[i]*x[i]);
            sum_yy += (y[i]*y[i]);
        } 

        lr['slope'] = (n * sum_xy - sum_x * sum_y) / (n*sum_xx - sum_x * sum_x);
        lr['intercept'] = (sum_y - lr.slope * sum_x)/n;
        lr['r2'] = Math.pow((n*sum_xy - sum_x*sum_y)/Math.sqrt((n*sum_xx-sum_x*sum_x)*(n*sum_yy-sum_y*sum_y)),2);

        return lr;
}

简单线性回归与变异度量（总平方和=回归平方和+误差平方和）、估计标准误差（剩余标准误差）以及确定系数R2和相关系数R

const regress = (x, y) => {
    const n = y.length;
    let sx = 0;
    let sy = 0;
    let sxy = 0;
    let sxx = 0;
    let syy = 0;
    for (let i = 0; i < n; i++) {
        sx += x[i];
        sy += y[i];
        sxy += x[i] * y[i];
        sxx += x[i] * x[i];
        syy += y[i] * y[i];
    }
    const mx = sx / n;
    const my = sy / n;
    const yy = n * syy - sy * sy;
    const xx = n * sxx - sx * sx;
    const xy = n * sxy - sx * sy;
    const slope = xy / xx;
    const intercept = my - slope * mx;
    const r = xy / Math.sqrt(xx * yy);
    const r2 = Math.pow(r,2);
    let sst = 0;
    for (let i = 0; i < n; i++) {
       sst += Math.pow((y[i] - my), 2);
    }
    const sse = sst - r2 * sst;
    const see = Math.sqrt(sse / (n - 2));
    const ssr = sst - sse;
    return {slope, intercept, r, r2, sse, ssr, sst, sy, sx, see};
}
regress([1, 2, 3, 4, 5], [1, 2, 3, 4, 3]);

const回归=（x，y）=>{
常数n=y.长度；
设sx=0；
设sy=0；
设sxy=0；
设sxx=0；
设syy=0；
for（设i=0；i
对不起，我上一节统计课已经过了一段时间了。；）是的，最小二乘拟合是我要找的。（我编辑了我的问题，想说的也一样多）此外，如果有必要的话，我当然会自己编程，但如果可能的话，我当然更愿意使用一个库——我无法想象没有什么东西可以做到这一点。我不久前做了一个小库，用来做一些简单的矩阵东西，比如行列式和逆矩阵，它们对于最小二乘法计算来说很方便——这并不难。有很多我需要一些技巧来提高性能，但只有在出现问题时才需要。它们会混淆代码。@omega，重复的x值？基本算法似乎没有考虑到这一点，我还没有做数学计算来解决它，但我猜你可能可以对多次出现的每个x取不同的y值的平均值？或者几何平均数？不确定，如果你算出了，就把它摆弄一下，然后贴上一些东西。@Milimetric嘿，请快速检查一下线性回归算法是否适用于pr的情况
const regress = (x, y) => {
    const n = y.length;
    let sx = 0;
    let sy = 0;
    let sxy = 0;
    let sxx = 0;
    let syy = 0;
    for (let i = 0; i < n; i++) {
        sx += x[i];
        sy += y[i];
        sxy += x[i] * y[i];
        sxx += x[i] * x[i];
        syy += y[i] * y[i];
    }
    const mx = sx / n;
    const my = sy / n;
    const yy = n * syy - sy * sy;
    const xx = n * sxx - sx * sx;
    const xy = n * sxy - sx * sy;
    const slope = xy / xx;
    const intercept = my - slope * mx;
    const r = xy / Math.sqrt(xx * yy);
    const r2 = Math.pow(r,2);
    let sst = 0;
    for (let i = 0; i < n; i++) {
       sst += Math.pow((y[i] - my), 2);
    }
    const sse = sst - r2 * sst;
    const see = Math.sqrt(sse / (n - 2));
    const ssr = sst - sse;
    return {slope, intercept, r, r2, sse, ssr, sst, sy, sx, see};
}
regress([1, 2, 3, 4, 5], [1, 2, 3, 4, 3]);