Calcul du Coefficient de Détermination (R²) en C

CBeginner
Pratiquer maintenant

Introduction

Dans ce laboratoire, nous apprendrons à calculer le Coefficient de Détermination (R²) en C. Le laboratoire couvre les étapes suivantes :

Tout d'abord, nous calculerons les valeurs prédites de y à l'aide de la régression linéaire. Nous créerons un programme qui calculera les valeurs prédites basées sur un modèle de régression linéaire simple. Ensuite, nous calculerons la valeur de R² en utilisant les variations expliquée et totale. Enfin, nous afficherons la valeur de R².

Ce laboratoire propose une approche pratique pour comprendre le concept du Coefficient de Détermination et sa mise en œuvre en programmation C, une compétence précieuse pour l'analyse statistique des données.

Calcul des valeurs prédites de y à l'aide de la régression

Dans cette étape, nous apprendrons à calculer les valeurs prédites de y à l'aide de la régression linéaire en C. Nous créerons un programme qui calculera les valeurs prédites basées sur un modèle de régression linéaire simple.

Tout d'abord, créons un fichier C pour nos calculs de régression :

cd ~/project
nano regression_prediction.c

Maintenant, saisissez le code suivant :

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

// Fonction pour calculer les valeurs prédites de y
void computePredictedY(double *x, double *y, int n, double pente, double ordonnee_a_lorigine, double *predicted_y) {
    for (int i = 0; i < n; i++) {
        predicted_y[i] = pente * x[i] + ordonnee_a_lorigine;
    }
}

int main() {
    // Points de données d'exemple
    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]);

    // Pente et ordonnée à l'origine prédéfinies (à des fins de démonstration)
    double pente = 0.6;
    double ordonnee_a_lorigine = 1.5;

    // Tableau pour stocker les valeurs prédites de y
    double predicted_y[n];

    // Calcul des valeurs prédites de y
    computePredictedY(x, y, n, pente, ordonnee_a_lorigine, predicted_y);

    // Affichage des valeurs y originales et prédites
    printf("Valeurs Y originales vs prédites :\n");
    for (int i = 0; i < n; i++) {
        printf("X : %.1f, Y original : %.1f, Y prédit : %.1f\n",
               x[i], y[i], predicted_y[i]);
    }

    return 0;
}

Compilez le programme :

gcc -o regression_prediction regression_prediction.c -lm

Exécutez le programme :

./regression_prediction

Sortie d'exemple :

Valeurs Y originales vs prédites :
X : 1.0, Y original : 2.0, Y prédit : 2.1
X : 2.0, Y original : 4.0, Y prédit : 2.7
X : 3.0, Y original : 5.0, Y prédit : 3.3
X : 4.0, Y original : 4.0, Y prédit : 3.9
X : 5.0, Y original : 5.0, Y prédit : 4.5

Décomposons les composants clés de ce code :

  1. La fonction computePredictedY() calcule les valeurs prédites de y en utilisant l'équation de régression linéaire : y = mx + b
  2. Nous utilisons une pente prédéfinie (0,6) et une ordonnée à l'origine (1,5) à des fins de démonstration.
  3. Le programme affiche les valeurs y originales et prédites pour la comparaison.

Calcul de R² à l'aide de la variation expliquée/totale

Dans cette étape, nous étendrons notre programme de régression précédent pour calculer le Coefficient de Détermination (R²), qui mesure l'ajustement du modèle de régression aux données.

Tout d'abord, modifions notre fichier C existant :

cd ~/project
nano r_squared_calculation.c

Entrez le code complet suivant :

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

// Fonction pour calculer la moyenne d'un tableau
double calculateMean(double *arr, int n) {
    double sum = 0.0;
    for (int i = 0; i < n; i++) {
        sum += arr[i];
    }
    return sum / n;
}

// Fonction pour calculer R-carré
double computeRSquared(double *x, double *y, int n, double pente, double ordonnee_a_lorigine) {
    // Calcul des valeurs y prédites
    double predicted_y[n];
    double variation_totale = 0.0;
    double variation_expliquee = 0.0;

    // Calcul de la moyenne des valeurs y réelles
    double moyenne_y = calculateMean(y, n);

    // Calcul des variations
    for (int i = 0; i < n; i++) {
        // Valeur y prédite
        predicted_y[i] = pente * x[i] + ordonnee_a_lorigine;

        // Variation totale (distance par rapport à la moyenne)
        variation_totale += pow(y[i] - moyenne_y, 2);

        // Variation expliquée (distance par rapport à la valeur prédite)
        variation_expliquee += pow(y[i] - predicted_y[i], 2);
    }

    // Calcul de R-carré
    return 1 - (variation_expliquee / variation_totale);
}

int main() {
    // Points de données d'exemple
    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]);

    // Pente et ordonnée à l'origine prédéfinies (à des fins de démonstration)
    double pente = 0.6;
    double ordonnee_a_lorigine = 1.5;

    // Calcul et affichage de R-carré
    double r_squared = computeRSquared(x, y, n, pente, ordonnee_a_lorigine);

    printf("Résultats de l'analyse de régression :\n");
    printf("Pente : %.2f\n", pente);
    printf("Ordonnée à l'origine : %.2f\n", ordonnee_a_lorigine);
    printf("R-carré (R²) : %.4f\n", r_squared);

    return 0;
}

Compilez le programme :

gcc -o r_squared_calculation r_squared_calculation.c -lm

Exécutez le programme :

./r_squared_calculation

Sortie d'exemple :

Résultats de l'analyse de régression :
Pente : 0.60
Ordonnée à l'origine : 1.50
R-carré (R²) : 0.5600

Composants clés du calcul de R² :

  1. calculateMean() calcule la moyenne d'un tableau.
  2. computeRSquared() calcule R² en utilisant la formule : 1 - (Variation expliquée / Variation totale).
  3. La Variation totale mesure la dispersion des valeurs y réelles autour de leur moyenne.
  4. La Variation expliquée mesure la dispersion des valeurs prédites par rapport aux valeurs réelles.
  5. R² varie de 0 à 1, des valeurs plus élevées indiquant un meilleur ajustement du modèle.

Affichage de la valeur de R²

Dans cette étape finale, nous créerons un programme complet qui lit les données d'un fichier, calcule les paramètres de régression et affiche la valeur de R² avec une interprétation détaillée.

Tout d'abord, créez un fichier de données d'exemple :

cd ~/project
nano regression_data.txt

Ajoutez les données de régression d'exemple :

1.0 2.0
2.0 4.0
3.0 5.0
4.0 4.0
5.0 5.0

Maintenant, créez le programme de calcul final de R² :

nano r_squared_print.c

Entrez le code suivant :

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

// Fonction pour calculer les paramètres de régression linéaire
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];
    }

    // Calcul de la pente et de l'ordonnée à l'origine en utilisant la méthode des moindres carrés
    *slope = (n * sum_xy - sum_x * sum_y) / (n * sum_x_squared - sum_x * sum_x);
    *intercept = (sum_y - *slope * sum_x) / n;
}

// Fonction pour calculer R-carré
double computeRSquared(double *x, double *y, int n, double slope, double intercept) {
    double variation_totale = 0.0;
    double variation_expliquee = 0.0;
    double moyenne_y = 0.0;

    // Calcul de la moyenne de y
    for (int i = 0; i < n; i++) {
        moyenne_y += y[i];
    }
    moyenne_y /= n;

    // Calcul des variations
    for (int i = 0; i < n; i++) {
        variation_totale += pow(y[i] - moyenne_y, 2);
        double predicted_y = slope * x[i] + intercept;
        variation_expliquee += pow(y[i] - predicted_y, 2);
    }

    // Calcul de R-carré
    return 1 - (variation_expliquee / variation_totale);
}

// Fonction pour interpréter la valeur de R-carré
void interpretRSquared(double r_squared) {
    printf("\nInterprétation de R² :\n");
    if (r_squared < 0.3) {
        printf("Modèle faiblement ajusté : le modèle explique moins de 30 % de la variance.\n");
    } else if (r_squared < 0.5) {
        printf("Modèle modérément ajusté : le modèle explique 30 à 50 % de la variance.\n");
    } else if (r_squared < 0.7) {
        printf("Bon ajustement du modèle : le modèle explique 50 à 70 % de la variance.\n");
    } else {
        printf("Excellent ajustement du modèle : le modèle explique plus de 70 % de la variance.\n");
    }
}

int main() {
    FILE *file;
    int n = 0, max_lignes = 100;
    double x[100], y[100];
    double pente, ordonnee_a_lorigine, r_squared;

    // Ouverture du fichier de données
    file = fopen("regression_data.txt", "r");
    if (file == NULL) {
        printf("Erreur lors de l'ouverture du fichier !\n");
        return 1;
    }

    // Lecture des données du fichier
    while (fscanf(file, "%lf %lf", &x[n], &y[n]) == 2) {
        n++;
        if (n >= max_lignes) break;
    }
    fclose(file);

    // Calcul des paramètres de régression
    calculateRegressionParameters(x, y, n, &pente, &ordonnee_a_lorigine);

    // Calcul de R-carré
    r_squared = computeRSquared(x, y, n, pente, ordonnee_a_lorigine);

    // Affichage des résultats
    printf("Résultats de l'analyse de régression :\n");
    printf("Nombre de points de données : %d\n", n);
    printf("Pente : %.4f\n", pente);
    printf("Ordonnée à l'origine : %.4f\n", ordonnee_a_lorigine);
    printf("R-carré (R²) : %.4f\n", r_squared);

    // Interprétation de R-carré
    interpretRSquared(r_squared);

    return 0;
}

Compilez le programme :

gcc -o r_squared_print r_squared_print.c -lm

Exécutez le programme :

./r_squared_print

Sortie d'exemple :

Résultats de l'analyse de régression :
Nombre de points de données : 5
Pente : 0.6000
Ordonnée à l'origine : 1.5000
R-carré (R²) : 0.5600

Interprétation de R² :
Bon ajustement du modèle : le modèle explique 50 à 70 % de la variance.

Points clés :

  1. Lit les données d'un fichier externe.
  2. Calcule les paramètres de régression à l'aide de la méthode des moindres carrés.
  3. Calcule la valeur de R².
  4. Fournit une interprétation de la valeur de R².
  5. Aide à comprendre le pouvoir prédictif du modèle.

Résumé

Dans ce laboratoire, nous avons appris à calculer les valeurs prédites de y à l'aide d'un modèle de régression linéaire simple en C. Nous avons créé un programme qui prend en entrée les points de données x et y, ainsi que la pente et l'ordonnée à l'origine de la droite de régression, puis calcule les valeurs prédites de y. Les étapes clés impliquaient le calcul des valeurs prédites de y en fonction de l'équation de régression, puis l'impression des valeurs y originales et prédites pour comparaison.

Ensuite, nous apprendrons à calculer le coefficient de détermination (R²) en utilisant la variation expliquée et la variation totale des données.