Calculer les paramètres de régression linéaire en C

Introduction

Dans ce labo (LabEx), vous allez apprendre à calculer les paramètres de la régression linéaire, y compris la pente (m) et l'ordonnée à l'origine (b), en utilisant le langage de programmation C. Le labo couvre le processus étape par étape de lecture des points de données (x,y), du calcul de la pente et de l'ordonnée à l'origine, et de l'impression de l'équation de régression linéaire au format y = mx + b. Ce labo offre une approche pratique pour l'analyse et la modélisation de données statistiques en utilisant le langage C, un langage de programmation très utilisé.

Lecture des points de données (x,y)

Dans cette étape, vous allez apprendre à lire les points de données (x,y) pour une analyse de régression linéaire en C. Nous allons créer un programme qui permet d'entrer plusieurs points de données et de les stocker pour des calculs ultérieurs.

Tout d'abord, créons un fichier C pour implémenter la lecture des points de données :

cd ~/project
nano linear_regression.c

Maintenant, ajoutez le code suivant au fichier :

#include <stdio.h>
#define MAX_POINTS 100

typedef struct {
    double x;
    double y;
} DataPoint;

int main() {
    DataPoint points[MAX_POINTS];
    int num_points = 0;

    printf("Enter x and y coordinates (enter -1 -1 to finish):\n");

    while (num_points < MAX_POINTS) {
        double x, y;
        scanf("%lf %lf", &x, &y);

        if (x == -1 && y == -1) {
            break;
        }

        points[num_points].x = x;
        points[num_points].y = y;
        num_points++;
    }

    printf("\nData Points Entered:\n");
    for (int i = 0; i < num_points; i++) {
        printf("Point %d: (%.2f, %.2f)\n", i+1, points[i].x, points[i].y);
    }

    return 0;
}

Compilez le programme :

gcc -o linear_regression linear_regression.c

Exécutez le programme et entrez quelques points de données d'exemple :

./linear_regression

Exemple de sortie :

Enter x and y coordinates (enter -1 -1 to finish):
1 2
2 4
3 5
4 4
5 5
-1 -1

Data Points Entered:
Point 1: (1.00, 2.00)
Point 2: (2.00, 4.00)
Point 3: (3.00, 5.00)
Point 4: (4.00, 4.00)
Point 5: (5.00, 5.00)

Décortiquons les éléments clés de ce code :

1. Nous définissons une structure DataPoint pour stocker les coordonnées x et y.
2. MAX_POINTS limite le nombre de points de données pour éviter le dépassement de capacité (overflow).
3. Le programme utilise une boucle while pour lire les coordonnées.
4. Les utilisateurs peuvent entrer des points de données et terminer l'entrée en entrant -1 -1.
5. Le programme affiche tous les points de données entrés pour vérification.

Calcul de la pente (m) et de l'ordonnée à l'origine (b)

Dans cette étape, vous allez apprendre à calculer la pente (m) et l'ordonnée à l'origine (b) pour la régression linéaire en utilisant la méthode des moindres carrés.

Tout d'abord, mettez à jour le fichier linear_regression.c précédent :

cd ~/project
nano linear_regression.c

Remplacez le code précédent par l'implémentation suivante :

#include <stdio.h>
#include <math.h>
#define MAX_POINTS 100

typedef struct {
    double x;
    double y;
} DataPoint;

// Function to compute linear regression parameters
void computeLinearRegression(DataPoint points[], int num_points, double *m, double *b) {
    double sum_x = 0, sum_y = 0, sum_xy = 0, sum_x_squared = 0;

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

    double n = num_points;

    // Compute slope (m)
    *m = (n * sum_xy - sum_x * sum_y) / (n * sum_x_squared - sum_x * sum_x);

    // Compute y-intercept (b)
    *b = (sum_y - (*m) * sum_x) / n;
}

int main() {
    DataPoint points[MAX_POINTS];
    int num_points = 0;

    printf("Enter x and y coordinates (enter -1 -1 to finish):\n");

    while (num_points < MAX_POINTS) {
        double x, y;
        scanf("%lf %lf", &x, &y);

        if (x == -1 && y == -1) {
            break;
        }

        points[num_points].x = x;
        points[num_points].y = y;
        num_points++;
    }

    double slope, intercept;
    computeLinearRegression(points, num_points, &slope, &intercept);

    printf("\nLinear Regression Results:\n");
    printf("Number of points: %d\n", num_points);
    printf("Slope (m): %.4f\n", slope);
    printf("Y-Intercept (b): %.4f\n", intercept);
    printf("Equation: y = %.4fx + %.4f\n", slope, intercept);

    return 0;
}

Compilez le programme avec la bibliothèque mathématique :

gcc -o linear_regression linear_regression.c -lm

Exécutez le programme avec des points de données d'exemple :

./linear_regression

Exemple de sortie :

Enter x and y coordinates (enter -1 -1 to finish):
1 2
2 4
3 5
4 4
5 5
-1 -1

Linear Regression Results:
Number of points: 5
Slope (m): 0.6000
Y-Intercept (b): 2.2000
Equation: y = 0.6000x + 2.2000

Points clés concernant le calcul de la régression linéaire :

1. Nous utilisons la méthode des moindres carrés pour calculer la pente et l'ordonnée à l'origine.
2. La formule pour la pente est : m = (n _ Σ(xy) - Σx _ Σy) / (n * Σ(x²) - (Σx)²)
3. La formule pour l'ordonnée à l'origine est : b = (Σy - m * Σx) / n
4. La fonction computeLinearRegression() calcule ces paramètres.
5. La fonction principale affiche l'équation de régression.

Afficher y = mx + b

Dans cette étape, vous allez apprendre à afficher l'équation de régression linéaire et à prédire les valeurs de y en utilisant la pente et l'ordonnée à l'origine calculées.

Mettez à jour le fichier linear_regression.c pour ajouter la fonctionnalité de prédiction :

cd ~/project
nano linear_regression.c

Remplacez le code précédent par l'implémentation suivante :

#include <stdio.h>
#include <math.h>
#define MAX_POINTS 100

typedef struct {
    double x;
    double y;
} DataPoint;

void computeLinearRegression(DataPoint points[], int num_points, double *m, double *b) {
    double sum_x = 0, sum_y = 0, sum_xy = 0, sum_x_squared = 0;

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

    double n = num_points;

    *m = (n * sum_xy - sum_x * sum_y) / (n * sum_x_squared - sum_x * sum_x);
    *b = (sum_y - (*m) * sum_x) / n;
}

// Function to predict y value
double predictY(double m, double b, double x) {
    return m * x + b;
}

int main() {
    DataPoint points[MAX_POINTS];
    int num_points = 0;

    printf("Enter x and y coordinates (enter -1 -1 to finish):\n");

    while (num_points < MAX_POINTS) {
        double x, y;
        scanf("%lf %lf", &x, &y);

        if (x == -1 && y == -1) {
            break;
        }

        points[num_points].x = x;
        points[num_points].y = y;
        num_points++;
    }

    double slope, intercept;
    computeLinearRegression(points, num_points, &slope, &intercept);

    printf("\nLinear Regression Equation:\n");
    printf("y = %.4fx + %.4f\n", slope, intercept);

    // Print prediction for sample x values
    printf("\nPredicted y values:\n");
    double test_x_values[] = {0, 2.5, 6, 10};
    for (int i = 0; i < 4; i++) {
        double predicted_y = predictY(slope, intercept, test_x_values[i]);
        printf("When x = %.2f, y = %.4f\n", test_x_values[i], predicted_y);
    }

    return 0;
}

Compilez le programme :

gcc -o linear_regression linear_regression.c -lm

Exécutez le programme avec des points de données d'exemple :

./linear_regression

Exemple de sortie :

Enter x and y coordinates (enter -1 -1 to finish):
1 2
2 4
3 5
4 4
5 5
-1 -1

Linear Regression Equation:
y = 0.6000x + 2.2000

Predicted y values:
When x = 0.00, y = 2.2000
When x = 2.50, y = 3.7000
When x = 6.00, y = 5.8000
When x = 10.00, y = 8.2000

Points clés concernant l'affichage de l'équation de régression :

1. Nous avons ajouté une fonction predictY() pour calculer y pour tout x donné.
2. La fonction principale affiche l'équation complète : y = mx + b.
3. Nous démontrons la prédiction en montrant les valeurs de y pour différentes entrées de x.
4. La sortie fournit une visualisation claire du modèle de régression linéaire.

Résumé

Dans ce labo (LabEx), vous avez appris à lire les points de données (x,y) pour une analyse de régression linéaire en C. Vous avez créé un programme qui permet d'entrer plusieurs points de données et de les stocker pour des calculs ultérieurs. Vous avez également appris à afficher les points de données entrés pour vérification.

Ensuite, vous allez apprendre à calculer la pente (m) et l'ordonnée à l'origine (b) de la droite de régression linéaire, puis à afficher l'équation sous la forme y = mx + b.