Práctica: el perceptrón separa paso a paso

Entrenar un perceptrón a mano, iteración por iteración, sobre la función OR: calcular, corregir los pesos y ver cómo la recta se acomoda hasta separar las clases.

En esta práctica vamos a entrenar un perceptrón a mano, paso a paso, para ver con nuestros propios ojos cómo ajusta sus pesos hasta separar dos clases. Nada de librerías al principio: solo lápiz, papel y la regla de aprendizaje.

El problema

Queremos que un perceptrón aprenda la función lógica OR. Tenemos cuatro ejemplos con dos entradas ( $x_{1}, x_{2}$ ) y su etiqueta $y$ :

$x_{1}$	$x_{2}$	$y$
0	0	0
0	1	1
1	0	1
1	1	1

El objetivo: encontrar pesos $w_{1}, w_{2}$ y un sesgo $b$ tales que el perceptrón acierte los cuatro.

Las reglas del juego

Recordemos las dos fórmulas del perceptrón. La predicción:

\overset{y}{^} = {10 si w_{1} x_{1} + w_{2} x_{2} + b \geq 0 si no

Y la actualización, que aplicamos ejemplo por ejemplo (con tasa de aprendizaje $η = 1$ ):

w_{i} \leftarrow w_{i} + η (y - \overset{y}{^}) x_{i}, b \leftarrow b + η (y - \overset{y}{^})

Empezamos con todo en cero: $w_{1} = 0$ , $w_{2} = 0$ , $b = 0$ .

Primer barrido, a mano

Recorremos los cuatro ejemplos. En cada uno calculamos la suma $net = w_{1} x_{1} + w_{2} x_{2} + b$ , predecimos, y si nos equivocamos, corregimos.

$x$	$y$	net	$\overset{y}{^}$	$y - \overset{y}{^}$	acción	$w$ nuevo	$b$ nuevo
(0,0)	0	0	1	−1	corrige	(0, 0)	−1
(0,1)	1	−1	0	+1	corrige	(0, 1)	0
(1,0)	1	0	1	0	—	(0, 1)	0
(1,1)	1	1	1	0	—	(0, 1)	0

Fíjate en la lógica: cuando el perceptrón dice 1 y debía ser 0 ( $y - \overset{y}{^} = - 1$ ), baja los pesos de las entradas activas y el sesgo. Cuando dice 0 y debía ser 1 ( $y - \overset{y}{^} = + 1$ ), los sube. Cuando acierta, no toca nada.

Al terminar el barrido vamos en $w = (0, 1)$ , $b = 0$ . Todavía no separa bien (el ejemplo (0,0) sigue fallando), así que hay que seguir.

Repetir hasta que no haya errores

Si repetimos este mismo barrido un par de veces más, las correcciones se van agotando y los pesos se estabilizan en:

w_{1} = 1, w_{2} = 1, b = - 1

Es decir, la frontera aprendida es $x_{1} + x_{2} - 1 = 0$ , o sea $x_{1} + x_{2} = 1$ . Comprobemos que ahora sí acierta los cuatro:

$x$	$y$	net $= x_{1} + x_{2} - 1$	$\overset{y}{^}$	¿correcto?
(0,0)	0	−1	0	✓
(0,1)	1	0	1	✓
(1,0)	1	0	1	✓
(1,1)	1	1	1	✓

¡Convergió! La recta $x_{1} + x_{2} = 1$ deja el punto (0,0) de un lado y los otros tres del otro.

La frontera aprendida: el punto naranja (clase 0) queda a un lado; los tres rosados (clase 1), al otro.

Tu turno

Prueba lo mismo con la función AND, que solo vale 1 cuando ambas entradas son 1:

$x_{1}$	$x_{2}$	$y$
0	0	0
0	1	0
1	0	0
1	1	1

Parte de nuevo en $w = (0, 0)$ , $b = 0$ con $η = 1$ y aplica la misma regla barrido a barrido. Pista: deberías llegar a una frontera del estilo $x_{1} + x_{2} = 1, 5$ (por ejemplo $w = (1, 1)$ , $b = - 2$ ), que deja solo el punto (1,1) del lado positivo.

Comprobarlo en código

Cuando termines tu cálculo, verifica con este bucle, que hace exactamente lo que hiciste a mano:

import numpy as np

X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
y = np.array([0, 1, 1, 1])            # OR

w = np.zeros(2); b = 0.0; eta = 1.0
for epoca in range(10):
    errores = 0
    for xi, yi in zip(X, y):
        pred = 1 if xi @ w + b >= 0 else 0
        error = yi - pred
        w += eta * error * xi         # misma regla de la tabla
        b += eta * error
        errores += abs(error)
    if errores == 0:                  # un barrido sin errores = convergió
        break

print(w, b)   # ≈ [1. 1.] -1.0  → la recta x1 + x2 = 1

Para llevar

Entrenar un perceptrón es repetir un gesto simple: predecir, comparar con la verdad y, si falla, empujar los pesos en la dirección correcta. Haciéndolo a mano se ve que la "recta de decisión" no aparece por magia, sino que se acomoda paso a paso hasta separar las clases. Es la misma mecánica —predecir, medir el error, corregir— que, a gran escala, entrena a las redes neuronales con backpropagation.