ChatGPT, Claude o el reconocimiento de caras del móvil funcionan con redes neuronales artificiales: millones de piezas diminutas que copian, de forma muy simplificada, lo que hace una neurona del cerebro. La idea tiene más de ochenta años, y nació de una pregunta muy concreta: si una neurona solo se enciende o se apaga, ¿puede una red de neuronas razonar como una calculadora? Te contamos cómo surgió, cómo funciona una neurona artificial y, con dos animaciones, cómo una red aprende sola.
Primero hubo que ver la neurona
A finales del siglo XIX no estaba claro que el cerebro estuviera hecho de células separadas. Muchos científicos, entre ellos el italiano Camillo Golgi, creían que era una red continua, como una malla de tuberías. Fue el español Santiago Ramón y Cajal quien, a partir de 1888, tiñó y dibujó miles de neuronas y demostró que cada una es una célula independiente, con una dirección clara: las señales entran por las dendritas, se reúnen en el cuerpo celular y salen por el axón hacia otras neuronas, a las que se conecta en las sinapsis. Golgi y Cajal compartieron el Nobel de Medicina de 1906, todavía sin ponerse de acuerdo.
Durante las décadas siguientes se vio además que una neurona funciona casi como un interruptor: va acumulando las señales que le llegan y, si pasan de cierto umbral, dispara un impulso eléctrico. Si no, se queda en silencio. No hay término medio: es todo o nada.
1943: una neurona hecha de lógica
Ese «todo o nada» llamó la atención de dos personajes muy distintos. Warren McCulloch era un neurofisiólogo de Chicago que llevaba años pensando cómo podía el cerebro producir pensamiento. Walter Pitts era un joven autodidacta, sin título universitario, que de adolescente había leído los Principia Mathematica de Bertrand Russell y le había escrito para señalarle errores; vivía prácticamente sin casa cerca de la Universidad de Chicago cuando McCulloch lo acogió.
En 1943 publicaron juntos «A Logical Calculus of the Ideas Immanent in Nervous Activity». Su modelo de neurona era mínimo: unas entradas que valen 0 o 1, una suma y un umbral. Si la suma lo alcanza, la salida es 1; si no, 0. Con eso demostraron algo sorprendente: combinando neuronas así se puede construir cualquier operación lógica, como Y, O o NO, y, por tanto, en principio, cualquier cálculo. El cerebro podía verse como una máquina de calcular. John von Neumann citó el artículo poco después al describir la arquitectura de los primeros ordenadores.
Faltaba algo esencial: en la neurona de McCulloch y Pitts, los pesos y el umbral los ponía una persona a mano. La neurona no aprendía. En 1949, el psicólogo canadiense Donald Hebb propuso cómo podría hacerlo el cerebro: cuando una neurona ayuda repetidamente a que otra se dispare, la conexión entre las dos se refuerza. Es la idea que hoy se resume en «las neuronas que se disparan juntas se conectan», y la base de todo lo que vino después: aprender es ajustar la fuerza de las conexiones.
Pruébalo: una neurona que aprende
Esta es una neurona artificial con dos entradas. Haz clic en las entradas para encenderlas y apagarlas, y mueve los pesos (w₁ y w₂) y el umbral (b): la neurona suma cada entrada multiplicada por su peso, más el umbral, y dispara si el resultado es mayor que cero. Los pulsos azules son señales que empujan a disparar; los rojos, señales que frenan. A la derecha verás lo que «ve» la neurona: los cuatro casos posibles como puntos en un plano y la recta que separa los que dan 1 de los que dan 0.
Objetivo: Y (AND). Mueve los pesos y el umbral hasta que los cuatro casos salgan bien, o pulsa «Aprender los pesos».
Con «Aprender los pesos», la neurona empieza con todo a cero y aplica la regla del perceptrón: prueba cada caso y, si se queda corta, sube los pesos de las entradas que estaban encendidas; si se pasa, los baja. Con la Y y la O encuentra la solución en unas pocas vueltas. Con el XOR, que da 1 solo cuando las dos entradas son distintas, no lo consigue nunca, y la explicación está en el plano: no hay ninguna recta que deje los dos puntos azules a un lado y los dos rojos al otro.
1958: el perceptrón, la máquina que «iba a pensar»
Esa regla la inventó Frank Rosenblatt, un psicólogo del Laboratorio Aeronáutico de Cornell, que en 1958 juntó las dos ideas: la neurona de McCulloch y Pitts y el aprendizaje de Hebb. Lo llamó perceptrón, y no se quedó en el papel. Con dinero de la Oficina de Investigación Naval de Estados Unidos construyó el Mark I Perceptron, una máquina con una «retina» de 400 fotocélulas en una cuadrícula de 20 por 20, cuyos pesos eran potenciómetros que unos motores eléctricos giraban para ajustarlos. Le enseñaban tarjetas con formas y, tras unos cuantos intentos, aprendía a distinguirlas.
La presentación, en julio de 1958, desató la primera fiebre de la IA. Según la crónica del New York Times, la Marina esperaba que fuera el embrión de un ordenador capaz de andar, hablar, ver, escribir, reproducirse y ser consciente de su propia existencia. Nada de eso estaba cerca.
El invierno y el deshielo
En 1969, Marvin Minsky y Seymour Papert, del MIT, publicaron el libro Perceptrons, donde demostraban matemáticamente lo que acabas de ver en la animación: un perceptrón de una sola capa no puede aprender cosas tan simples como el XOR. Sabían que una red con más capas sí podría, pero nadie sabía cómo entrenarla. El libro, junto con las promesas incumplidas, contribuyó a que la financiación de las redes neuronales se secara durante más de una década. Es el primer «invierno de la IA».
La salida llegó con la retropropagación (backpropagation). La idea es repartir la culpa del error hacia atrás: se mira cuánto se equivocó la salida y se calcula cuánto contribuyó cada peso de cada capa, para corregirlos todos un poco. Paul Werbos la había descrito en su tesis de 1974, pero fue el artículo de David Rumelhart, Geoffrey Hinton y Ronald Williams en Nature, en 1986, el que la popularizó. Con ella, las redes podían tener capas ocultas entre la entrada y la salida, y esas capas aprenden por su cuenta a detectar rasgos intermedios. El XOR dejó de ser un problema.
Pruébalo: una red que aprende a separar
Aquí tienes una red pequeña, de las que se entrenan con retropropagación. Recibe dos números, la posición de un punto en el mapa de la izquierda, y tiene que decir si es azul o rojo. Pulsa «Entrenar» y mira cómo el fondo del mapa, que muestra lo que la red responde en cada zona, se va ajustando a los puntos. A la derecha, la red por dentro: cada neurona se ilumina según su activación para el punto marcado con el círculo, y los pulsos de luz recorren las conexiones con la fuerza de cada señal, en azul si suman y en rojo si restan. Pasa el ratón o el dedo por el mapa para ver qué neuronas se encienden en cada zona.
Prueba a quitar las capas ocultas: con «Ninguna», la red es un perceptrón y solo sabe dibujar una recta, así que no pasa de acertar poco más de la mitad de los puntos en ninguno de los tres conjuntos. Con una capa oculta resuelve el XOR y el círculo en un par de segundos, pero la espiral se le resiste. Con dos capas, también la espiral. Cada capa combina lo que encontró la anterior, y eso le permite trazar fronteras cada vez más retorcidas: es la idea del aprendizaje profundo.
Este programa en Python hace lo mismo que las dos animaciones en pequeño, sin ninguna biblioteca: primero la neurona sola con la regla del perceptrón, que aprende la Y y la O pero no el XOR, y después una red con una capa oculta de solo dos neuronas, entrenada con retropropagación, que sí lo resuelve:
# Una neurona artificial que aprende con la regla del perceptrón (Rosenblatt, 1958),
# y una red con una capa oculta que resuelve el XOR con retropropagación (1986).
import math
import random
TABLAS = {
"Y": [((0, 0), 0), ((0, 1), 0), ((1, 0), 0), ((1, 1), 1)],
"O": [((0, 0), 0), ((0, 1), 1), ((1, 0), 1), ((1, 1), 1)],
"XOR": [((0, 0), 0), ((0, 1), 1), ((1, 0), 1), ((1, 1), 0)],
}
def neurona(x, w, b):
"""Dispara (1) si la suma ponderada supera el umbral, como la de McCulloch y Pitts."""
return 1 if w[0] * x[0] + w[1] * x[1] + b > 0 else 0
def perceptron(tabla, max_epocas):
w, b = [0, 0], 0
for epoca in range(1, max_epocas + 1):
errores = 0
for x, objetivo in tabla:
error = objetivo - neurona(x, w, b)
if error:
errores += 1
w = [w[0] + error * x[0], w[1] + error * x[1]]
b += error
if errores == 0:
return w, b, epoca, True
return w, b, max_epocas, False
for nombre, tabla in TABLAS.items():
w, b, epocas, converge = perceptron(tabla, 6 if nombre == "XOR" else 20)
salidas = [neurona(x, w, b) for x, _ in tabla]
estado = f"aprendido en {epocas} épocas" if converge else f"sin solución tras {epocas} épocas"
print(f"{nombre:3} w = {w}, b = {b:2} salidas {salidas} ({estado})")
# Red 2-2-1 con sigmoides: la capa oculta resuelve lo que una neurona sola no puede.
def sig(z):
return 1 / (1 + math.exp(-z))
random.seed(1) # con la semilla 3 se queda atascada en un mínimo local
W1 = [[random.uniform(-1, 1) for _ in range(2)] for _ in range(2)]
b1 = [0.0, 0.0]
W2 = [random.uniform(-1, 1) for _ in range(2)]
b2 = 0.0
tasa = 0.5
for epoca in range(20000):
for x, t in TABLAS["XOR"]:
h = [sig(W1[j][0] * x[0] + W1[j][1] * x[1] + b1[j]) for j in range(2)]
y = sig(W2[0] * h[0] + W2[1] * h[1] + b2)
dy = (y - t) * y * (1 - y) # error de la salida
dh = [dy * W2[j] * h[j] * (1 - h[j]) for j in range(2)] # repartido hacia atrás
for j in range(2):
W2[j] -= tasa * dy * h[j]
W1[j][0] -= tasa * dh[j] * x[0]
W1[j][1] -= tasa * dh[j] * x[1]
b1[j] -= tasa * dh[j]
b2 -= tasa * dy
print("\nRed con una capa oculta de 2 neuronas, tras 20,000 épocas:")
for x, t in TABLAS["XOR"]:
h = [sig(W1[j][0] * x[0] + W1[j][1] * x[1] + b1[j]) for j in range(2)]
y = sig(W2[0] * h[0] + W2[1] * h[1] + b2)
print(f"XOR{x} = {y:.3f} (debe dar {t})")salidaY w = [2, 1], b = -2 salidas [0, 0, 0, 1] (aprendido en 6 épocas) O w = [1, 1], b = 0 salidas [0, 1, 1, 1] (aprendido en 4 épocas) XOR w = [-1, 0], b = 1 salidas [1, 1, 0, 0] (sin solución tras 6 épocas) Red con una capa oculta de 2 neuronas, tras 20,000 épocas: XOR(0, 0) = 0.013 (debe dar 0) XOR(0, 1) = 0.989 (debe dar 1) XOR(1, 0) = 0.989 (debe dar 1) XOR(1, 1) = 0.011 (debe dar 0)
La neurona sola da exactamente los mismos pesos que la animación de arriba; lo comprobamos ejecutando las dos. Y un detalle honesto: con otros pesos iniciales al azar (por ejemplo, la semilla 3), esa red tan pequeña se queda atascada y no resuelve el XOR. Es uno de los problemas reales del entrenamiento, y una de las razones por las que las redes actuales tienen muchas más neuronas de las que en teoría necesitarían.
De 400 fotocélulas a cientos de miles de millones de pesos
Durante los noventa y los dos mil, las redes neuronales siguieron siendo una opción más entre muchas. Yann LeCun las usó para leer códigos postales escritos a mano, pero eran lentas de entrenar y necesitaban muchos datos. Las dos cosas cambiaron a la vez: internet trajo los datos y las tarjetas gráficas, las GPU, diseñadas para videojuegos, resultaron perfectas para hacer millones de multiplicaciones en paralelo. En 2012, AlexNet, una red profunda de Alex Krizhevsky, Ilya Sutskever y Geoffrey Hinton entrenada con dos GPU, arrasó en el concurso de reconocimiento de imágenes ImageNet. Desde entonces, casi toda la IA es aprendizaje profundo, y en 2024 John Hopfield y Geoffrey Hinton recibieron el Nobel de Física por sus trabajos fundacionales sobre redes neuronales.
Los grandes modelos de lenguaje de hoy siguen hechos de la misma pieza: entradas multiplicadas por pesos, una suma y una función de activación, aunque ya no es el escalón de todo o nada sino curvas suaves, que permiten calcular hacia dónde ajustar cada peso. La diferencia es la escala: en lugar de dos pesos, cientos de miles de millones, organizados en capas y en arquitecturas como los transformers, entrenados con buena parte del texto de internet.
Una copia muy tosca del original
Conviene no tomarse el nombre demasiado al pie de la letra. El cerebro humano tiene unos 86,000 millones de neuronas, y cada una es mucho más compleja que una suma y un umbral: sus dendritas hacen cálculos propios, las señales llevan información en su ritmo y no solo en su intensidad, y las conexiones cambian con la química del cerebro. En 2021, un equipo de la Universidad Hebrea de Jerusalén intentó imitar con una red artificial lo que hace una sola neurona de la corteza cerebral, y necesitó una red profunda de entre cinco y ocho capas.
Además, el cerebro no aprende con retropropagación, o al menos nadie ha encontrado cómo podría hacerlo, y consume unos 20 vatios, menos que una bombilla, mientras que entrenar un modelo grande requiere centros de datos enteros. La neurona artificial fue una inspiración, no una copia: tomó del cerebro una sola idea, que muchas piezas simples, conectadas con fuerzas ajustables, pueden aprender casi cualquier cosa. Ochenta años después, esa idea sigue dando de sí.
Si te gustan los algoritmos que se entienden mejor viéndolos, tenemos más con animación: el código Huffman, los boids, el juego del caos y los epiciclos de Fourier. Y si te interesa hacia dónde va la IA, lee qué es la inteligencia artificial general y la carrera por los chips que la mueven.
Fuentes: W. S. McCulloch y W. Pitts, «A Logical Calculus of the Ideas Immanent in Nervous Activity», Bulletin of Mathematical Biophysics 5, 115–133 (1943); F. Rosenblatt, «The perceptron: A probabilistic model for information storage and organization in the brain», Psychological Review 65(6), 386–408 (1958); el Mark I Perceptron y la crónica del New York Times, en Wikipedia; la vida de Walter Pitts, en Wikipedia; D. E. Rumelhart, G. E. Hinton y R. J. Williams, «Learning representations by back-propagating errors», Nature 323, 533–536 (1986); D. Beniaguev, I. Segev y M. London, «Single cortical neurons as deep artificial neural networks», Neuron 109(17), 2727–2739 (2021); Nobel de Medicina de 1906 y Nobel de Física de 2024. El programa se ejecutó con Python 3.13 y la comparación, con Node.js 24. Las animaciones, los esquemas y la portada: decodigo.com.