La neurona artificial y combinación lineal

Tu programa es un motor de cálculo y entrenamiento neuronal que procesa comandos desde la entrada estándar en formato JSON compacto y devuelve el resultado por la salida estándar, reportando errores en stderr con código de salida 1.

El ejecutor de Shipcode corre tu programa mediante el comando declarado en shipcode.yml:

challenge: neural-network
run: python3 main.py

Para entender la inteligencia artificial moderna, no necesitas empezar con arquitecturas complejas de millones de parámetros. Todo comienza con una unidad elemental creada en 1943: el modelo de neurona artificialModelo matemático simplificado propuesto por McCulloch y Pitts que simula el procesamiento de estímulos en una célula cerebralVer documentación oficial.

Imagina que estás decidiendo si salir a pasear hoy. Tu cerebro evalúa distintas señales del entorno:

• ¿Hace buen clima? ($x_1$)
• ¿Es fin de semana? ($x_2$)
• ¿Tienes tareas pendientes? ($x_3$)

Sin embargo, no todas las señales tienen la misma relevancia. Para ti, el clima puede importar mucho, mientras que las tareas pendientes pueden tener un impacto negativo. A la importancia relativa de cada señal la llamamos peso ($w$).

Una neurona artificial simula este proceso:

1. Toma una serie de números de entrada ($x_1, x_2, \dots, x_n$).
2. Multiplica cada entrada por su peso correspondiente ($x_i \cdot w_i$).
3. Suma todas esas multiplicaciones.
4. Añade un término especial llamado sesgo (bias, $b$).

¿Por qué es necesario el sesgo (bias)?

Si una neurona no tuviese sesgo, cuando todas las entradas fueran cero ($x = [0, 0]$), la suma siempre daría cero. El sesgo representa la propensión natural o inclinación base de la neurona antes de recibir cualquier estímulo externo. En términos geométricos, permite desplazar la frontera de decisión en el espacio para que no esté atada obligatoriamente a cruzar por el origen $(0, 0)$.

La combinación lineal (frecuentemente denotada como $z$) se calcula mediante la fórmula afín:

Cuando la entrada estándar contenga una operación con "op": "linear-neuron", tu programa debe leer el payload:

{
  "op": "linear-neuron",
  "inputs": [1.0, 2.0],
  "weights": [0.5, -0.5],
  "bias": 0.2
}

Ejemplo guiado paso a paso

Siguiendo los datos del ejemplo anterior:

1. Multiplicamos la primera entrada por su peso: $1.0 \times 0.5 = 0.5$.
2. Multiplicamos la segunda entrada por su peso: $2.0 \times (-0.5) = -1.0$.
3. Sumamos los productos ponderados: $0.5 + (-1.0) = -0.5$.
4. Sumamos el sesgo base: $-0.5 + 0.2 = -0.3$.
5. El valor final es $z = -0.3$.

A nivel de código práctico en desarrollo de modelos:

• En Python: Puedes utilizar la función incorporada zip(inputs, weights) para iterar simultáneamente sobre entradas y pesos de forma limpia y legible:

  if len(inputs) != len(weights):
      raise ValueError("Las dimensiones de entrada y pesos no coinciden")
  z = sum(x * w for x, w in zip(inputs, weights)) + bias
  

• En TypeScript: Puedes utilizar un bucle for tradicional o el método reduce() acumulando sobre el índice:

  if (inputs.length !== weights.length) {
    throw new Error("Dimensiones incompatibles");
  }
  const z = inputs.reduce((acc, x, i) => acc + x * weights[i], bias);
  

Depuración y diagnóstico

Si un caso de prueba falla:

• Imprime inputs, weights y bias en sys.stderr o console.error para inspeccionar los valores sin contaminar la salida estándar stdout.
• Verifica que el sesgo no se multiplique por las entradas; el sesgo es un término aditivo independiente.

1. Validación de dimensiones: La cantidad de elementos en inputs debe ser idéntica a la de weights. Si una neurona recibe 3 entradas pero solo tiene 2 pesos, escribe un mensaje en stderr que contenga la palabra error y sal con código 1.
2. Control de errores y JSON inválido: Si la entrada estándar no es un JSON bien formado o el campo op no es reconocido, emite error en stderr y sal con código 1.
3. Manejo de precisión: Redondea el valor resultante a 4 decimales usando la función round_value incluida en tu starter. Si tras redondear el número resulta entero (incluyendo el 0), represéntalo como entero en JSON (por ejemplo {"z":0} en lugar de {"z":0.0}).
4. Formato de respuesta: Emite únicamente el objeto JSON compacto en una sola línea terminada en salto de línea:

   { "z": -0.3 }
   

Abre el README de la plantilla de tu lenguaje y ejecuta desde su raíz el comando build de shipcode.yml, si existe, seguido de run. La plantilla está incompleta: al principio debe fallar con un diagnóstico de implementación pendiente. Después de desarrollar esta etapa, usa shipcode test; conserva los comportamientos de las etapas anteriores y usa shipcode submit cuando pasen.

Puedes usar una biblioteca JSON para el sobre de entrada y salida. Esa biblioteca no debe resolver el algoritmo del proyecto. Si tu lenguaje no incluye JSON, añade una dependencia documentada y ajusta el comando build de shipcode.yml; comprueba la instalación en una carpeta limpia.

Los fragmentos con Math, .shift() o notación similar expresan ideas de algoritmo; no requieren JavaScript. Adáptalos a los tipos y bibliotecas de tu lenguaje. Un byte no equivale siempre a un carácter: en formatos binarios cuenta bytes y declara la codificación.

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.