Teil 2: https://www.mathelounge.de/529253/artikel-regression-berechnung-regr…
1. Einführung
Mit der Methode der kleinsten Quadrate kann man zu einer gegebenen Menge von Punkten eine Funktion finden, die möglichst nahe an den Punkten verläuft. Wir werden in diesem Artikel eine allgemeine Formel zur Berechnung einer linearen Ausgleichsfunktion y=a0+a1x für endlich viele Messwerte herleiten, welche in ein Java-Programm gegossen und für diverse Probleme, bei denen Ausgleichsrechnungen eine Rolle spielen (physikalische Experimente, statistische Untersuchungen, ...), genutzt werden kann.
2. Datenpaare
Für unseren Algorithmus definieren wir einen neuen Datentyp „Data“, der Datenpaare repräsentiert. Bei Datenpaaren handelt es sich um 2−Tupel (geordnete Paare) der Form (x,y) mit x,y∈R. x und y werden als private, unveränderliche Objektvariablen vom Typ double gespeichert und im Konstruktor zugewiesen. Mit zwei Akzessormethoden (Getter) können diese Werte aus einem Data-Objekt gelesen werden. Eine mögliche Implementierung sieht wie folgt aus:
public class Data {
// x-Wert
private final double x;
// y-Wert
private final double y;
// Konstruktor
public Data(final double x, final double y){
this.x = x;
this.y = y;
}
// Getter für den x-Wert
public double get_x(){
return this.x;
}
// Getter für den y-Wert
public double get_y(){
return this.y;
}
}
Gegeben seien n Datenpaare (x1,y1),(x2,y2),...,(xn,yn), die linear durch y=a0+a1x mit a0,a1∈R approximiert werden sollen. Gesucht ist die Lösung des linearen Gleichungssystems ATAx=ATb. Dabei ist x=(a0a1)T, b=(y1y2...yn)T und A∈Rn×2 eine Matrix, die folgende Gestalt besitzt: A=⎝⎜⎜⎜⎜⎛11⋮1x1x2⋮xn⎠⎟⎟⎟⎟⎞ Setzen wir A,AT,x und b in ATAx=ATb, so erhalten wir: ATA(1x11x2......1xn)⋅⎝⎜⎜⎜⎜⎛11⋮1x1x2⋮xn⎠⎟⎟⎟⎟⎞⋅x(a0a1)=ATb(1x11x2......1xn)⋅⎝⎜⎜⎜⎜⎛y1y2⋮yn⎠⎟⎟⎟⎟⎞ Wir berechnen ATA und erhalten: ATA=(1x11x2......1xn)⋅⎝⎜⎜⎜⎜⎛11⋮1x1x2⋮xn⎠⎟⎟⎟⎟⎞=(nx1+x2+...+xnx1+x2+...+xnx12+x22+...+xn2)=⎝⎜⎜⎜⎛nk=1∑nxkk=1∑nxkk=1∑nxk2⎠⎟⎟⎟⎞ Die Inverse (ATA)−1
der Matrix ATA, die zur Lösung des linearen Gleichungssystems genutzt wird, berechnen wir wie folgt. Sei φ : =det(ATA)−1 gegeben durch φ : =det(ATA)1=n⋅k=1∑nxk2−(k=1∑nxk)21 Dann besitzt (ATA)−1 folgende Gestalt: (ATA)−1=φ⋅⎝⎜⎜⎜⎛k=1∑nxk2−k=1∑nxk−k=1∑nxkn⎠⎟⎟⎟⎞ Nun berechnen wir ATb und erhalten: ATb=(1x11x2......1xn)⋅⎝⎜⎜⎜⎜⎛y1y2⋮yn⎠⎟⎟⎟⎟⎞=(y1+y2+...+ynx1⋅y1+x2⋅y2+...+xn⋅yn)=⎝⎜⎜⎜⎛k=1∑nykk=1∑nxk⋅yk⎠⎟⎟⎟⎞ Den Lösungsvektor x=(a0a1) erhalten wir durch beidseitige Multiplikation der Inversen von ATA, denn =In(ATA)−1⋅ATA⋅x=(ATA)−1ATb⟺x=(ATA)−1ATb Der Lösungsvektor ist also: x=(a0a1)=φ⋅⎝⎜⎜⎜⎛k=1∑nxk2−k=1∑nxk−k=1∑nxkn⎠⎟⎟⎟⎞⋅⎝⎜⎜⎜⎛k=1∑nykk=1∑nxk⋅yk⎠⎟⎟⎟⎞=φ⋅⎝⎜⎜⎜⎛(k=1∑nyk)⋅(k=1∑nxk2)−(k=1∑nxk)⋅(k=1∑nxk⋅yk)n⋅(k=1∑nxk⋅yk)−(k=1∑nxk)⋅(k=1∑nyk)⎠⎟⎟⎟⎞
Die Regressionskoeffizienten a0 und a1 der linearen Ausgleichsgerade y=a0+a1⋅x können demnach direkt durch
- a0=φ⋅((k=1∑nyk)⋅(k=1∑nxk2)−(k=1∑nxk)⋅(k=1∑nxk⋅yk))
- a1=φ⋅(n⋅(k=1∑nxk⋅yk)−(k=1∑nxk)⋅(k=1∑nyk))
berechnet werden. Diese Funktion bietet die bestmöglichste Approximation an die gegebenen Messwerte mit dem kleinsten Betrag für den Fehlervektor e nach der Methode der kleinsten Quadrate.
3. Implementierung
Wir stellen in einer beliebigen Klasse eine statische Utility-Funktion mit dem Namen „regression“, die als Argument eine Liste mit Data-Objekten erhält und die lineare Regression gemäß der des im vorangegangenen Abschnitt entwickelten Algorithmus vornimmt. Die Ergebnisparameter a0 und a1 werden in einem Array vom Typ double gespeichert und zurückgegeben.
public static double[] regression(final List<Data> data){
final double[] result = new double[2];
// Definition der Variablen für den Algorithmus
double phi = 0;
double sum_of_x_squared = 0;
double sum_of_x = 0;
double sum_of_y = 0;
double sum_of_x_times_y = 0;
double a_0 = 0;
double a_1 = 0;
final int m = data.size();
// Berechnen der Summen
for(final Data data_point : data){
sum_of_x_squared += Math.pow(data_point.get_x(), 2);
sum_of_x += data_point.get_x();
sum_of_y += data_point.get_y();
sum_of_x_times_y += (data_point.get_x() * data_point.get_y());
}
phi = 1.0/(m * sum_of_x_squared - Math.pow(sum_of_x, 2));
// Berechnen der Regressionskoeffizienten
a_0 = phi * (sum_of_y * sum_of_x_squared - sum_of_x * sum_of_x_times_y);
a_1 = phi * (m * sum_of_x_times_y - sum_of_x * sum_of_y);
// Ausgabe
System.out.println(a_0 + (a_1 == 0 ? "" : (a_1 > 0 ? "+" : ""))+a_1+"*x");
// Abspeichern der Ergebnisse
result[0] = a_0;
result[1] = a_1;
return result;
}
4. Beispiel für die schrittweise Ermittlung der Regressionsgeraden
Gegeben seien die Messwerte {(x,y)∣x,y∈R} : ={(−2,4),(−1,2),(0,1),(1,0),(2,1)}. Wir suchen die lineare Ausgleichsgerade: y=a0⋅x+a1 mit a0,a1∈R (die Form der Ausgleichsgeraden kann je nach Aufgabenstellung abweichen; beziehen Sie dies in Ihre Modellierung ein!). Mit den gegebenen Messwerten besitzt A die Form A=⎝⎜⎜⎜⎜⎜⎛−2−101211111⎠⎟⎟⎟⎟⎟⎞ bzw. AT=(−21−11011121) Zu lösen ist folgendes lineare Gleichungssystem: ATAAT⋅⎝⎜⎜⎜⎜⎜⎛−2−101211111⎠⎟⎟⎟⎟⎟⎞⋅(a0a1)=ATbAT⋅⎝⎜⎜⎜⎜⎜⎛42101⎠⎟⎟⎟⎟⎟⎞ Wir berechnen ATA: ATA=(−21−11011121)T⋅⎝⎜⎜⎜⎜⎜⎛−2−101211111⎠⎟⎟⎟⎟⎟⎞=(10005) Anschließend ermitteln wir ATb: (−21−11011121)⋅⎝⎜⎜⎜⎜⎜⎛42101⎠⎟⎟⎟⎟⎟⎞=(−88) Wir lösen also folgendes lineare Gleichungssystem: (10005)⋅(a0a1)=(−88) Die Lösung kann mittels der Inversen oder dem Gauß-Jordan-Verfahren ermittelt werden. Man erhält schlussendlich: (a0a1)=(−0.81.6) Die Gleichung der Ausgleichsgerade lautet also y=−0.8x+1.6=1.6−0.8x
Im nächsten Teil werden wir dieses Ergebnis mit unserem Programm verifizieren.
