Entrenamiento convergente e inferencia

Has construido cada pieza fundamental de la inteligencia artificial moderna:

1. La neurona lineal: Realiza la suma ponderada de estímulos.
2. La función de activación: Comprime la salida en una probabilidad no lineal $(0, 1)$.
3. La función de pérdida: Mide con rigor cuánto se equivoca el modelo.
4. El paso de optimización: Da pasos en la ladera descendente del error.
5. La época de entrenamiento: Aplica la regla de la cadena para calcular gradientes sobre todo el conjunto de datos.

En esta etapa final, unirás todas las piezas para construir el ciclo completo de entrenamiento e inferenciaFase donde un modelo ya entrenado procesa datos nunca antes vistos para tomar decisionesVer documentación oficial.

Imagina la tabla de verdad de la compuerta lógica AND:

• Entradas $[0, 0] \implies 0$
• Entradas $[1, 0] \implies 0$
• Entradas $[0, 1] \implies 0$
• Entradas $[1, 1] \implies 1$

Al inicio, inicializamos los pesos en $0$ ($w_1 = 0, w_2 = 0$) y el sesgo en $0$ ($b = 0$). Con estos valores iniciales, la neurona no sabe nada: para cualquier entrada calcula $z = 0$ y su sigmoide arroja $\sigma(0) = 0.5$ (máxima incertidumbre).

Pero a medida que el bucle ejecuta 200 épocas de optimización:

1. En cada época, la red calcula sus errores frente a la tabla de verdad.
2. La retropropagación calcula los gradientes promedio.
3. Los pesos aumentan progresivamente mientras el sesgo se vuelve negativo.
4. Al final del entrenamiento, los parámetros han convergido a un estado donde la suma ponderada solo supera el umbral cuando ambas entradas están activas.

¡Acabas de entrenar a una máquina para aprender una regla lógica a partir de datos!

Cuando la entrada contenga "op": "train-and-predict", tu programa debe leer:

• epochs: cantidad de épocas completas a iterar (entero positivo)
• learning_rate: tasa de aprendizaje $\alpha$
• samples: conjunto de datos de entrenamiento con pares {"x": [...], "y": 0 o 1}
• test_inputs: lista de vectores de entrada a clasificar tras el entrenamiento

Procedimiento paso a paso

1. Inicialización:

   • Determina la dimensión $d$ observando la longitud de samples[0]["x"].
   • Inicializa los pesos con ceros: weights = [0.0] * d.
   • Inicializa el sesgo en cero: bias = 0.0.
   • Total de muestras: $N = \text{len}(samples)$.

2. Bucle de entrenamiento (ejecutar epochs veces):

   • Inicializa acumuladores de gradientes: grad_w = [0.0] * d y grad_b = 0.0.
   • Para cada muestra $s$ en samples:
     • $z = \sum_{j=1}^{d} (w_j \cdot s.x_j) + b$.
     • $\hat{y} = \frac{1}{1 + e^{-z}}$.
     • $\delta = (\hat{y} - s.y) \cdot \hat{y} \cdot (1 - \hat{y})$.
     • Acumula en grad_w[j] += delta * s.x[j] y grad_b += delta.
   • Actualiza los pesos y el sesgo restando la media del gradiente multiplicada por learning_rate: $$w_j \leftarrow w_j - \alpha \cdot \frac{\text{grad\_w}[j]}{N}$$ $$b \leftarrow b - \alpha \cdot \frac{\text{grad\_b}}{N}$$

3. Fase de inferencia:

   • Para cada vector $x_{\text{test}}$ en test_inputs:
     • Evalúa la neurona con los pesos y el sesgo aprendidos: $$z = \sum_{j=1}^{d} (w_j \cdot x_{\text{test}, j}) + b$$ $$p = \frac{1}{1 + e^{-z}}$$
     • Emite la clase predicha con el umbral estándar de decisión: $$\text{predicción} = \begin{cases} 1 & \text{si } p \ge 0.5 \\ 0 & \text{si } p < 0.5 \end{cases}$$

Separa la acumulación de gradientes de la actualización de parámetros. Comprueba los valores intermedios con el ejemplo numérico. Mantén entrenamiento e inferencia como operaciones distintas; escribe tú los bucles y reutiliza las funciones anteriores.

Lección de ingeniería de ML

Observa cómo las fases están nítidamente separadas:

1. Entrenamiento: Se modifican los pesos mediante gradientes usando las etiquetas reales y.
2. Inferencia: Los pesos quedan congelados (frozen weights) y el modelo solo hace predicciones hacia adelante sobre nuevas entradas sin calcular derivadas ni conocer la respuesta correcta.

1. Si samples está vacío o epochs <= 0, escribe error en stderr y termina con código 1.
2. Emite un objeto JSON con la lista de enteros predichos:

   { "predictions": [0, 0, 0, 1] }
   

Los ejemplos multilínea se muestran así para facilitar la lectura. Emite JSON compacto, sin espacios opcionales, con las propiedades en el orden de los ejemplos de salida y un salto de línea final. No escribas logs en stdout. Las pruebas comparan texto exacto. Para entradas inválidas, usa stderr con la palabra error, stdout vacío y código 1. Para entradas válidas, código 0. Usa números JSON enteros cuando el resultado sea entero; en neural-network aplica el redondeo a cuatro decimales indicado en la etapa.