# Bloque de Código 1: Importando nuestras bibliotecas

import numpy as np
import matplotlib.pyplot as plt

# Una rápida impresión para confirmar que todo está cargado y listo. ¡Buena práctica!
print("Kit de herramientas listo. NumPy y Matplotlib están cargados y listos.")

Kit de herramientas listo. NumPy y Matplotlib están cargados y listos.

# Bloque de Código 2: Creando un conjunto de datos sintético y realista

# Estoy configurando una 'semilla aleatoria' aquí. Este es un paso crucial en la ingeniería de software
# para el aprendizaje automático. Asegura que nuestros números 'aleatorios' sean los mismos cada
# vez que ejecutamos este código, haciendo que nuestros resultados sean reproducibles.
np.random.seed(42)

# Simulemos datos para 50 días.
m = 50 # 'm' es el nombre de variable estándar para el número de ejemplos de entrenamiento.

# X = Número de Pacientes. Creemos 50 valores aleatorios entre 50 y 150.
# La forma (m, 1) lo convierte en un vector columna.
X = 50 + 100 * np.random.rand(m, 1)

# y = Número de Mascarillas Usadas.
# Creemos una relación: y = 25 (base) + 0.8 * X + algo de ruido aleatorio.
# Esto simula un escenario del mundo real donde la relación no es perfectamente lineal.
y = 25 + 0.8 * X + np.random.randn(m, 1) * 10

# Lo primero que debe hacer un desarrollador con los datos es mirarlos.
# Hagamos la gráfica para confirmar visualmente que se ven como esperamos.
plt.figure(figsize=(12, 7))
plt.scatter(X, y, label='Datos Diarios Simulados')
plt.title("Hospital Minermont - Datos Sintéticos")
plt.xlabel("Número de Pacientes (Característica X)")
plt.ylabel("Mascarillas Usadas (Objetivo y)")
plt.grid(True)
plt.legend()
plt.show()

# Bloque de Código 3: Construyendo y Entrenando el Modelo (con Parada Temprana)

# --- 1. Escalado de la Característica ---
# El número de pacientes (de 50 a 150) es un número grande comparado con el 1
# constante que multiplica al sesgo. Lo estandarizamos: media 0 y desviación típica 1.
X_mean = X.mean()
X_std = X.std()
X_scaled = (X - X_mean) / X_std

# --- 2. Inicialización de Parámetros ---
# Necesitamos darle a nuestro modelo un punto de partida. Empecemos w y b en 0.
# Es una posición inicial simple y neutral.
w = 0.0
b = 0.0

# --- 3. Configuración de Hiperparámetros ---
# Estos son ajustes para el algoritmo de aprendizaje, no aprendidos de los datos.
# Tenemos que configurarlos nosotros mismos.
learning_rate = 0.01       # Cómo de grande es el paso en cada actualización (alfa en las notas de Luis).
num_iterations = 10000     # El número máximo de iteraciones.
tol = 0.001                # Tolerancia: cambio mínimo en el coste para seguir adelante (umbral de parada temprana).

# --- 4. El Bucle de Entrenamiento ---
# Almacenaremos el coste en cada paso para observar cómo aprende nuestro modelo.
cost_log = []

print("Iniciando la secuencia de entrenamiento...")
for i in range(num_iterations):
    # a) Realizar predicciones para TODOS nuestros puntos de datos con los w y b actuales.
    y_pred = w * X_scaled + b

    # b) Calcular el coste (MSE) para estas predicciones.
    # Esto nos dice cómo de bien lo estamos haciendo en esta iteración.
    cost = np.mean((y_pred - y)**2)
    cost_log.append(cost)

    # --- Condición de Parada Temprana ---
    # Si el coste no ha cambiado mucho en comparación con el paso anterior,
    # significa que hemos alcanzado una región plana, no estamos aprendiendo mucho más.
    if i > 0 and abs(cost_log[-2] - cost_log[-1]) < tol:
        print(f"Parada temprana en la iteración {i}: el coste apenas cambia.")
        break

    # c) Calcular los gradientes. Este es el núcleo del aprendizaje.
    # Estas fórmulas provienen de la derivada de la función de coste.
    # Nos dicen la pendiente de nuestra "colina" de coste para w y b.
    dw = (2/m) * np.sum((y_pred - y) * X_scaled)  # Gradiente para el peso
    db = (2/m) * np.sum(y_pred - y)               # Gradiente para el sesgo

    # d) Actualizar los parámetros.
    # Movemos w y b en la dirección *opuesta* a su gradiente.
    # Este es el paso "cuesta abajo".
    w = w - learning_rate * dw
    b = b - learning_rate * db

    # Un registro simple para seguir el proceso en tiempo real.
    # Imprimimos la evolución del error cada 100 iteraciones, empezando por la 1
    # (la iteración 0 es el punto de partida, w = b = 0).
    if ((i-1) % 100) == 0:
        print(f"Iteración {i}: Coste = {cost:.6f}")

# --- 5. De Vuelta a las Unidades Originales ---
# El modelo ha aprendido con los pacientes escalados. Deshacemos el escalado para que
# w sea "mascarillas por paciente" y b el número base de mascarillas.
b = b - w * X_mean / X_std
w = w / X_std

# imprimir el número de iteraciones y el error final
print("\n--- Entrenamiento Completo ---")
print(f"Número de iteraciones: {i}")
print(f"Error final: {cost:.6f}")
print(f"Peso aprendido final (w): {w:.4f}")
print(f"Sesgo aprendido final (b): {b:.4f}")

Iniciando la secuencia de entrenamiento...
Iteración 1: Coste = 10285.499154
Iteración 101: Coste = 261.760311
Iteración 201: Coste = 85.463328
Iteración 301: Coste = 82.362626
Parada temprana en la iteración 322: el coste apenas cambia.

--- Entrenamiento Completo ---
Número de iteraciones: 322
Error final: 82.330876
Peso aprendido final (w): 0.7765
Sesgo aprendido final (b): 27.0436

# Bloque de Código 4: Visualizando el Rendimiento del Modelo

# Crea una figura con dos gráficos lado a lado para un informe agradable.
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(20, 7))

# --- Gráfico 1: La Curva de Aprendizaje ---
ax1.plot(cost_log)
ax1.set_title("Curva de Aprendizaje del Modelo")
ax1.set_xlabel("Iteración")
ax1.set_ylabel("Coste (Error Cuadrático Medio)")
ax1.grid(True)

# --- Gráfico 2: La Línea de Regresión Final ---
# Primero, añade a la gráfica los puntos de datos originales
ax2.scatter(X, y, label='Datos Originales')
# Luego, añade a la gráfica la línea que ha aprendido el modelo
# Generamos los valores y para la línea usando nuestros w y b finales
ax2.plot(X, w * X + b, color='red', linewidth=3, label='Modelo Aprendido')
ax2.set_title("Ajuste del Modelo Final")
ax2.set_xlabel("Número de Pacientes")
ax2.set_ylabel("Mascarillas Usadas")
ax2.grid(True)
ax2.legend()

plt.show()

# Bloque de Código 5: Haciendo una Predicción

# Digamos que queremos saber cuántas mascarillas debemos presupuestar si esperamos 100 pacientes mañana.
patients_tomorrow = 100

# Usamos nuestros w y b finales entrenados para calcular la predicción.
predicted_masks = w * patients_tomorrow + b

print("\n--- Haciendo una Nueva Predicción ---")
print(f"Para un día con {patients_tomorrow} pacientes...")
print(f"Nuestro modelo predice que necesitaremos aproximadamente {predicted_masks:.0f} mascarillas.")

# Probemos otra para un día más tranquilo.
patients_quiet_day = 65
predicted_masks_quiet = w * patients_quiet_day + b
print(f"\nPara un día con {patients_quiet_day} pacientes...")
print(f"Nuestro modelo predice que necesitaremos aproximadamente {predicted_masks_quiet:.0f} mascarillas.")

--- Haciendo una Nueva Predicción ---
Para un día con 100 pacientes...
Nuestro modelo predice que necesitaremos aproximadamente 105 mascarillas.

Para un día con 65 pacientes...
Nuestro modelo predice que necesitaremos aproximadamente 78 mascarillas.

2.6 - Notas de Luis - Nuestro primer modelo predictivo¶

Paso 1: Importación de bibliotecas necesarias¶

Paso 2: Preparación y preprocesamiento de los datos¶

Paso 3: Definición de los componentes del modelo¶

Paso 4: Implementación del bucle de entrenamiento¶

Paso 5: Visualización y análisis de los resultados¶

Paso 6: Aplicación del modelo para realizar predicciones¶

Conclusión y Próximos Pasos¶