Régression linéaire en Javascript

je veux faire les moindres carrés S'ajustant en Javascript dans un navigateur web.

actuellement les utilisateurs entrent des informations de point de données en utilisant des entrées de texte HTML et puis je prends ces données avec jQuery et les graphe avec Flot.

après que l'Utilisateur a entré dans leurs points de données je voudrais leur présenter une "ligne de meilleur ajustement". J'imagine que je calculerais les équations linéaire, polynomiale, exponentielle et logarithmique et puis je choisirais celle avec la plus haute R^2 valeur.

il semble que je ne trouve aucune bibliothèque qui puisse m'aider à le faire. Je suis tombé sur jStat, mais il manque complètement de documentation (pour autant que je puisse trouver) et après avoir fouillé dans le code source, il ne semble pas y avoir de fonctionnalité de régression linéaire intégrée--je me base uniquement sur les noms de fonction cependant.

Est-ce que quelqu'un connaît des bibliothèques Javascript qui offrent une régression simple l'analyse?


L'espoir serait que je puisse utiliser la bibliothèque comme si...

Si j'ai eu quelques de dispersion des points dans un tableau var points = [[3,4],[15,45],...[23,78]], j'ai réussi à main qui à une fonction comme lin_reg(points) et il serait de retour quelque chose comme [7.12,3] si l'équation linéaire a été y = 7.12 x + 3.

24
demandé sur Chris W. 2011-06-01 05:28:31
la source

7 ответов

Quel type de régression linéaire? Pour quelque chose de simple comme la méthode des moindres carrés, je venais de le programmer moi-même:

http://mathworld.wolfram.com/LeastSquaresFitting.html

Les mathématiques n'est pas trop dur à suivre, là, donner un coup de feu pendant une heure ou ainsi et laissez-moi savoir si c'est trop dur, je peux essayer.

EDIT:

Trouvé quelqu'un qui n'a c':

http://dracoblue.net/dev/linear-least-squares-in-javascript/159/

20
répondu Milimetric 2011-06-01 08:25:45
la source

j'ai trouvé cette grande bibliothèque JavaScript.

C'est très simple, et semble fonctionner parfaitement.

Je ne peux pas non plus recommander les maths.JS assez.

7
répondu JZL003 2014-10-08 02:26:58
la source

découvrez https://web.archive.org/web/20150523035452/https://cgwb.nci.nih.gov/cgwbreg.html (calculatrice de régression javascript) - pur JavaScript, pas les appels CGI au serveur. Les données et le traitement restent sur votre ordinateur. Complète de R de ce style et de la R du code pour vérifier le travail et la visualisation des résultats.

voir le code source pour les implémentations JavaScript intégrées des OLS et des statistiques associées aux résultats.

le code est mes efforts pour porter les fonctions de la bibliothèque GSL à JavaScript.

les codes sont publiés sous GPL parce que c'est essentiellement la ligne pour le portage de ligne du code de bibliothèque scientifique Gnu (GSL) sous licence GPL.

EDIT: Paul Lutus fournit aussi du code GPL pour la régression à: http://arachnoid.com/polysolve/index.html

7
répondu Richard Finney 2018-04-30 13:06:34
la source
http://trentrichardson.com/2010/04/06/compute-linear-regressions-in-javascript/

notez qu'en plus de l'équation linéaire, il renvoie aussi le score R2, qui peut être utile.

** EDIT **

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;
}

pour utiliser ceci vous avez juste besoin de passer deux tableaux, known_y et known_x, donc ceci est ce que vous pourriez passer:

var known_y = [1, 2, 3, 4];
var known_x = [5.2, 5.7, 5.0, 4.2];

var lr = linearRregression(known_y, known_x);
// now you have:
// lr.slope
// lr.intercept
// lr.r2
5
répondu o_c 2015-07-22 19:02:48
la source

voici un extrait qui prendra un tableau de triplets (x, y, r) où r est le poids du (x, y) point de données et RETOUR [A, b] tel que Y = a*X + b approximatif des données.

// 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];
}
4
répondu Nic Mabon 2012-04-27 19:06:47
la source

un peu basé sur la réponse de 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 };
}

puis y' = x * gain + offset.

1
répondu Timmmm 2015-06-10 13:02:55
la source

régression linéaire Simple avec mesures de la variation (somme totale des carrés = régression somme des carrés + erreur somme des carrés ), erreur-Type D'estimation voir (erreur-type résiduelle), et coefficients de détermination R2 et de corrélation 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]);
1
répondu didinko 2017-03-28 21:48:09
la source