Trend-Linien ( regression, Kurvenanpassung) java-Bibliothek

Da Sie alle basieren auf linearen passt, OLSMultipleLinearRegression ist alles was Sie brauchen für lineare, polynomiale, exponentielle, logarithmische und macht Trendlinien.

Ihre Frage gab mir eine Ausrede, um downloaden und spielen Sie mit den commons math regression tools, und ich zusammen einige trend-line tools:

Schnittstelle:

public interface TrendLine {
    public void setValues(double[] y, double[] x); //y ~ f(x)
    public double predict(double x); //get a predicted y for a given x
}

Eine abstrakte Klasse für regression-based-Trendlinien:

public abstract class OLSTrendLine implements TrendLine {

    RealMatrix coef = null; //will hold prediction coefs once we get values

    protected abstract double[] xVector(double x); //create vector of values from x
    protected abstract boolean logY(); //set true to predict log of y (note: y must be positive)

    @Override
    public void setValues(double[] y, double[] x) {
        if (x.length != y.length) {
            throw new IllegalArgumentException(String.format("The numbers of y and x values must be equal (%d != %d)",y.length,x.length));
        }
        double[][] xData = new double[x.length][]; 
        for (int i = 0; i < x.length; i++) {
            //the implementation determines how to produce a vector of predictors from a single x
            xData[i] = xVector(x[i]);
        }
        if(logY()) { //in some models we are predicting ln y, so we replace each y with ln y
            y = Arrays.copyOf(y, y.length); //user might not be finished with the array we were given
            for (int i = 0; i < x.length; i++) {
                y[i] = Math.log(y[i]);
            }
        }
        OLSMultipleLinearRegression ols = new OLSMultipleLinearRegression();
        ols.setNoIntercept(true); //let the implementation include a constant in xVector if desired
        ols.newSampleData(y, xData); //provide the data to the model
        coef = MatrixUtils.createColumnRealMatrix(ols.estimateRegressionParameters()); //get our coefs
    }

    @Override
    public double predict(double x) {
        double yhat = coef.preMultiply(xVector(x))[0]; //apply coefs to xVector
        if (logY()) yhat = (Math.exp(yhat)); //if we predicted ln y, we still need to get y
        return yhat;
    }
}

Implementierung zu einem Polynom oder lineare Modelle:

(Für lineare Modelle) stellen Sie den Grad, zu 1 beim Aufruf des Konstruktors.)

public class PolyTrendLine extends OLSTrendLine {
    final int degree;
    public PolyTrendLine(int degree) {
        if (degree < 0) throw new IllegalArgumentException("The degree of the polynomial must not be negative");
        this.degree = degree;
    }
    protected double[] xVector(double x) { //{1, x, x*x, x*x*x, ...}
        double[] poly = new double[degree+1];
        double xi=1;
        for(int i=0; i<=degree; i++) {
            poly[i]=xi;
            xi*=x;
        }
        return poly;
    }
    @Override
    protected boolean logY() {return false;}
}

Exponential-und power-Modelle sind noch einfacher:

(Hinweis: wir sind Vorhersage log y nun-das ist wichtig. Beide eignen sich nur für positive y -)

public class ExpTrendLine extends OLSTrendLine {
    @Override
    protected double[] xVector(double x) {
        return new double[]{1,x};
    }

    @Override
    protected boolean logY() {return true;}
}

und

public class PowerTrendLine extends OLSTrendLine {
    @Override
    protected double[] xVector(double x) {
        return new double[]{1,Math.log(x)};
    }

    @Override
    protected boolean logY() {return true;}

}

Und ein log-Modell:

(Was nimmt der Logarithmus von x, sondern prognostiziert y, nicht ln y)

public class LogTrendLine extends OLSTrendLine {
    @Override
    protected double[] xVector(double x) {
        return new double[]{1,Math.log(x)};
    }

    @Override
    protected boolean logY() {return false;}
}

Und Sie können es verwenden, wie diese:

public static void main(String[] args) {
    TrendLine t = new PolyTrendLine(2);
    Random rand = new Random();
    double[] x = new double[1000*1000];
    double[] err = new double[x.length];
    double[] y = new double[x.length];
    for (int i=0; i<x.length; i++) { x[i] = 1000*rand.nextDouble(); }
    for (int i=0; i<x.length; i++) { err[i] = 100*rand.nextGaussian(); } 
    for (int i=0; i<x.length; i++) { y[i] = x[i]*x[i]+err[i]; } //quadratic model
    t.setValues(y,x);
    System.out.println(t.predict(12)); //when x=12, y should be... , eg 143.61380202745192
}

Da Sie nur wollten Trendlinien, verwarf ich den ols-Modellen, wenn ich fertig war mit Ihnen, aber möchten Sie vielleicht einige Daten über die Güte der Anpassung, etc.

Für Implementierungen mit gleitender Mittelwert, gleitender median, etc, wie es aussieht, können Sie kleben mit den commons math. Versuchen DescriptiveStatistics und geben Sie sich ein Fenster. Möchten Sie vielleicht tun einige Glättung durch interpolation wie bereits in einer anderen Antwort.

InformationsquelleAutor maybeWeCouldStealAVan

Zusätzlich zu dem, was maybeWeCouldStealAVa sagte;

Commons-math3-Bibliothek ist auch verfügbar in der maven-repository.

Aktuelle version ist 3.2 und die dependency-tag:

    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-math3</artifactId>
        <version>3.2</version>
    </dependency>

InformationsquelleAutor Martin Åberg