Bestimmtheitsmaß (R²) in C berechnen – Anleitung

Einführung

In diesem Labor lernen wir, wie man den Bestimmtheitsmaß (R²) in C berechnet. Das Labor umfasst die folgenden Schritte:

Zuerst berechnen wir die vorhergesagten y-Werte mithilfe der linearen Regression. Wir erstellen ein Programm, das die vorhergesagten Werte basierend auf einem einfachen linearen Regressionsmodell berechnet. Anschließend berechnen wir den R²-Wert mithilfe der erklärten und totalen Variationen. Schließlich geben wir den R²-Wert aus.

Dieses Labor bietet einen praktischen Ansatz, um das Konzept des Bestimmtheitsmaßes und seine Implementierung in der C-Programmierung zu verstehen, was eine wertvolle Fähigkeit für die statistische Datenanalyse ist.

Vorhergesagte y-Werte mit Regression berechnen

In diesem Schritt lernen wir, wie man vorhergesagte y-Werte mithilfe der linearen Regression in C berechnet. Wir erstellen ein Programm, das die vorhergesagten Werte basierend auf einem einfachen linearen Regressionsmodell berechnet.

Erstellen wir zunächst eine C-Datei für unsere Regressionsberechnung:

cd ~/project
nano regression_prediction.c

Geben Sie nun folgenden Code ein:

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

// Funktion zur Berechnung der vorhergesagten y-Werte
void computePredictedY(double *x, double *y, int n, double slope, double intercept, double *predicted_y) {
    for (int i = 0; i < n; i++) {
        predicted_y[i] = slope * x[i] + intercept;
    }
}

int main() {
    // Beispiel-Datenpunkte
    double x[] = {1.0, 2.0, 3.0, 4.0, 5.0};
    double y[] = {2.0, 4.0, 5.0, 4.0, 5.0};
    int n = sizeof(x) / sizeof(x[0]);

    // Vordefinierte Steigung und Achsenabschnitt (zur Demonstration)
    double slope = 0.6;
    double intercept = 1.5;

    // Array zum Speichern der vorhergesagten y-Werte
    double predicted_y[n];

    // Berechnung der vorhergesagten y-Werte
    computePredictedY(x, y, n, slope, intercept, predicted_y);

    // Ausgabe der ursprünglichen und vorhergesagten y-Werte
    printf("Ursprüngliche vs. vorhergesagte Y-Werte:\n");
    for (int i = 0; i < n; i++) {
        printf("X: %.1f, Ursprünglicher Y: %.1f, Vorhergesagter Y: %.1f\n",
               x[i], y[i], predicted_y[i]);
    }

    return 0;
}

Kompilieren Sie das Programm:

gcc -o regression_prediction regression_prediction.c -lm

Führen Sie das Programm aus:

./regression_prediction

Beispielausgabe:

Ursprüngliche vs. vorhergesagte Y-Werte:
X: 1.0, Ursprünglicher Y: 2.0, Vorhergesagter Y: 2.1
X: 2.0, Ursprünglicher Y: 4.0, Vorhergesagter Y: 2.7
X: 3.0, Ursprünglicher Y: 5.0, Vorhergesagter Y: 3.3
X: 4.0, Ursprünglicher Y: 4.0, Vorhergesagter Y: 3.9
X: 5.0, Ursprünglicher Y: 5.0, Vorhergesagter Y: 4.5

Lassen Sie uns die wichtigsten Komponenten dieses Codes aufschlüsseln:

Die Funktion computePredictedY() berechnet vorhergesagte y-Werte anhand der linearen Regressionsgleichung: y = mx + b
Wir verwenden eine vordefinierte Steigung (0,6) und einen Achsenabschnitt (1,5) zur Demonstration.
Das Programm gibt sowohl die ursprünglichen als auch die vorhergesagten y-Werte zur Vergleichbarkeit aus.

R² mit Erklärter/Gesamtvariation berechnen

In diesem Schritt erweitern wir unser vorheriges Regressionsprogramm, um das Bestimmtheitsmaß (R²) zu berechnen, welches misst, wie gut das Regressionsmodell zu den Daten passt.

Ändern wir zunächst unsere bestehende C-Datei:

cd ~/project
nano r_squared_calculation.c

Geben Sie folgenden umfassenden Code ein:

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

// Funktion zur Berechnung des Mittelwerts eines Arrays
double calculateMean(double *arr, int n) {
    double sum = 0.0;
    for (int i = 0; i < n; i++) {
        sum += arr[i];
    }
    return sum / n;
}

// Funktion zur Berechnung von R-Quadrat
double computeRSquared(double *x, double *y, int n, double slope, double intercept) {
    // Berechnung der vorhergesagten y-Werte
    double predicted_y[n];
    double total_variation = 0.0;
    double explained_variation = 0.0;

    // Berechnung des Mittelwerts der tatsächlichen y-Werte
    double y_mean = calculateMean(y, n);

    // Berechnung der Variationen
    for (int i = 0; i < n; i++) {
        // Vorhergesagter y-Wert
        predicted_y[i] = slope * x[i] + intercept;

        // Gesamtvariation (Abstand vom Mittelwert)
        total_variation += pow(y[i] - y_mean, 2);

        // Erklärte Variation (Abstand vom vorhergesagten Wert)
        explained_variation += pow(y[i] - predicted_y[i], 2);
    }

    // Berechnung von R-Quadrat
    return 1 - (explained_variation / total_variation);
}

int main() {
    // Beispiel-Datenpunkte
    double x[] = {1.0, 2.0, 3.0, 4.0, 5.0};
    double y[] = {2.0, 4.0, 5.0, 4.0, 5.0};
    int n = sizeof(x) / sizeof(x[0]);

    // Vordefinierte Steigung und Achsenabschnitt (zur Demonstration)
    double slope = 0.6;
    double intercept = 1.5;

    // Berechnung und Ausgabe von R-Quadrat
    double r_squared = computeRSquared(x, y, n, slope, intercept);

    printf("Ergebnisse der Regressionsanalyse:\n");
    printf("Steigung: %.2f\n", slope);
    printf("Achsenabschnitt: %.2f\n", intercept);
    printf("R-Quadrat (R²): %.4f\n", r_squared);

    return 0;
}

Kompilieren Sie das Programm:

gcc -o r_squared_calculation r_squared_calculation.c -lm

Führen Sie das Programm aus:

./r_squared_calculation

Beispielausgabe:

Ergebnisse der Regressionsanalyse:
Steigung: 0.60
Achsenabschnitt: 1.50
R-Quadrat (R²): 0.5600

Wichtige Komponenten der R²-Berechnung:

calculateMean() berechnet den Durchschnitt eines Arrays.
computeRSquared() berechnet R² nach der Formel: 1 - (Erklärte Variation / Gesamtvariation).
Die Gesamtvariation misst die Streuung der tatsächlichen y-Werte um ihren Mittelwert.
Die Erklärte Variation misst die Streuung der vorhergesagten Werte von den tatsächlichen Werten.
R² liegt zwischen 0 und 1, wobei höhere Werte auf eine bessere Anpassung des Modells hinweisen.

R²-Wert ausgeben

In diesem letzten Schritt erstellen wir ein umfassendes Programm, das Daten aus einer Datei liest, die Regressionsparameter berechnet und den R²-Wert mit detaillierter Interpretation ausgibt.

Erstellen Sie zunächst eine Beispiel-Datendatei:

cd ~/project
nano regression_data.txt

Fügen Sie die Beispiel-Regressionsdaten hinzu:

1.0 2.0
2.0 4.0
3.0 5.0
4.0 4.0
5.0 5.0

Erstellen Sie nun das endgültige Programm zur R²-Berechnung:

nano r_squared_print.c

Geben Sie folgenden Code ein:

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

// Funktion zur Berechnung der linearen Regressionsparameter
void calculateRegressionParameters(double *x, double *y, int n,
                                   double *slope, double *intercept) {
    double sum_x = 0, sum_y = 0, sum_xy = 0, sum_x_squared = 0;

    for (int i = 0; i < n; i++) {
        sum_x += x[i];
        sum_y += y[i];
        sum_xy += x[i] * y[i];
        sum_x_squared += x[i] * x[i];
    }

    // Berechnung von Steigung und Achsenabschnitt mit der Methode der kleinsten Quadrate
    *slope = (n * sum_xy - sum_x * sum_y) / (n * sum_x_squared - sum_x * sum_x);
    *intercept = (sum_y - *slope * sum_x) / n;
}

// Funktion zur Berechnung von R-Quadrat
double computeRSquared(double *x, double *y, int n, double slope, double intercept) {
    double total_variation = 0.0;
    double explained_variation = 0.0;
    double y_mean = 0.0;

    // Berechnung des Mittelwerts von y
    for (int i = 0; i < n; i++) {
        y_mean += y[i];
    }
    y_mean /= n;

    // Berechnung der Variationen
    for (int i = 0; i < n; i++) {
        total_variation += pow(y[i] - y_mean, 2);
        double predicted_y = slope * x[i] + intercept;
        explained_variation += pow(y[i] - predicted_y, 2);
    }

    // Berechnung von R-Quadrat
    return 1 - (explained_variation / total_variation);
}

// Funktion zur Interpretation des R-Quadrat-Wertes
void interpretRSquared(double r_squared) {
    printf("\nInterpretation von R²:\n");
    if (r_squared < 0.3) {
        printf("Schwache Modellanpassung: Das Modell erklärt weniger als 30%% der Varianz.\n");
    } else if (r_squared < 0.5) {
        printf("Mäßige Modellanpassung: Das Modell erklärt 30-50%% der Varianz.\n");
    } else if (r_squared < 0.7) {
        printf("Gute Modellanpassung: Das Modell erklärt 50-70%% der Varianz.\n");
    } else {
        printf("Ausgezeichnete Modellanpassung: Das Modell erklärt über 70%% der Varianz.\n");
    }
}

int main() {
    FILE *file;
    int n = 0, max_lines = 100;
    double x[100], y[100];
    double slope, intercept, r_squared;

    // Öffnen der Datendatei
    file = fopen("regression_data.txt", "r");
    if (file == NULL) {
        printf("Fehler beim Öffnen der Datei!\n");
        return 1;
    }

    // Lesen der Daten aus der Datei
    while (fscanf(file, "%lf %lf", &x[n], &y[n]) == 2) {
        n++;
        if (n >= max_lines) break;
    }
    fclose(file);

    // Berechnung der Regressionsparameter
    calculateRegressionParameters(x, y, n, &slope, &intercept);

    // Berechnung von R-Quadrat
    r_squared = computeRSquared(x, y, n, slope, intercept);

    // Ausgabe der Ergebnisse
    printf("Ergebnisse der Regressionsanalyse:\n");
    printf("Anzahl der Datenpunkte: %d\n", n);
    printf("Steigung: %.4f\n", slope);
    printf("Achsenabschnitt: %.4f\n", intercept);
    printf("R-Quadrat (R²): %.4f\n", r_squared);

    // Interpretation von R-Quadrat
    interpretRSquared(r_squared);

    return 0;
}

Kompilieren Sie das Programm:

gcc -o r_squared_print r_squared_print.c -lm

Führen Sie das Programm aus:

./r_squared_print

Beispielausgabe:

Ergebnisse der Regressionsanalyse:
Anzahl der Datenpunkte: 5
Steigung: 0.6000
Achsenabschnitt: 1.5000
R-Quadrat (R²): 0.5600

Interpretation von R²:
Gute Modellanpassung: Das Modell erklärt 50-70% der Varianz.

Wichtige Punkte:

Liest Daten aus einer externen Datei.
Berechnet Regressionsparameter mit der Methode der kleinsten Quadrate.
Berechnet den R²-Wert.
Bietet eine Interpretation des R²-Wertes.
Hilft, die Vorhersagekraft des Modells zu verstehen.

Zusammenfassung

In diesem Labor haben wir gelernt, wie man die vorhergesagten y-Werte mithilfe eines einfachen linearen Regressionsmodells in C berechnet. Wir haben ein Programm erstellt, das die x- und y-Datenpunkte sowie die Steigung und den Achsenabschnitt der Regressionsgeraden entgegennimmt und anschließend die vorhergesagten y-Werte berechnet. Die wichtigsten Schritte umfassten die Berechnung der vorhergesagten y-Werte basierend auf der Regressionsgleichung und die anschließende Ausgabe der ursprünglichen und vorhergesagten y-Werte zum Vergleich.

Als Nächstes werden wir lernen, wie man den Bestimmtheitskoeffizienten (R²) mithilfe der erklärten und Gesamtvariation der Daten berechnet.

Berechnung des Bestimmtheitsmaßes (R²) in C

Einführung

Vorhergesagte y-Werte mit Regression berechnen

R² mit Erklärter/Gesamtvariation berechnen

R²-Wert ausgeben

Zusammenfassung