Primer módulo del Curso de Redes Neuronales. La meta del curso completo es entender las redes neuronales desde cero: la base matemática sobre la que se construye todo el deep learning moderno — las CNN que ven imágenes, los Transformers y los LLM que hoy escriben texto. Vamos de lo básico a lo avanzado, sin saltarnos pasos. Si nunca has visto qué hay adentro de un modelo de IA, pasa antes por Cómo funciona la IA. Este módulo pone el primer ladrillo: la neurona artificial, la pieza mínima que se repite millones de veces dentro de cualquier red.

La tesis del módulo

Una neurona artificial es una sola fórmula: multiplica cada entrada por su peso, suma todo junto con un ajuste (el bias), y pasa el resultado por una función. Nada más. Toda red neuronal, por gigante que sea, es esta operación repetida y encadenada. Si entiendes esta línea, entiendes el átomo de la IA.

De la neurona biológica a la matemática

La inspiración viene del cerebro. Una neurona biológica recibe señales de otras neuronas por sus dendritas, las combina en el cuerpo celular, y si la señal combinada supera un umbral, dispara un impulso por su axón hacia las siguientes neuronas. Recibe muchas entradas, decide, y emite una salida.

La versión matemática copia ese esquema, pero con números:

Entradas (x₁, x₂, ..., xₙ): los datos que entran. Pueden ser píxeles de una imagen, palabras convertidas en números, o las señales de otras neuronas.
Pesos (weights): cada entrada se multiplica por un peso w. El peso es cuánto le importa esa entrada a la neurona — un número que la red va a ajustar mientras aprende. Peso grande, la entrada pesa mucho; peso cero, la ignora.
Suma ponderada: se suman todas las entradas ya multiplicadas por sus pesos: w₁x₁ + w₂x₂ + ... + wₙxₙ.
Bias: se suma un número extra, el bias (sesgo). Es un ajuste que corre el resultado hacia arriba o abajo sin depender de las entradas — como el “umbral” de la neurona biológica, pero movible. Deja que la neurona dispare más fácil o más difícil.
Función de activación: el total pasa por una función que produce la salida. Por ahora piénsala como el “¿disparo o no?”. El módulo 2 la desarma entera.

Toda la neurona en una línea:

salida = f( w₁x₁ + w₂x₂ + … + wₙxₙ + b )

Ese f es la función de activación; ese b es el bias. Lo de adentro del paréntesis — la suma ponderada más el bias — se llama la pre-activación.

   entradas    pesos

   x1 ──────►  × w1 ───┐
                       │
   x2 ──────►  × w2 ───┤          ┌───────────────┐
                       ├────────► │ Σ  (suma) + b │
   x3 ──────►  × w3 ───┤          └───────┬───────┘
                       │                  │
   xn ──────►  × wn ───┘                  ▼
                                  ┌───────────────┐
                                  │  activación f │
                                  └───────┬───────┘
                                          │
                                          ▼
                                        salida

La neurona biológica vs la artificial

La analogía es útil, pero no hay que tomársela al pie de la letra: la neurona artificial es una caricatura matemática, no una simulación del cerebro.

Neurona biológica	Neurona artificial
Recibe señales por las dendritas	Recibe entradas `x₁...xₙ`
Cada sinapsis pesa distinto	Cada entrada tiene su peso `w`
Umbral de disparo en el cuerpo	Bias `b` (umbral movible)
Dispara si supera el umbral	Pasa la suma por `f(·)`
Emite impulso por el axón	Entrega un número de salida
Aprende reforzando sinapsis	Aprende ajustando pesos (módulos 4–5)
Millones, con química y tiempo real	Millones, pura álgebra en paralelo

Una neurona en código

Primero con numpy, para ver la fórmula pelada. El truco de eficiencia: en vez de multiplicar y sumar entrada por entrada, se usa el producto punto (np.dot), que hace w₁x₁ + w₂x₂ + ... de una sola pasada.

import numpy as np

def neurona(x, w, b):
    # x: entradas, w: pesos, b: bias (todos del mismo largo x y w)
    z = np.dot(w, x) + b          # pre-activación: suma ponderada + bias
    salida = 1 / (1 + np.exp(-z)) # activación sigmoid (módulo 2)
    return salida

x = np.array([0.5, 0.3, 0.9])     # tres entradas
w = np.array([0.4, -0.2, 0.7])    # un peso por entrada
b = 0.1                           # bias

print(neurona(x, w, b))           # -> un número entre 0 y 1

La misma neurona en PyTorch, la librería que usaremos en serio desde el módulo 8. Aquí nn.Linear(3, 1) es exactamente “3 entradas, 1 neurona”: guarda adentro los pesos y el bias, y los inicializa solo.

import torch
import torch.nn as nn

neurona = nn.Linear(in_features=3, out_features=1)  # 3 entradas -> 1 salida
activacion = nn.Sigmoid()

x = torch.tensor([0.5, 0.3, 0.9])
z = neurona(x)              # suma ponderada + bias, hecho por dentro
salida = activacion(z)      # pasa por la activación

print(salida)              # -> tensor con un número entre 0 y 1

Ojo: los pesos y el bias arrancan con valores aleatorios. Una neurona recién creada no sabe nada; da respuestas al azar. Todo el “aprender” es ir ajustando esos números — el tema de los módulos 4 y 5.

El perceptrón: el ladrillo original

En 1958, Frank Rosenblatt construyó el perceptrón: la primera neurona artificial entrenable. Su activación era la más simple posible — un escalón: si la pre-activación supera 0, la salida es 1; si no, 0. Un clasificador binario: sí o no, esta clase o la otra.

El perceptrón sabe trazar una línea recta que separe dos grupos de puntos. Y ahí está su límite famoso.

El límite del perceptrón: no puede con XOR

XOR (“o exclusivo”) es una función lógica: da 1 cuando las dos entradas son distintas, y 0 cuando son iguales.

x₁	x₂	AND	OR	XOR
0	0	0	0	0
0	1	0	1	1
1	0	0	1	1
1	1	1	1	0

AND y OR los resuelve un perceptrón sin problema: se puede trazar una recta que deje los 1 a un lado y los 0 al otro. Pero XOR es imposible con una sola recta — los dos “1” quedan en esquinas opuestas del cuadrado, cruzados. Ninguna línea recta los separa de los dos “0”.

   x2
    │
   1│  ● 1            ○ 0
    │
    │      (no hay UNA recta que
    │       separe los ● de los ○)
    │
   0│  ○ 0            ● 1
    └───────────────────────►  x1
       0                1

   ● = XOR da 1     ○ = XOR da 0

Este descubrimiento (Minsky y Papert, 1969) casi mata la investigación en redes por una década. ¿La solución? Apilar neuronas en capas y meter una función no-lineal entre medio. Con eso la red deja de trazar rectas y puede curvar la frontera. Esos dos ingredientes son justo los próximos dos módulos.

Errores comunes

Creer que una neurona “piensa”. No: es una multiplicación con suma y una función. La inteligencia aparece recién cuando juntas millones y las entrenas.
Confundir peso con bias. El peso multiplica una entrada; el bias se suma solo, sin depender de ninguna entrada. Son roles distintos.
Olvidar el bias. Sin bias, la neurona está obligada a pasar por el origen y pierde flexibilidad. Es barato y casi siempre suma.
Pensar que el perceptrón “falla” en XOR por un bug. No es un error de código: una sola neurona lineal matemáticamente no puede. Necesita capas y no-linealidad, no más entrenamiento.
Tomarse la analogía del cerebro demasiado en serio. Ayuda a la intuición, pero una red neuronal no simula neuronas reales; es álgebra inspirada en ellas.

La frase para llevarse

“Una neurona es entradas por pesos, más un bias, pasado por una función. Toda la IA moderna es esa línea repetida millones de veces.”

Qué viene

Módulo 2: funciones de activación. Ese f(·) que dejamos como caja negra es la pieza que le da vida a la red. Veremos por qué sin una función no-lineal apilar capas no sirve de nada, y conoceremos a las protagonistas: sigmoid, tanh y ReLU.

Redes Neuronales — Módulo 1: la neurona artificial — del cerebro a la matemática