Proyecto final: App de Estadística Aplicada con Python y Streamlit

Asignatura: Estadística Aplicada con Python y R · Ingeniería Agrícola · Universidad de Sucre

Docente: Justo Fuentes · Semestre: 2026-2

Entorno de trabajo: GitHub Codespaces + GitHub Copilot en modo Agent

Duración: 2 semanas (4 sesiones de 2 horas) o una jornada continua (una mañana o una tarde)

Este proyecto integra en una sola aplicación web los cuatro temas del semestre. Cada prompt se lanza una sola vez en el chat de Copilot (modo Agent) y, al terminar, se confirma con su commit y se sincroniza con GitHub. Así el historial del repositorio queda como un cuaderno de campo: una anotación fechada por cada labor terminada.

Producto final esperado

Una app multipágina de Streamlit llamada app-estadistica-aplicada con:

  1. Inicio: datos del estudiante, cultivo, municipio y huella digital de sus datos.
  2. Datos: tablas, tipos de variables, faltantes y descarga.
  3. EDA: análisis univariado, cualitativo y bivariado, atípicos y faltantes.
  4. Distribuciones: ajuste de modelos de probabilidad a la precipitación máxima anual, pruebas de bondad de ajuste, criterios de información (AIC, BIC, AICc), períodos de retorno, riesgo e incertidumbre; y comparación de modelos de secado en capa delgada con AICc.
  5. Regresión: Pearson y Spearman, regresión lineal simple por MCO, bondad de ajuste, inferencia sobre la pendiente, diagnóstico de residuos y predicción.
  6. Series de tiempo: componentes, promedios móviles, índices estacionales, descomposición clásica, métodos de referencia, validación (MAE, RMSE, SMAPE) y pronóstico automático con AutoTS.

Cada página termina con una sección “Verificación del cálculo a mano” que muestra los resultados de una muestra pequeña. El estudiante la compara con su hoja manuscrita (metodología del Lápiz y el Algoritmo).

Referencias técnicas:

Cronograma sugerido

Bloque Prompts Producto Etiqueta (tag)
Semana 1 · Sesión 1 Paso 0 y Prompts 1 a 5 Repositorio, entorno, datos personalizados, estructura de la app y página Datos —
Semana 1 · Sesión 2 Prompts 6 a 9 EDA y Distribuciones (con modelos de secado) v0.1-eda, v0.2-distribuciones
Semana 2 · Sesión 1 Prompts 10 a 13 Regresión y módulo de series con AutoTS v0.3-regresion
Semana 2 · Sesión 2 Prompts 14 a 20 Página de Series, verificación, robustez, README, autoevaluación y versión final v0.4-series, v1.0-final

Modalidad jornada continua (≈ 4,5 a 5 horas): lanza los prompts en orden, sin saltarte ningún commit. Tiempo aproximado: Prompts 1–5 (60 min) · 6–9 (70 min) · 10–13 (60 min) · 14–20 (70 min). Haz una pausa de 10 minutos entre bloques y detén el Codespace si la pausa es larga.

Cómo trabajar cada prompt (léelo una vez)

  1. Abre el chat de Copilot (Ctrl+Alt+I) y en el selector de modo elige Agent.
  2. Copia el prompt completo, reemplaza lo que está entre corchetes [ ] y envíalo una sola vez.
  3. Cuando el agente quiera ejecutar un comando, aparece Continue / Allow: lee el comando antes de aceptar.
  4. Cuando cree o cambie archivos, revisa y elige Keep (conservar) o Undo (deshacer).
  5. Abre la app en la pestaña Puertos → 8501 y comprueba que funciona.
  6. Lanza el commit del prompt en la terminal (Ctrl+ñ), o con el panel Control de código fuente (Ctrl+Shift+G → + → mensaje → Commit → Sync Changes).
  7. Copia el prompt y lo que aceptaste o corregiste en BITACORA_IA.md.

Analogía agrícola: el agente es un operario muy rápido; tú eres el ingeniero residente que revisa y firma. Cada commit es la firma en el cuaderno de obra: si no está firmado, no se hizo.

Antes de cada commit comprueba que .venv/ no se va a subir:

git status      # .venv/ NO debe aparecer en la lista

Secuencia de prompts para los estudiantes

Paso 0. Crear el repositorio y el Codespace (manual, sin agente)

  1. En GitHub: + → New repository → nombre app-estadistica-aplicada → Public → marca Add a README file → Create repository.
  2. En github.com/settings/codespaces: Default idle timeout = 15 min.
  3. En el repositorio: Code → Codespaces → Create codespace on main.
  4. En la terminal del Codespace, identifícate con tu correo institucional:
git config --global user.name "Nombre Apellido"
git config --global user.email "usuario@unisucrevirtual.edu.co"
git config --global --list      # verifica que quedaron guardados

Prompt 1. Comprensión general del proyecto y plan de desarrollo:

Actúa como tutor experto en Python, Streamlit, Git y Estadística Aplicada para estudiantes
de Ingeniería Agrícola. Responde en español.

Estoy en un GitHub Codespace (Linux) dentro de mi repositorio app-estadistica-aplicada, que
por ahora solo tiene README.md. Debo construir una app web multipágina en Streamlit con:

1. Inicio.
2. Datos.
3. EDA: Análisis Exploratorio de Datos.
4. Distribuciones: selección de modelos de distribución (Normal, Lognormal, Gamma, Weibull,
   Gumbel y GEV) para precipitación máxima anual, pruebas KS y Anderson-Darling, criterios
   de información AIC, BIC y AICc, período de retorno, riesgo e incertidumbre; y comparación
   de modelos de secado en capa delgada con AICc.
5. Regresión: correlación de Pearson y Spearman, regresión lineal simple por MCO, bondad de
   ajuste, inferencia sobre la pendiente y diagnóstico de residuos.
6. Series de tiempo: componentes, promedios móviles, índices estacionales, descomposición
   clásica, métodos de referencia, validación con MAE, RMSE y SMAPE, y pronóstico con AutoTS.

Antes de escribir código, explícame:
- Qué debe hacer cada página, qué entradas pide y qué tablas y gráficas muestra.
- Qué cálculos estadísticos realiza cada página.
- Cómo organizar el proyecto de forma modular (app.py, pages/, src/, datos/, verificacion/).
- En qué orden conviene construirlo y por qué.

Guarda ese plan en el archivo docs/PLAN_DESARROLLO.md (con títulos, viñetas y una tabla de
páginas y funciones). No crees ningún otro archivo, no instales nada y no hagas commits.

Commit del Prompt 1:

git add docs/PLAN_DESARROLLO.md
git commit -m "docs: plan de desarrollo de la app (Prompt 1)"
git push

Prompt 2. Entorno virtual, dependencias e instrucciones permanentes para Copilot:

Prepara el entorno del proyecto. Explica en una o dos líneas cada paso antes de ejecutarlo.

1. Crea un entorno virtual: python -m venv .venv  y verifica con: .venv/bin/python --version
2. Crea .vscode/settings.json para que VS Code use .venv/bin/python como intérprete.
3. Crea un .gitignore para Python que excluya: .venv/, __pycache__/, *.pyc,
   .ipynb_checkpoints/, .streamlit/secrets.toml, .DS_Store y exports/.
4. Crea requirements.txt con: streamlit, pandas, numpy, scipy, statsmodels, matplotlib,
   seaborn, openpyxl, scikit-learn, autots y pytest.
5. Instala con: .venv/bin/pip install -r requirements.txt  y verifica imprimiendo la
   versión de cada librería.
6. Crea .streamlit/config.toml con [server] headless = true y enableXsrfProtection = false
   (necesario para que st.file_uploader funcione dentro de Codespaces).
7. Crea .github/copilot-instructions.md con estas reglas permanentes para todo el proyecto:
   - Responder siempre en español y explicar cada paso antes de ejecutarlo.
   - Usar .venv/bin/python, .venv/bin/pip y .venv/bin/streamlit en todos los comandos.
   - Usar solo las librerías de requirements.txt; no instalar otras sin preguntarme.
   - Comentar el código paso a paso y escribir docstrings en español para estudiantes de
     Ingeniería Agrícola; ejes de gráficas con nombre y unidades.
   - Textos de la interfaz en español; usar seaborn y matplotlib para las gráficas.
   - No modificar la carpeta datos/ ni el archivo generar_datos.py una vez creados.
   - No hacer commits ni push: el estudiante los hace.
   - Al terminar cada tarea, ejecutar .venv/bin/streamlit run app.py y corregir errores.

No crees otros archivos. Al final muéstrame el árbol de archivos (sin .venv) y explícame en
5 líneas para qué sirven el entorno virtual, .gitignore, requirements.txt y
copilot-instructions.md.

Commit del Prompt 2:

git status      # confirma que .venv/ NO aparece
git add -A
git commit -m "chore: entorno virtual, requirements, gitignore e instrucciones de Copilot (Prompt 2)"
git push

Prompt 3. Generador de datos personalizados con el código estudiantil:

Crea el script generar_datos.py en la raíz del proyecto. Debe generar datos simulados
PERSONALIZADOS con mi código estudiantil como semilla, para que cada estudiante tenga datos
distintos y reproducibles.

Mis datos: código = "[TU CÓDIGO ESTUDIANTIL]"   nombre = "[TUS NOMBRES Y APELLIDOS]"

Reglas generales:
- semilla = int(codigo) % 2**32 y rng = numpy.random.default_rng(semilla).
- cultivo elegido según la semilla entre: Maíz, Arroz, Yuca, Ñame, Ajonjolí, Plátano,
  Frijol y Sorgo (cada uno con su rendimiento base en t/ha).
- municipio elegido según la semilla entre: Sincelejo, Corozal, Sampués, Los Palmitos,
  San Marcos, Majagual, Tolú y Ovejas.
- Guardar todo en la carpeta datos/.

Archivos que debe crear:
1. parcelas.csv (entre 80 y 120 parcelas): parcela (P001...), suelo (Franco, Arcilloso,
   Arenoso), riego (Sí/No), dosis_N [kg/ha, 0-180], lamina_riego [mm, mayor con riego],
   materia_organica [%, con 3 a 6 faltantes], ph [4.8-7.8] y rendimiento [t/ha], que dependa
   de dosis_N, lamina_riego, materia_organica, ph y suelo, con ruido normal; incluir 2
   parcelas atípicas (una muy alta y una muy baja).
2. precip_max_anual.csv: anio (1986 a 2025) y pmax24h_mm, precipitación máxima en 24 horas
   de cada año, simulada con una Gumbel de parámetros mu entre 70 y 100 mm y beta entre 12 y
   20 mm que dependan de la semilla.
3. clima_mensual.csv: fecha (inicio de mes, 2015-01 a 2025-12), precipitacion_mm con régimen
   bimodal del Caribe (lluvias en abril-mayo y septiembre-noviembre, seco en diciembre-marzo)
   y ruido lognormal, y temperatura_c con tendencia leve creciente y ciclo anual.
4. secado.csv: tiempo_min (0 a 300 cada 15 min) y MR (razón de humedad, de 1 hacia 0)
   simulada con el modelo de Page MR = exp(-k·t^n), con k y n que dependan de la semilla y
   ruido pequeño, sin valores negativos.
5. Muestras pequeñas para el cálculo A MANO:
   - muestra_eda10.csv: 10 parcelas (parcela, suelo, riego, rendimiento) que incluyan 1 atípico.
   - muestra_dist10.csv: 10 años de precip_max_anual.csv elegidos al azar.
   - muestra_reg8.csv: 8 parcelas sin atípicos repartidas a lo largo de lamina_riego
     (ordenar por lámina, formar 8 grupos con pd.qcut y tomar 1 por grupo).
   - muestra_series24.csv: los 24 meses de 2024-2025 de clima_mensual.csv con columnas periodo
     (1 a 24), fecha, anio, mes, precipitacion_mm y conjunto (entrenamiento = 18 primeros
     meses, validacion = 6 últimos).
6. metadatos.json: codigo, nombre, cultivo, municipio, n_parcelas y huella, donde
   huella = primeros 8 caracteres en mayúscula del md5 de f"{codigo}|{n}|{suma de rendimiento:.2f}".

El script debe imprimir al final: nombre, código, cultivo, municipio, huella y las cuatro
muestras pequeñas. Comenta cada bloque. Ejecútalo con .venv/bin/python generar_datos.py y
muéstrame la salida. Después de esto, no vuelvas a modificar generar_datos.py ni datos/.

Copia en tu hoja manuscrita las cuatro muestras pequeñas que imprime la terminal. No vuelvas a ejecutar el script con otro código.

Commit del Prompt 3:

git add generar_datos.py datos/
git commit -m "feat(datos): generador de datos personalizados y muestras para el cálculo a mano (Prompt 3)"
git push

Prompt 4. Estructura de la app multipágina y página de Inicio:

Crea la estructura base de la app multipágina de Streamlit:

1. src/__init__.py (vacío) y src/datos.py con funciones documentadas:
   - cargar_csv(nombre) con @st.cache_data que lea un archivo de datos/ (fechas parseadas
     cuando existan columnas fecha).
   - cargar_metadatos() que lea datos/metadatos.json.
   - tarjeta_estudiante() que muestre en la barra lateral nombre, código, cultivo,
     municipio y huella.
2. app.py (Inicio) con st.set_page_config (título "Estadística Aplicada con Python y R",
   layout ancho): título "App de Estadística Aplicada — Ingeniería Agrícola, Unisucre";
   tarjeta del estudiante; propósito de la app; descripción breve de cada página; una
   sección "Lápiz y Algoritmo" que explique que primero se calcula a mano y luego se verifica
   con la app, Python y R; y una advertencia académica: la app apoya el aprendizaje, pero la
   interpretación es responsabilidad del estudiante.
3. Páginas en pages/ con un st.info "En construcción" y la lista de temas de cada una:
   1_Datos.py, 2_EDA.py, 3_Distribuciones.py, 4_Regresion.py y 5_Series_de_tiempo.py.
   Todas deben llamar a tarjeta_estudiante().

Explícame cómo Streamlit reconoce las páginas de la carpeta pages/ y cómo importar src/
sin errores de ModuleNotFoundError. Ejecuta la app y dime cómo abrirla desde la pestaña
Puertos (8501).

Commit del Prompt 4:

git add -A
git commit -m "feat(app): estructura multipágina, módulo src/datos.py y página de Inicio (Prompt 4)"
git push

Prompt 5. Página Datos:

Reemplaza pages/1_Datos.py por una página funcional que permita elegir, con un st.selectbox,
cualquiera de los archivos de datos/ (parcelas, precip_max_anual, clima_mensual, secado) y
muestre:

1. La tabla de datos (st.dataframe) y el número de filas y columnas en st.metric.
2. Una tabla con cada variable, su tipo de dato y su clasificación estadística
   (cualitativa nominal, cualitativa ordinal, cuantitativa discreta o continua).
3. Una tabla de valores faltantes por variable (cantidad y porcentaje).
4. La descripción de cada archivo: qué representa, unidades y en qué página se usa.
5. Un st.download_button para descargar el archivo en CSV.
6. Un st.file_uploader opcional para que el usuario cargue su propio CSV o Excel y vea las
   mismas tablas (si no carga nada, se usan mis datos).

Agrega a src/datos.py las funciones tipos_de_variables(df) y valores_faltantes(df), con
docstrings. Ejecuta la app y corrige errores.

Commit del Prompt 5:

git add -A
git commit -m "feat(datos): página Datos con tipos de variables, faltantes y descarga (Prompt 5)"
git push

Fin de la Sesión 1. Ejecuta git status (debe decir nothing to commit) y detén el Codespace: github.com/codespaces → … → Stop codespace.

Prompt 6. Módulo y página de Análisis Exploratorio de Datos (EDA):

Desarrolla el EDA de la app usando datos/parcelas.csv y datos/muestra_eda10.csv.

1. Crea src/eda.py con funciones documentadas y comentadas paso a paso:
   - resumen_numerico(serie): n, media, mediana, desviación estándar muestral, varianza,
     CV %, mínimo, Q1, Q3, máximo, RIC y asimetría (cuartiles con el método tipo 7, el que
     usan por defecto pandas y R).
   - vallas_tukey(serie): límites inferior y superior con 1.5·RIC y lista de atípicos.
   - tabla_frecuencias(serie): frecuencias absolutas y relativas de una variable cualitativa.
2. Reemplaza pages/2_EDA.py con filtros por suelo y riego en la barra lateral y estas secciones:
   a) Univariado: selector de variable numérica, tabla resumen_numerico, histograma con
      curva de densidad, diagrama de caja y lista de parcelas atípicas.
   b) Cualitativo: tablas de frecuencias y gráficos de barras de suelo y riego.
   c) Bivariado: diagramas de caja de rendimiento por suelo y por riego; dispersión de una
      variable X elegida contra rendimiento, coloreada por riego; mapa de calor de la matriz
      de correlación de Pearson.
   d) Datos faltantes y atípicos: qué parcelas tienen faltantes y una explicación breve de
      qué hacer con ellos (no borrarlos sin justificar).
   e) "Verificación del cálculo a mano (10 parcelas)": tabla de muestra_eda10, su resumen
      numérico, la tabla de desviaciones (x - media y su cuadrado), las vallas de Tukey, los
      atípicos y la media de rendimiento por riego, con 4 decimales.
Ejecuta la app y corrige errores.

Commit del Prompt 6 (con etiqueta de versión):

git add -A
git commit -m "feat(eda): módulo src/eda.py y página EDA con verificación de 10 parcelas (Prompt 6)"
git tag -a v0.1-eda -m "Versión 0.1: Datos y EDA"
git push --follow-tags

Prompt 7. Módulo de ajuste de distribuciones y criterios de información:

Crea src/distribuciones.py para seleccionar el modelo de distribución de la precipitación
máxima anual (datos/precip_max_anual.csv, columna pmax24h_mm) con scipy.stats. Funciones
documentadas y comentadas paso a paso, explicando cada fórmula:

1. CANDIDATAS: diccionario con Normal (norm), Lognormal (lognorm, loc fijo en 0), Gamma
   (gamma, loc fijo en 0), Weibull (weibull_min, loc fijo en 0), Gumbel (gumbel_r) y GEV
   (genextreme). Aclarar en un comentario que en scipy el parámetro c de genextreme es -ξ.
2. ajustar(datos, nombre): ajuste por máxima verosimilitud (fit) y número k de parámetros
   libres (sin contar los fijos).
3. log_verosimilitud(datos, nombre, params) = suma de logpdf.
4. criterios_informacion(datos, nombre, params): AIC = 2k - 2ℓ, BIC = k·ln(n) - 2ℓ y
   AICc = AIC + 2k(k+1)/(n-k-1).
5. bondad_ajuste(datos, nombre, n_mc): estadísticos y valores p de Kolmogorov-Smirnov y de
   Anderson-Darling con scipy.stats.goodness_of_fit (valor p por Monte Carlo, que corrige
   el problema de Lilliefors), más el valor p "ingenuo" de stats.kstest para compararlo.
6. tabla_comparativa(datos, n_mc=199): una fila por candidata con parámetros, k, ℓ, AIC,
   BIC, AICc, ΔAIC = AIC - AIC mínimo, interpretación de ΔAIC (< 2 soporte sustancial,
   4-7 menos soporte, > 10 sin soporte), estadísticos y valores p, y "¿Se rechaza H0?" al 5 %.
7. posiciones_graficas(datos): datos ordenados, posición de Weibull i/(n+1) y de Gringorten
   (i - 0.44)/(n + 0.12), y período de retorno empírico T = 1/(1 - p).
8. cuantil_retorno(nombre, params, T): x_T = F⁻¹(1 - 1/T) para T = 2, 5, 10, 25, 50 y 100 años.
9. riesgo_falla(T, N): R = 1 - (1 - 1/T)^N.
10. bootstrap_cuantil(datos, nombre, T, B=500, semilla): intervalo de confianza del 95 % de
    x_T por bootstrap paramétrico.
11. gumbel_momentos(datos): método de momentos, β = s·√6/π y μ = media - 0.5772·β (es el
    cálculo que el estudiante hace a mano).

Prueba el módulo con un pequeño bloque if __name__ == "__main__" que imprima la tabla
comparativa ordenada por AIC. Ejecútalo con .venv/bin/python -m src.distribuciones.
No modifiques todavía las páginas.

Commit del Prompt 7:

git add src/distribuciones.py
git commit -m "feat(distribuciones): ajuste MLE, KS y AD por Monte Carlo, AIC/BIC/AICc, período de retorno y bootstrap (Prompt 7)"
git push

Prompt 8. Página Distribuciones:

Reemplaza pages/3_Distribuciones.py por una página funcional que use src/distribuciones.py
con datos/precip_max_anual.csv y datos/muestra_dist10.csv. Secciones:

1. "Los datos": serie de máximos anuales (gráfico de barras por año, en mm), resumen
   numérico e histograma.
2. "Candidatas y ajuste": st.multiselect de distribuciones (todas por defecto); histograma
   con las densidades ajustadas superpuestas; y una explicación breve de por qué Gumbel y GEV
   tienen respaldo teórico para máximos anuales (teorema de valores extremos).
3. "Bondad de ajuste": tabla de KS y Anderson-Darling con valores p por Monte Carlo y el
   valor p ingenuo de KS; gráficos Q-Q de cada candidata en una cuadrícula; un st.slider
   para n_mc (99 a 499) y st.cache_data para no repetir el cálculo.
4. "Criterios de información": tabla ordenada por AIC con BIC, AICc, ΔAIC y su
   interpretación; gráfico de barras de ΔAIC; y un st.success con el modelo recomendado
   siguiendo este semáforo: (i) respaldo físico, (ii) Q-Q aceptable, (iii) no se rechaza con
   Anderson-Darling, (iv) ΔAIC pequeño; entre modelos equivalentes, elegir el más simple.
5. "Período de retorno y diseño": tabla de x_T para T = 2 a 100 años según cada candidata;
   gráfico en papel de Gumbel (eje x = variable reducida -ln(-ln(1 - 1/T)) rotulado con los
   valores de T, datos con posición de Gringorten y curvas de las candidatas); intervalo de
   confianza bootstrap del cuantil para un T elegido; y una calculadora de riesgo con T y la
   vida útil N de la obra (por ejemplo, un canal de drenaje).
6. "Verificación del cálculo a mano (10 años)": tabla de muestra_dist10 ordenada con la
   posición de Weibull y el T empírico; media, desviación estándar muestral; parámetros
   de Gumbel por momentos (β y μ) y por máxima verosimilitud; x_T para T = 10, 50 y 100
   años con ambos métodos; y el riesgo para T = 50 y N = 25 años, con 4 decimales.
Ejecuta la app y corrige errores.

Commit del Prompt 8:

git add -A
git commit -m "feat(distribuciones): página de selección de modelos, período de retorno y verificación de 10 años (Prompt 8)"
git push

Prompt 9. Modelos de secado en capa delgada y AICc (aplicación en Ingeniería):

Agrega a la app la comparación de modelos semiempíricos de secado con datos/secado.csv.

1. Crea src/modelos_curvas.py con funciones documentadas:
   - MODELOS: Lewis MR = exp(-k·t); Henderson-Pabis MR = a·exp(-k·t);
     Page MR = exp(-k·t^n); Logarítmico MR = a·exp(-k·t) + c; Dos términos
     MR = a·exp(-k0·t) + b·exp(-k1·t). Cada uno con valores iniciales razonables.
   - ajustar_curva(t, MR, nombre) con scipy.optimize.curve_fit.
   - metricas_curva(MR, MR_ajustado, k): R², RMSE, χ² reducido, AIC = n·ln(SCE/n) + 2k
     y AICc = AIC + 2k(k+1)/(n-k-1).
   - tabla_modelos(t, MR): una fila por modelo con parámetros y métricas, ordenada por AICc.
2. En pages/3_Distribuciones.py agrega al final una sección "Ingeniería: modelos de secado
   (AICc)" con: curva observada y curvas ajustadas; tabla de modelos ordenada por AICc con
   ΔAICc; gráfico de residuos del mejor modelo; y una explicación de por qué el AICc castiga
   los parámetros extra (navaja de Ockham), con la analogía de no comprar una secadora más
   compleja si la sencilla seca igual.
Ejecuta la app y corrige errores.

Commit del Prompt 9 (con etiqueta de versión):

git add -A
git commit -m "feat(secado): modelos de secado en capa delgada comparados con AICc (Prompt 9)"
git tag -a v0.2-distribuciones -m "Versión 0.2: distribuciones, criterios de información y secado"
git push --follow-tags

Fin de la Semana 1. git status y detén el Codespace.

Prompt 10. Módulo de correlación y regresión lineal simple:

Abre de nuevo el proyecto (sincronicé con git pull). Crea src/regresion.py con funciones
documentadas y comentadas paso a paso, usando datos/parcelas.csv y datos/muestra_reg8.csv:

1. matriz_correlacion(df, metodo) para "pearson" o "spearman" de las variables numéricas.
2. calculo_manual(x, y): n, medias, Sxx, Syy, Sxy, r de Pearson, rho de Spearman,
   b1 = Sxy/Sxx, b0 = ȳ - b1·x̄, ajustados, residuos, SCE, SCR, SCT, R² = 1 - SCE/SCT,
   RSE = raíz(SCE/(n-2)), SE(b1) = RSE/raíz(Sxx), t = b1/SE(b1), t crítico bilateral
   (alfa = 0.05, gl = n-2), p-valor e IC 95 % de b1. Con numpy y scipy, con las mismas
   fórmulas de la clase.
3. ajustar_rls(df, x, y) con statsmodels.formula.api.ols.
4. predecir(modelo, x0): predicción, intervalo de confianza e intervalo de predicción del 95 %.
5. diagnostico_residuos(modelo): residuos, ajustados, Shapiro-Wilk y Breusch-Pagan.
6. ajustar_multiple(df, y, lista_x), eliminando filas con faltantes.
Agrega un bloque if __name__ == "__main__" que compare calculo_manual con statsmodels para
muestra_reg8.csv (deben coincidir b0, b1, R², RSE y t). Ejecútalo con
.venv/bin/python -m src.regresion.

Commit del Prompt 10:

git pull
git add src/regresion.py
git commit -m "feat(regresion): módulo de correlación, MCO, inferencia sobre la pendiente y diagnóstico (Prompt 10)"
git push

Prompt 11. Página Regresión:

Reemplaza pages/4_Regresion.py por una página funcional que use src/regresion.py. Secciones:

1. "Correlación": selector Pearson/Spearman, mapa de calor de la matriz y tabla de la
   correlación de cada variable con rendimiento, ordenada por |r|; nota: correlación no
   implica causalidad.
2. "Regresión lineal simple": selector de X (por defecto lamina_riego) con
   Y = rendimiento; dispersión con la recta ajustada; ecuación con unidades; r, R² y RSE en
   st.metric; tabla de coeficientes (coeficiente, error estándar, t, p-valor, IC 95 %); un
   st.info con la decisión sobre H0: β1 = 0 al 5 %; y la interpretación de b1 por cada 100 mm.
3. "Diagnóstico de residuos": residuos vs ajustados con línea en 0, histograma, gráfico Q-Q,
   Shapiro-Wilk y Breusch-Pagan con interpretación sencilla.
4. "Predicción": st.slider dentro del rango observado con predicción e intervalos del 95 %,
   y un st.number_input libre que muestre st.warning de EXTRAPOLACIÓN fuera del rango.
5. "Regresión múltiple (vista previa)": rendimiento ~ dosis_N + lamina_riego +
   materia_organica + ph; coeficientes, R² y R² ajustado.
6. "Verificación del cálculo a mano (8 parcelas)": tabla de muestra_reg8 con desviaciones,
   productos cruzados, rangos, ajustados y residuos; todos los resultados de calculo_manual
   con 4 decimales (b1 con 6); dispersión con la recta; y una tabla que compare b1, r, R², t
   y p-valor entre las 8 parcelas y todas las parcelas.
Ejecuta la app y corrige errores.

Commit del Prompt 11 (con etiqueta de versión):

git add -A
git commit -m "feat(regresion): página de correlación, regresión, residuos, predicción y verificación de 8 parcelas (Prompt 11)"
git tag -a v0.3-regresion -m "Versión 0.3: correlación y regresión lineal simple"
git push --follow-tags

Prompt 12. Módulo de series de tiempo (sin AutoTS):

Crea src/series.py con funciones documentadas y comentadas paso a paso, usando
datos/clima_mensual.csv y datos/muestra_series24.csv:

1. cargar_serie(variable): Serie con índice de fechas y frecuencia "MS".
2. promedio_movil(serie, orden) con rolling (ventana que termina en el mes actual).
3. indices_estacionales(serie): aditivos, promedio de cada mes menos el promedio general
   (la suma de los 12 índices debe ser ≈ 0).
4. descomponer(serie): seasonal_decompose de statsmodels, modelo aditivo, period=12.
5. metodos_referencia(entrenamiento, h): pronósticos ingenuo (último valor), estacional
   ingenuo (mismo mes del año anterior) y promedio (media del entrenamiento) para h meses.
6. metricas(real, pronostico): MAE, RMSE y SMAPE = 200·media(|e| / (|real| + |pronóstico|)).
7. concurso_referencia(muestra24): entrena con los 18 meses de entrenamiento, pronostica los
   6 de validación con los tres métodos y devuelve la tabla de métricas ordenada por SMAPE.
Agrega un bloque if __name__ == "__main__" que imprima el concurso de muestra_series24.csv
y ejecútalo con .venv/bin/python -m src.series.

Commit del Prompt 12:

git add src/series.py
git commit -m "feat(series): componentes, promedios móviles, índices estacionales, descomposición y métodos de referencia (Prompt 12)"
git push

Prompt 13. Pronóstico automático con AutoTS:

Agrega a src/series.py la función ejecutar_autots(serie, horizonte, model_list, generaciones,
validaciones, intervalo, semilla) con AutoTS y estos parámetros: frequency="MS",
ensemble=None, transformer_list="superfast", validation_method="backwards",
no_negatives=True, n_jobs=1 y verbose=0. Debe devolver un diccionario con:
- el pronóstico con límites inferior y superior (DataFrame con fecha, pronostico_mm,
  limite_inferior_mm y limite_superior_mm),
- el nombre, los parámetros y las transformaciones del mejor modelo,
- la tabla model.results("validation") con Model, smape, mae, rmse y Score (top 10).

Crea también el script pronostico_autots.py en la raíz que ejecute ejecutar_autots con la
precipitación de 2015-2025, horizonte 12, model_list "superfast", 5 generaciones,
2 validaciones, intervalo 0.9 y semilla = int(código de metadatos.json) % 10000, y guarde
en resultados/ los archivos autots_pronostico.csv, autots_top10_modelos.csv y
autots_mejor_modelo.json. Comenta cada línea explicando qué hace AutoTS, con la analogía
de un ensayo de evaluación de variedades con selección genética.
Ejecútalo con .venv/bin/python pronostico_autots.py (puede tardar de 1 a 4 minutos) y
muéstrame el modelo ganador y el puesto de SeasonalNaive en el top 10.
Si AutoTS tarda más de 5 minutos, baja a 2 generaciones y 1 validación.

Commit del Prompt 13:

git add src/series.py pronostico_autots.py resultados/
git commit -m "feat(autots): pronóstico automático con AutoTS y resultados guardados (Prompt 13)"
git push

Fin de la Semana 2 · Sesión 1. git status y detén el Codespace.

Prompt 14. Página Series de tiempo:

Reemplaza pages/5_Series_de_tiempo.py por una página funcional que use src/series.py.
Secciones:

1. "Exploración": selector de variable (precipitacion_mm o temperatura_c); gráfico de línea
   con promedios móviles de 3 y 12 meses; diagrama de caja por mes con nombres de los meses
   en español; y una explicación de tendencia, estacionalidad e irregularidad con el
   régimen bimodal de lluvias del Caribe.
2. "Descomposición clásica": gráficos de observada, tendencia, estacional y residuo; tabla
   de índices estacionales por mes con su interpretación (por encima o por debajo del promedio).
3. "Métodos de referencia y validación": con los últimos 12 meses como validación,
   pronósticos ingenuo, estacional ingenuo y promedio; gráfico real vs pronósticos; y tabla
   de MAE, RMSE y SMAPE ordenada por SMAPE.
4. "Pronóstico automático con AutoTS": dentro de un st.form, horizonte (6 a 24, por defecto
   12), model_list ("superfast" o "fast"), generaciones (1 a 10, por defecto 5), validaciones
   (1 a 3, por defecto 2) e intervalo (0.8, 0.9 o 0.95). Al presionar "Ejecutar AutoTS" usar
   st.spinner y st.cache_resource; la semilla sale de metadatos.json. Mostrar: modelo ganador y
   parámetros en st.json; gráfico de la serie con el pronóstico y la banda del intervalo; tabla
   del pronóstico; top 10 de modelos; botón de descarga del pronóstico en CSV; y un st.info con
   la analogía del ensayo de variedades.
5. "Resultados guardados": si existen archivos en resultados/, mostrarlos sin volver a
   ejecutar AutoTS.
6. "Verificación del cálculo a mano (24 meses)": tabla de muestra_series24 con PM3; índices
   estacionales con su suma; los tres pronósticos de julio a diciembre 2025 junto a los
   reales; tabla de errores |e|, e² y |e|/(|y|+|ŷ|) por mes; MAE, RMSE y SMAPE por método;
   método ganador; y gráfico con la línea vertical entre entrenamiento y validación.
Actualiza app.py: todas las páginas están disponibles. Ejecuta la app y corrige errores.

Commit del Prompt 14 (con etiqueta de versión):

git pull
git add -A
git commit -m "feat(series): página de series de tiempo con AutoTS y verificación de 24 meses (Prompt 14)"
git tag -a v0.4-series -m "Versión 0.4: series de tiempo y AutoTS"
git push --follow-tags

Prompt 15. Scripts de verificación en Python y R (Lápiz y Algoritmo, Fase 2):

Crea la carpeta verificacion/ con scripts independientes de la app que verifiquen los
cálculos a mano de las cuatro muestras pequeñas. Cada script debe estar comentado paso a
paso, usar solo fórmulas explícitas (no funciones de la app) e imprimir resultados con
4 decimales:

1. verificar_eda.py y verificar_eda.R (muestra_eda10.csv): media, mediana, varianza,
   desviación estándar, CV, Q1, Q3 (tipo 7), RIC, vallas de Tukey, atípicos y media por riego.
2. verificar_distribuciones.py y verificar_distribuciones.R (muestra_dist10.csv): posición
   de Weibull, T empírico, Gumbel por momentos, x_T para T = 10, 50 y 100 años y riesgo para
   T = 50 y N = 25. En R, además, ajuste por máxima verosimilitud con fitdistrplus y evd si
   están disponibles, explicando cómo instalarlos en Posit Cloud.
3. verificar_regresion.py y verificar_regresion.R (muestra_reg8.csv): Sxx, Syy, Sxy, r, rho,
   b0, b1, SCE, R², RSE, SE(b1), t, decisión e IC 95 %; en R con lm() y summary().
4. verificar_series.py y verificar_series.R (muestra_series24.csv): PM3 de 2025, índices
   estacionales, tres métodos de referencia y MAE, RMSE y SMAPE.
5. verificacion/RESULTADOS.md: una plantilla con cuatro tablas (una por tema) con las
   columnas Medida | A mano | Python | R | App | ¿Coincide?, y al final las secciones
   "¿Se cumplió mi predicción previa?" y "Diferencias encontradas y su causa".
Ejecuta los cuatro scripts de Python y muéstrame la salida. Los de R los ejecutaré yo en
Posit Cloud.

Commit del Prompt 15:

git add verificacion/
git commit -m "test(verificacion): scripts en Python y R para verificar los cálculos a mano (Prompt 15)"
git push

Prompt 16. Validaciones, mensajes pedagógicos y exportación de resultados:

Mejora la robustez de la app sin cambiar los cálculos:

1. Crea src/validacion.py con funciones que detecten: archivo vacío, columnas no
   seleccionadas, variable de respuesta no numérica, datos faltantes, menos datos de los
   necesarios (por ejemplo, menos de 10 para ajustar distribuciones o menos de 24 meses para
   series) y errores al ajustar modelos. Los mensajes deben ser pedagógicos (qué pasó y qué
   debe corregir el estudiante) y mostrarse con st.warning o st.error, nunca con un error
   técnico sin explicar.
2. Úsalas en las páginas EDA, Distribuciones, Regresión y Series de tiempo.
3. Crea src/exportar.py con funciones para descargar con st.download_button: tablas en Excel
   (BytesIO con openpyxl), figuras de matplotlib en PNG y PDF, y un reporte breve en
   Markdown con los resultados principales de cada página.
4. Agrega en cada página un expander "Descargar resultados" con esas opciones.
5. Crea tests/test_calculos.py con pruebas sencillas (assert) que comprueben, para las
   muestras pequeñas, que src/ y verificacion/ dan los mismos resultados, y ejecútalas con
   .venv/bin/python -m pytest -q.
Ejecuta la app y corrige errores.

Commit del Prompt 16:

git add -A
git commit -m "refactor(app): validaciones con mensajes pedagógicos, exportación de resultados y pruebas (Prompt 16)"
git push

Prompt 17. README académico y Bitácora de IA:

Escribe dos archivos:

1. README.md completo para el repositorio, con: título; datos del estudiante (nombre,
   código, grupo, cultivo, municipio y huella leídos de datos/metadatos.json); descripción
   general; objetivo académico; las seis páginas y los temas de cada una; tecnologías;
   estructura del proyecto (árbol de carpetas); cómo ejecutarla en un Codespace paso a paso;
   la metodología del Lápiz y el Algoritmo; limitaciones (datos simulados, AutoTS con modelos
   rápidos, supuestos de cada modelo); posibles mejoras; y referencias básicas. Deja vacías,
   con el título y una nota "(escrito por el estudiante, con cifras y unidades)", estas
   secciones: Hallazgos del EDA, Hallazgos de distribuciones, Hallazgos de la regresión y
   Hallazgos de series de tiempo.
2. BITACORA_IA.md: una plantilla con una sección por cada prompt (1 a 20) con los campos:
   prompt usado (texto exacto), comandos que aprobé, cambios que rechacé o corregí y por qué,
   errores encontrados; y al final una "Reflexión de cierre" con preguntas sobre qué aprendí
   haciéndolo yo mismo, qué supervisé en el agente y en qué se equivocó la IA.
Tono académico, claro y profesional. No inventes hallazgos: esas secciones las escribo yo.

Tarea tuya (no del agente): completa las cuatro secciones de Hallazgos del README con tus cifras y unidades, y llena la BITACORA_IA.md. Sube tu hoja manuscrita escaneada a evidencias/hoja_manuscrita.pdf y dos o tres capturas de la app.

Commit del Prompt 17:

git add -A
git commit -m "docs: README académico, bitácora de IA, hallazgos y evidencias (Prompt 17)"
git push

Prompt 18. Autoevaluación antes de la versión final:

Actúa como evaluador del proyecto final de Estadística Aplicada. Sin modificar el código,
revisa el repositorio completo y escribe docs/AUTOEVALUACION.md con:
1. Organización del proyecto y modularidad.
2. Claridad de comentarios y docstrings.
3. Correctitud estadística de cada página. Verifica en especial: varianza con n-1;
   cuartiles tipo 7; k correcto en AIC/BIC/AICc y signo del parámetro de forma de la GEV;
   valores p por Monte Carlo; RSE con n-2; SMAPE con 200 y |real| + |pronóstico|; y el
   estacional ingenuo con 12 meses de rezago.
4. Funcionamiento de cada página (ejecuta la app y los tests).
5. Coincidencia entre las secciones de verificación de la app y verificacion/.
6. Una lista priorizada de correcciones (crítica, importante, deseable).
No corrijas nada: solo diagnostica.

Commit del Prompt 18:

git add docs/AUTOEVALUACION.md
git commit -m "docs: autoevaluación final del proyecto (Prompt 18)"
git push

Si la autoevaluación encuentra errores críticos, corrígelos antes de seguir con un prompt corto: “Corrige únicamente el punto crítico N de docs/AUTOEVALUACION.md y explícame el cambio”. Cada corrección lleva su commit: git add -A && git commit -m "fix: corrige [problema] según la autoevaluación" && git push.

Prompt 19. Despliegue en Streamlit Community Cloud (opcional):

Explícame paso a paso cómo desplegar esta app en Streamlit Community Cloud desde mi
repositorio de GitHub y prepara lo necesario:
1. Revisa requirements.txt para la nube (versiones compatibles y sin librerías innecesarias).
2. Crea runtime.txt o indica la versión de Python que debo elegir en el despliegue.
3. Indica que el archivo principal es app.py y qué hacer con .streamlit/config.toml.
4. Explica qué hacer si AutoTS es demasiado lento en la nube (usar "Resultados guardados"
   y limitar generaciones).
5. Lista los errores comunes (dependencias, rutas relativas a datos/, memoria) y cómo
   corregirlos.
6. Agrega al README una sección "App en línea" con un espacio para el enlace.

Commit del Prompt 19 (si no haces el despliegue, omite este prompt y su commit):

git add -A
git commit -m "chore(deploy): preparación para Streamlit Community Cloud (Prompt 19)"
git push

Prompt 20. Revisión del repositorio y versión final:

Actúa como mi asistente de control de versiones con Git. Explica cada comando antes de
ejecutarlo y espera mi aprobación.
1. Ejecuta git status y confirma que .venv/ y __pycache__/ NO aparecen; si aparecen,
   corrige .gitignore y quítalos del índice con git rm -r --cached.
2. Ejecuta git pull.
3. Revisa que existan: app.py, las 5 páginas, los módulos de src/, datos/, resultados/,
   verificacion/, tests/, evidencias/, docs/, README.md, BITACORA_IA.md y requirements.txt.
   Dime si falta algo.
4. Muéstrame git log --oneline y git tag, y resume en 5 líneas la historia del proyecto.
5. Explícame en 3 líneas la diferencia entre commit, push y tag.
No hagas commits: yo lanzo el commit final.

Commit del Prompt 20 (versión final):

git add -A
git commit -m "release: versión final de la app de Estadística Aplicada (Prompt 20)"
git tag -a v1.0-final -m "Versión final: EDA, distribuciones, regresión y series de tiempo"
git push --follow-tags

Luego, en GitHub (navegador): Releases → Create a new release → tag v1.0-final → título App de Estadística Aplicada — versión final 2026-2 → 3 o 4 líneas de descripción → Publish release. Por último, git status y detén el Codespace.

Prompts de emergencia para errores frecuentes

Error de importación

Me aparece este error:
ModuleNotFoundError: No module named 'src.distribuciones'
Esta es mi estructura de carpetas: [pego la salida de: tree -I .venv]
Este es el archivo desde donde importo: [pego el código]
Diagnostica el problema y corrige los imports. Explícame si falta __init__.py, si estoy
ejecutando desde otra carpeta o si debo usar .venv/bin/streamlit run app.py desde la raíz.

Commit: git add -A && git commit -m "fix: corrige imports de src (emergencia)" && git push

Error al cargar archivos en Codespaces (AxiosError 403)

Al usar st.file_uploader en el Codespace aparece "AxiosError: Request failed with status
code 403". Revisa .streamlit/config.toml y corrígelo para que la carga de archivos funcione
dentro de Codespaces. Explícame por qué ocurre.

Commit: git add -A && git commit -m "fix: configuración de Streamlit para cargar archivos en Codespaces (emergencia)" && git push

Error estadístico

El ajuste o el modelo no funciona correctamente.
Página y función: [nombre]
Primeras filas de los datos: [pego df.head()]
Error completo: [pego el error]
Corrige el problema y explícame qué estaba mal desde el punto de vista estadístico y desde
el punto de vista de Python. No cambies las fórmulas de la clase.

Commit: git add -A && git commit -m "fix: corrige el cálculo de [tema] (emergencia)" && git push

El resultado de la app no coincide con mi hoja

En la sección de verificación de [página] la app da [valor] y mi cálculo a mano da [valor].
Muéstrame, paso a paso y con las fórmulas de la clase, cómo calcula la app ese resultado
para que yo encuentre dónde está la diferencia. No modifiques ningún archivo.

Commit: este prompt no cambia archivos. Cuando encuentres la causa, anótala en verificacion/RESULTADOS.md y lanza: git add -A && git commit -m "docs: registra diferencia manual vs app" && git push.

AutoTS demasiado lento o con muchas advertencias

AutoTS tarda más de 5 minutos o muestra muchas advertencias. Ajusta ejecutar_autots y la
página para usar por defecto 2 generaciones y 1 validación, silenciar advertencias
innecesarias y mostrar "Resultados guardados" mientras tanto. Explícame por qué las
advertencias de modelos que fallan son normales en AutoTS.

Commit: git add -A && git commit -m "perf(autots): reduce generaciones y validaciones por defecto (emergencia)" && git push

Push rechazado

Al hacer git push aparece este error: [pego el error completo]
Explícame la causa (cambios en GitHub que no tengo, correo privado bloqueado o etiqueta
existente) y dame los comandos exactos para resolverlo sin perder mi trabajo.

Commit: el mismo que quedó pendiente, una vez resuelto el problema.

Entregables

  1. URL del repositorio https://github.com/TU_USUARIO/app-estadistica-aplicada, público, con la etiqueta v1.0-final y su Release.
  2. Enlace a la app desplegada (si hiciste el Prompt 19).
  3. evidencias/hoja_manuscrita.pdf con los cálculos a mano de las cuatro muestras.
  4. verificacion/RESULTADOS.md comparando a mano, Python, R y la app.
  5. README.md con los cuatro apartados de Hallazgos escritos por ti.
  6. BITACORA_IA.md con los prompts usados y lo que aceptaste, rechazaste o corregiste.

Historial mínimo esperado: al menos 20 commits (uno por prompt) y las etiquetas v0.1-eda, v0.2-distribuciones, v0.3-regresion, v0.4-series y v1.0-final.

Mensajes de commit: se usan los prefijos feat (función nueva), fix (corrección), docs (documentación), chore (configuración), refactor (mejora sin cambiar resultados), test (verificación), perf (rendimiento) y release (versión). El número del prompt va al final, entre paréntesis, para que el docente pueda seguir el historial.