Predicción de ventas de té con ML: Regresión lineal, descenso de gradiente y regularización (Amigable para principiantes + Código)

Introducción: en este artículo explicamos regresión lineal desde cero usando la historia de un puesto de té para hacer conceptos como función de coste, descenso de gradiente, regularización y sobreajuste más tangibles. Incluimos ejemplos en Python con NumPy y scikit learn adaptados para que puedas ejecutar y entender cada paso. Además presentamos cómo Q2BSTUDIO puede ayudar a llevar modelos a producción dentro de proyectos de aplicaciones a medida y software a medida integrando inteligencia artificial y mejores prácticas en ciberseguridad.

Qué vas a aprender: entender la regresión lineal aplicada a ventas de té frente a temperatura; medir el error con la función de coste MSE; optimizar parámetros con descenso de gradiente; reconocer sobreajuste y corregirlo con regularización como Ridge y Lasso; ejemplos prácticos reproducibles con NumPy y scikit learn.

Preparación: instala las librerías si hace falta con pip install numpy pandas scikit learn matplotlib Luego en tu script importa las dependencias esenciales import numpy as np import pandas as pd import matplotlib.pyplot as plt from sklearn.linear_model import LinearRegression Ridge Lasso from sklearn.model_selection import train_test_split from sklearn.metrics import mean_squared_error np.random.seed(42)

Escenario 1 regresión lineal simple: idea temperatura en grados Celsius a ventas de tazas de té; temperaturas más bajas suelen aumentar ventas. Código mínimo para crear datos y ajustar un modelo lin = LinearRegression() temps = np.array([10,12,15,18,20,22,24,26,28]).reshape(-1,1) tea_sales = np.array([100,95,85,70,60,55,50,45,40]) lin.fit(temps,tea_sales) slope = lin.coef_[0] intercept = lin.intercept_ tomorrow_temp = np.array([[21]]) pred_sales = lin.predict(tomorrow_temp)

Escenario 2 función de coste MSE: la media de errores al cuadrado penaliza fuertemente los errores grandes. Definición simple def mse(y_true,y_pred): return np.mean((y_true-y_pred)**2) y_pred = lin.predict(temps) error = mse(tea_sales,y_pred)

Escenario 3 descenso de gradiente desde cero: ajustamos m y c paso a paso como afinar una receta de té X = temps.flatten() y = tea_sales.astype(float) m,c = 0.0,0.0 lr = 0.0005 epochs = 5000 def predictions(m,c,X): return m*X + c def gradients(m,c,X,y): y_hat = predictions(m,c,X) dm = (-2/len(X))*np.sum(X*(y-y_hat)) dc = (-2/len(X))*np.sum(y-y_hat) return dm,dc history = [] for _ in range(epochs): dm,dc = gradients(m,c,X,y) m -= lr*dm c -= lr*dc history.append(mse(y,predictions(m,c,X))) final_mse = history[-1]

Sugerencia sobre lr: si lr es muy grande la pérdida puede divergir; si es muy pequeña el aprendizaje es muy lento. Visualizar la curva de coste ayuda a elegir parámetros.

Escenario 4 sobreajuste: simulamos muchas características donde algunas aportan señal y otras son ruido n = 300 temp = np.random.uniform(5,35,size=n) rain = np.random.binomial(1,0.3,size=n) festival = np.random.binomial(1,0.1,size=n) traffic = np.random.normal(0,1,size=n) dog_barks = np.random.normal(0,1,size=n) true_sales = 120 - 2.5*temp + 10*rain + 15*festival + 1.0*np.random.normal(0,3,size=n) X = np.column_stack([temp,rain,festival,traffic,dog_barks]) feature_names = ['temp','rain','festival','traffic','dog_barks'] X_train,X_test,y_train,y_test = train_test_split(X,true_sales,test_size=0.25,random_state=42) lr_model = LinearRegression() lr_model.fit(X_train,y_train) train_mse = mean_squared_error(y_train,lr_model.predict(X_train)) test_mse = mean_squared_error(y_test,lr_model.predict(X_test))

Si observas coeficientes grandes en características claramente ruidosas o un train MSE mucho menor que test MSE eso es sobreajuste. Para corregirlo puedes eliminar manualmente características inútiles, recopilar más datos o aplicar regularización sistemática.

Escenario 5 regularización: añadimos una penalización por complejidad para reducir coeficientes excesivos. Ridge aplica una penalización L2 y Lasso aplica L1. Ejemplos ridge = Ridge(alpha=10.0) ridge.fit(X_train,y_train) lasso = Lasso(alpha=1.0) lasso.fit(X_train,y_train) ridge_train_mse = mean_squared_error(y_train,ridge.predict(X_train)) ridge_test_mse = mean_squared_error(y_test,ridge.predict(X_test)) lasso_train_mse = mean_squared_error(y_train,lasso.predict(X_train)) lasso_test_mse = mean_squared_error(y_test,lasso.predict(X_test))

Qué esperar: Ridge suele reducir coeficientes ruidosos sin anularlos completamente; Lasso puede forzar coeficientes a cero y servir como selección de características. Busca el alpha que minimice el error en validación para equilibrar sesgo y varianza.

Comparativa de penalizaciones: explora una lista de alphas por ejemplo alphas = [0.0,0.1,1.0,10.0,50.0] y ajusta un modelo para cada alpha recopilando coeficientes y errores de train y test. Observa como al aumentar alpha los coeficientes se acercan a cero y el modelo se simplifica; si alpha es demasiado grande aparece subajuste con aumento de ambos MSE.

Función auxiliar de pronóstico sencilla: def forecast_tea_cups(temp_c,rain=0,festival=0,model=ridge): x = np.array([[temp_c,rain,festival,0.0,0.0]]) return float(model.predict(x)[0]) Ejemplo forecast_tea_cups(18,1,1) forecast_tea_cups(30,0,0)

Conclusiones clave: regresión lineal traza la mejor recta entre variables; la función de coste mide el error; descenso de gradiente optimiza los parámetros; sobreajuste ocurre cuando el modelo aprende ruido; regularización como Ridge y Lasso ayuda a mejorar la generalización. Escoge la penalización con validación cruzada para encontrar el punto óptimo.

Cómo puede ayudar Q2BSTUDIO: en Q2BSTUDIO ofrecemos desarrollo de software a medida y aplicaciones a medida para integrar modelos de machine learning en entornos productivos, junto con servicios de ciberseguridad y pentesting para garantizar despliegues seguros. Somos especialistas en inteligencia artificial y complementamos soluciones con servicios cloud aws y azure para escalabilidad, y con servicios inteligencia de negocio y power bi para visualización y toma de decisiones. Si buscas apoyo para llevar un prototipo a producción o para diseñar agentes IA y soluciones de ia para empresas visita nuestra sección de inteligencia artificial en IA para empresas o conoce nuestras opciones de desarrollo de aplicaciones en aplicaciones a medida y software a medida. Confía en Q2BSTUDIO para combinar modelos de machine learning con seguridad, servicios cloud aws y azure y análisis con power bi.

Palabras clave incluidas naturalmente para posicionamiento: aplicaciones a medida, software a medida, inteligencia artificial, ciberseguridad, servicios cloud aws y azure, servicios inteligencia de negocio, ia para empresas, agentes IA, power bi. Si necesitas que adaptemos estos ejemplos a tus datos reales o despleguemos una API con modelos en la nube contacta con el equipo de Q2BSTUDIO para un plan a medida.