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:
- La función
computePredictedY()calcula los valores de y predichos utilizando la ecuación de regresión lineal: y = mx + b - Usamos una pendiente predefinida (0.6) e intercepto (1.5) para la demostración
- 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²:
calculateMean()calcula el promedio de un arreglo.computeRSquared()calcula R² usando la fórmula: 1 - (Variación Explicada / Variación Total).- La Variación Total mide la dispersión de los valores de y reales alrededor de su media.
- La Variación Explicada mide la dispersión de los valores predichos respecto a los valores reales.
- 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:
- Lee datos de un archivo externo.
- Calcula los parámetros de regresión usando el método de mínimos cuadrados.
- Calcula el valor de R².
- Proporciona una interpretación del valor de R².
- 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.
