Calcular el Coeficiente de Determinación (R²) en C

CBeginner
Practicar Ahora

Introducción

En este laboratorio, aprenderemos a calcular el Coeficiente de Determinación (R²) en C. El laboratorio cubre los siguientes pasos:

Primero, calcularemos los valores predichos de y utilizando regresión lineal. Crearemos un programa que calcule los valores predichos basados en un modelo de regresión lineal simple. Luego, calcularemos el valor de R² utilizando las variaciones explicada y total. Finalmente, imprimiremos el valor de R².

Este laboratorio proporciona un enfoque práctico para comprender el concepto del Coeficiente de Determinación y su implementación en programación C, una habilidad valiosa para el análisis estadístico de datos.

Calcular y Predicho Usando Regresión Lineal

En este paso, aprenderemos a calcular los valores de y predichos utilizando regresión lineal en C. Crearemos un programa que calcule los valores predichos basados en un modelo de regresión lineal simple.

Primero, creemos un archivo C para nuestro cálculo de regresión:

cd ~/project
nano regression_prediction.c

Ahora, ingrese el siguiente código:

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

// Función para calcular los valores de y predichos
void computePredictedY(double *x, double *y, int n, double pendiente, double intercepto, double *predicted_y) {
    for (int i = 0; i < n; i++) {
        predicted_y[i] = pendiente * x[i] + intercepto;
    }
}

int main() {
    // Puntos de datos de muestra
    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]);

    // Pendiente e intercepto predefinidos (para demostración)
    double pendiente = 0.6;
    double intercepto = 1.5;

    // Arreglo para almacenar los valores de y predichos
    double predicted_y[n];

    // Calcular los valores de y predichos
    computePredictedY(x, y, n, pendiente, intercepto, predicted_y);

    // Imprimir los valores de y originales y predichos
    printf("Valores de Y Original vs Predichos:\n");
    for (int i = 0; i < n; i++) {
        printf("X: %.1f, Y Original: %.1f, Y Predicho: %.1f\n",
               x[i], y[i], predicted_y[i]);
    }

    return 0;
}

Compile el programa:

gcc -o regression_prediction regression_prediction.c -lm

Ejecuta el programa:

./regression_prediction

Salida de ejemplo:

Valores de Y Original vs Predichos:
X: 1.0, Y Original: 2.0, Y Predicho: 2.1
X: 2.0, Y Original: 4.0, Y Predicho: 2.7
X: 3.0, Y Original: 5.0, Y Predicho: 3.3
X: 4.0, Y Original: 4.0, Y Predicho: 3.9
X: 5.0, Y Original: 5.0, Y Predicho: 4.5

Desglose de los componentes clave de este código:

  1. La función computePredictedY() calcula los valores de y predichos utilizando la ecuación de regresión lineal: y = mx + b
  2. Usamos una pendiente predefinida (0.6) e intercepto (1.5) para la demostración
  3. El programa imprime los valores de y originales y predichos para la comparación

Calcular R² Usando la Variación Explicada/Total

En este paso, ampliaremos nuestro programa de regresión anterior para calcular el Coeficiente de Determinación (R²), que mide qué tan bien se ajusta el modelo de regresión a los datos.

Primero, modifiquemos nuestro archivo C existente:

cd ~/project
nano r_squared_calculation.c

Ingrese el siguiente código completo:

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

// Función para calcular la media de un arreglo
double calculateMean(double *arr, int n) {
    double sum = 0.0;
    for (int i = 0; i < n; i++) {
        sum += arr[i];
    }
    return sum / n;
}

// Función para calcular R-cuadrado
double computeRSquared(double *x, double *y, int n, double pendiente, double intercepto) {
    // Calcular los valores de y predichos
    double predicted_y[n];
    double variacion_total = 0.0;
    double variacion_explicada = 0.0;

    // Calcular la media de los valores de y reales
    double media_y = calculateMean(y, n);

    // Calcular las variaciones
    for (int i = 0; i < n; i++) {
        // Valor de y predicho
        predicted_y[i] = pendiente * x[i] + intercepto;

        // Variación total (distancia de la media)
        variacion_total += pow(y[i] - media_y, 2);

        // Variación explicada (distancia de los valores predichos a los reales)
        variacion_explicada += pow(y[i] - predicted_y[i], 2);
    }

    // Calcular R-cuadrado
    return 1 - (variacion_explicada / variacion_total);
}

int main() {
    // Puntos de datos de muestra
    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]);

    // Pendiente e intercepto predefinidos (para demostración)
    double pendiente = 0.6;
    double intercepto = 1.5;

    // Calcular e imprimir R-cuadrado
    double r_squared = computeRSquared(x, y, n, pendiente, intercepto);

    printf("Resultados del Análisis de Regresión:\n");
    printf("Pendiente: %.2f\n", pendiente);
    printf("Intercepto: %.2f\n", intercepto);
    printf("R-cuadrado (R²): %.4f\n", r_squared);

    return 0;
}

Compile el programa:

gcc -o r_squared_calculation r_squared_calculation.c -lm

Ejecuta el programa:

./r_squared_calculation

Salida de ejemplo:

Resultados del Análisis de Regresión:
Pendiente: 0.60
Intercepto: 1.50
R-cuadrado (R²): 0.5600

Componentes clave del cálculo de R²:

  1. calculateMean() calcula el promedio de un arreglo.
  2. computeRSquared() calcula R² usando la fórmula: 1 - (Variación Explicada / Variación Total).
  3. La Variación Total mide la dispersión de los valores de y reales alrededor de su media.
  4. La Variación Explicada mide la dispersión de los valores predichos respecto a los valores reales.
  5. R² varía de 0 a 1, con valores más altos indicando un mejor ajuste del modelo.

Imprimir el Valor de R²

En este paso final, crearemos un programa completo que lee datos de un archivo, calcula los parámetros de regresión e imprime el valor de R² con una interpretación detallada.

Primero, crea un archivo de datos de muestra:

cd ~/project
nano regression_data.txt

Agrega datos de regresión de muestra:

1.0 2.0
2.0 4.0
3.0 5.0
4.0 4.0
5.0 5.0

Ahora, crea el programa final para calcular R²:

nano r_squared_print.c

Ingrese el siguiente código:

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

// Función para calcular los parámetros de regresión lineal
void calculateRegressionParameters(double *x, double *y, int n,
                                   double *pendiente, double *intercepto) {
    double suma_x = 0, suma_y = 0, suma_xy = 0, suma_x_cuadrado = 0;

    for (int i = 0; i < n; i++) {
        suma_x += x[i];
        suma_y += y[i];
        suma_xy += x[i] * y[i];
        suma_x_cuadrado += x[i] * x[i];
    }

    // Calcular la pendiente y el intercepto usando el método de mínimos cuadrados
    *pendiente = (n * suma_xy - suma_x * suma_y) / (n * suma_x_cuadrado - suma_x * suma_x);
    *intercepto = (suma_y - *pendiente * suma_x) / n;
}

// Función para calcular R-cuadrado
double computeRSquared(double *x, double *y, int n, double pendiente, double intercepto) {
    double variacion_total = 0.0;
    double variacion_explicada = 0.0;
    double media_y = 0.0;

    // Calcular la media de y
    for (int i = 0; i < n; i++) {
        media_y += y[i];
    }
    media_y /= n;

    // Calcular las variaciones
    for (int i = 0; i < n; i++) {
        variacion_total += pow(y[i] - media_y, 2);
        double y_predicha = pendiente * x[i] + intercepto;
        variacion_explicada += pow(y[i] - y_predicha, 2);
    }

    // Calcular R-cuadrado
    return 1 - (variacion_explicada / variacion_total);
}

// Función para interpretar el valor de R-cuadrado
void interpretRSquared(double r_squared) {
    printf("\nInterpretación de R²:\n");
    if (r_squared < 0.3) {
        printf("Ajuste del modelo débil: El modelo explica menos del 30%% de la varianza.\n");
    } else if (r_squared < 0.5) {
        printf("Ajuste del modelo moderado: El modelo explica entre el 30-50%% de la varianza.\n");
    } else if (r_squared < 0.7) {
        printf("Buen ajuste del modelo: El modelo explica entre el 50-70%% de la varianza.\n");
    } else {
        printf("Excelente ajuste del modelo: El modelo explica más del 70%% de la varianza.\n");
    }
}

int main() {
    FILE *archivo;
    int n = 0, max_lineas = 100;
    double x[100], y[100];
    double pendiente, intercepto, r_cuadrado;

    // Abrir el archivo de datos
    archivo = fopen("regression_data.txt", "r");
    if (archivo == NULL) {
        printf("Error al abrir el archivo!\n");
        return 1;
    }

    // Leer datos del archivo
    while (fscanf(archivo, "%lf %lf", &x[n], &y[n]) == 2) {
        n++;
        if (n >= max_lineas) break;
    }
    fclose(archivo);

    // Calcular los parámetros de regresión
    calculateRegressionParameters(x, y, n, &pendiente, &intercepto);

    // Calcular R-cuadrado
    r_cuadrado = computeRSquared(x, y, n, pendiente, intercepto);

    // Imprimir resultados
    printf("Resultados del Análisis de Regresión:\n");
    printf("Número de Puntos de Datos: %d\n", n);
    printf("Pendiente: %.4f\n", pendiente);
    printf("Intercepto: %.4f\n", intercepto);
    printf("R-cuadrado (R²): %.4f\n", r_cuadrado);

    // Interpretar R-cuadrado
    interpretRSquared(r_cuadrado);

    return 0;
}

Compila el programa:

gcc -o r_squared_print r_squared_print.c -lm

Ejecuta el programa:

./r_squared_print

Salida de ejemplo:

Resultados del Análisis de Regresión:
Número de Puntos de Datos: 5
Pendiente: 0.6000
Intercepto: 1.5000
R-cuadrado (R²): 0.5600

Interpretación de R²:
Buen ajuste del modelo: El modelo explica entre el 50-70% de la varianza.

Puntos clave:

  1. Lee datos de un archivo externo.
  2. Calcula los parámetros de regresión usando el método de mínimos cuadrados.
  3. Calcula el valor de R².
  4. Proporciona una interpretación del valor de R².
  5. Ayuda a comprender el poder predictivo del modelo.

Resumen

En este laboratorio, aprendimos a calcular los valores de y predichos utilizando un modelo de regresión lineal simple en C. Creamos un programa que toma los puntos de datos x e y, así como la pendiente y la intersección de la línea de regresión, y luego calcula los valores de y predichos. Los pasos clave incluyeron el cálculo de los valores de y predichos basados en la ecuación de regresión y luego la impresión de los valores de y originales y predichos para su comparación.

A continuación, aprenderemos a calcular el coeficiente de determinación (R²) utilizando la variación explicada y total de los datos.