El perceptrón

El perceptrón es la neurona artificial: la unidad más simple de una red neuronal. Propuesto por Frank Rosenblatt en 1958 e inspirado en las neuronas del cerebro, toma varias entradas, las pondera y decide una salida. Todo el deep learning nace de aquí.

De la neurona biológica a la artificial

Una neurona recibe señales, las combina y "se activa" si el estímulo supera cierto umbral. El perceptrón imita eso con números:

1. Recibe entradas $x_1,x_2,\dots ,x_n$.
2. Cada una tiene un peso $w_i$ que mide su importancia.
3. Suma todo y le añade un sesgo $b$.
4. Pasa el resultado por una función de activación que produce la salida.

La fórmula

Primero, la suma ponderada (idéntica a la de una regresión lineal):

$$z=w_1{x}_1+w_2{x}_2+\cdots +w_n{x}_n+b={\mathbf{w}}^{\top }\mathbf{x}+b$$

Luego, una función escalón decide la salida: dispara $1$ si se supera el umbral, $0$ si no.

$$\hat{y}=\{\begin{array}{ll}1& \text{si }z\ge 0\\ 0& \text{si }z<0\end{array}$$

Los pesos deciden cuánto pesa cada entrada; el sesgo, qué tan fácil es activarse.

Cómo aprende

El perceptrón ajusta sus pesos mirando sus errores. Por cada ejemplo, compara su predicción $\hat{y}$ con la respuesta real $y$ y corrige:

$$w_i\leftarrow w_i+\eta (y-\hat{y})x_i$$

• Si acertó ($y=\hat{y}$), no cambia nada.
• Si falló, mueve los pesos en la dirección que habría dado la respuesta correcta.

Repitiendo sobre los datos, converge a una recta que separa las clases... si es que existe.

En código

Un perceptrón que aprende la función lógica AND cabe en unas líneas:

import numpy as np

X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
y = np.array([0, 0, 0, 1])            # AND: solo (1,1) da 1

w = np.zeros(2); b = 0.0; eta = 0.1
for _ in range(10):                   # varias pasadas por los datos
    for xi, yi in zip(X, y):
        pred = 1 if xi @ w + b >= 0 else 0
        error = yi - pred
        w += eta * error * xi         # regla de aprendizaje
        b += eta * error

print(w, b)  # una recta que separa el único (1,1) del resto

El límite que cambió la historia

Un solo perceptrón únicamente puede separar clases con una recta. El caso famoso es el XOR (o exclusivo): no existe ninguna recta que separe sus clases, y el perceptrón simplemente no puede aprenderlo. Este descubrimiento, en 1969, casi congela el campo por años.

La solución llegó después: apilar perceptrones en capas. Eso es exactamente una red neuronal.

Para llevar

El perceptrón es la neurona artificial: pondera entradas, suma un sesgo y activa una salida. Aprende corrigiendo sus errores, pero por sí solo únicamente traza fronteras lineales —no puede con el XOR—. Superar ese límite apilando neuronas en capas es el tema de la próxima lección: las redes neuronales.