tl;dr Un modelo de IA es una función con millones (o billones) de parámetros ajustados con datos. El machine learning es el proceso de ajustarlos, el backpropagation es el algoritmo que hace ese ajuste posible, y los LLMs como Claude son la versión escalada de esa misma idea aplicada a texto. Aquí desarmamos toda la cadena, con código y referencias para profundizar.

Es muy fácil perderse entre tanto término: IA, machine learning, deep learning, redes neuronales, transformers, LLMs… Y la “infoxicación” de redes sociales no ayuda: o todo es magia que va a reemplazarte mañana, o todo es humo de marketing. La realidad, como siempre, está en el medio y es bastante más interesante.

En este artículo vamos a recorrer la cadena completa: desde qué es realmente un modelo de IA, pasando por los fundamentos del machine learning y el algoritmo de backpropagation (con código incluido), hasta cómo funcionan los LLMs modernos como Claude y cómo integrarlos en tus proyectos.

Manifiesto de ética de siempre: los LLMs son sistemas estocásticos que pueden producir razonamientos brillantes o alucinaciones con total confianza. Verifica sus afirmaciones con fuentes de rigor. Este artículo incluye referencias al final precisamente para eso.

---

¿Qué es un modelo de IA? (Spoiler: es una función)

Quitémosle el misticismo de entrada: un modelo de inteligencia artificial es una función matemática con parámetros ajustables.

$y = f(x; \theta)$

Donde $x$ es la entrada (una imagen, un texto, una tabla de datos), $y$ es la salida (una etiqueta, una predicción, el siguiente token) y $\theta$ son los parámetros: números que determinan el comportamiento de la función.

La diferencia entre programación clásica y machine learning está en quién escribe las reglas:

	Programación clásica	Machine Learning
Entrada	Datos + reglas	Datos + respuestas esperadas
Salida	Respuestas	Reglas (parámetros aprendidos)
Ejemplo	if temperatura > 38: fiebre	El modelo aprende el umbral viendo miles de casos

La escala de estos modelos varía brutalmente:

• Una regresión lineal: 2 parámetros (pendiente y ordenada).
• Una red convolucional para clasificar imágenes (ResNet-50): ~25 millones.
• Un LLM moderno: cientos de miles de millones de parámetros.

Pero el principio es el mismo en todos: encontrar los valores de $\theta$ que hacen que la función se comporte como queremos. Y eso nos lleva al siguiente punto.

Fundamentos de machine learning: aprender es optimizar

El machine learning se reduce a tres ingredientes:

1. Los datos

Sin datos no hay aprendizaje. Según cómo se presenten, tenemos tres paradigmas:

• Aprendizaje supervisado: cada ejemplo viene con su respuesta correcta (imagen → “gato”). Es el caballo de batalla de la industria: clasificación de spam, predicción de demanda, diagnóstico por imagen.
• Aprendizaje no supervisado: solo hay datos, sin etiquetas. El modelo encuentra estructura: clustering de clientes, detección de anomalías, reducción de dimensionalidad.
• Aprendizaje por refuerzo: un agente aprende interactuando con un entorno y recibiendo recompensas. Es la base de AlphaGo y también del RLHF (Reinforcement Learning from Human Feedback) con el que se afinan los LLMs modernos.

2. La función de pérdida

Necesitamos un número que mida qué tan mal lo está haciendo el modelo. A esa medida la llamamos función de pérdida (loss function). Por ejemplo, el error cuadrático medio para regresión:

$L = \frac{1}{n}\sum_{i=1}^{n}(y_i - \hat{y}_i)^2$

O la entropía cruzada para clasificación (y para predecir el siguiente token en un LLM). El objetivo del entrenamiento es uno solo: minimizar la pérdida.

3. El optimizador

Aquí entra el descenso de gradiente (gradient descent): calcular hacia dónde crece el error y mover los parámetros en la dirección contraria, en pasos pequeños controlados por la tasa de aprendizaje (learning rate):

$\theta_{nuevo} = \theta_{viejo} - \eta \cdot \nabla_\theta L$

Imagina que estás en una montaña con niebla total y quieres bajar al valle: tocas el suelo, detectas la pendiente, y das un paso cuesta abajo. Repites millones de veces. Eso es entrenar un modelo.

El problema es: ¿cómo calculas esa pendiente cuando tu “montaña” es una red neuronal con millones de parámetros encadenados en capas? Ahí entra el protagonista del siguiente apartado.

Backpropagation: el algoritmo que sostiene todo el deep learning

El backpropagation (retropropagación del error) es el algoritmo que calcula eficientemente el gradiente de la pérdida respecto a cada parámetro de la red. Fue popularizado por Rumelhart, Hinton y Williams en 1986, y sigue siendo el corazón de todo el deep learning moderno, incluido el entrenamiento de Claude o cualquier otro LLM.

La idea central es la regla de la cadena del cálculo diferencial. Una red neuronal es una composición de funciones:

$\hat{y} = f_3(f_2(f_1(x)))$

Para saber cuánta “culpa” tiene cada parámetro en el error final, propagamos el error hacia atrás, capa por capa, multiplicando derivadas locales:

1. Forward pass: la entrada atraviesa la red y produce una predicción.
2. Cálculo de la pérdida: comparamos la predicción con la respuesta correcta.
3. Backward pass: el error se propaga de la salida hacia la entrada, calculando el gradiente de cada parámetro.
4. Actualización: el optimizador ajusta cada parámetro según su gradiente.

Backpropagation en 30 líneas de Python

Nada como verlo en código. Una red mínima (2 entradas → 2 neuronas ocultas → 1 salida) aprendiendo la función XOR, solo con NumPy:

import numpy as np

# Datos: XOR (el clásico problema no lineal)
X = np.array([[0,0],[0,1],[1,0],[1,1]])
y = np.array([[0],[1],[1],[0]])

# Inicialización de pesos
rng = np.random.default_rng(42)
W1, b1 = rng.normal(size=(2, 2)), np.zeros((1, 2))
W2, b2 = rng.normal(size=(2, 1)), np.zeros((1, 1))

sigmoid = lambda z: 1 / (1 + np.exp(-z))
lr = 0.5  # learning rate

for epoch in range(10000):
    # --- Forward pass ---
    h = sigmoid(X @ W1 + b1)        # capa oculta
    y_hat = sigmoid(h @ W2 + b2)    # salida

    # --- Pérdida (error cuadrático medio) ---
    loss = np.mean((y - y_hat) ** 2)

    # --- Backward pass (regla de la cadena) ---
    d_yhat = 2 * (y_hat - y) / len(X)
    d_z2 = d_yhat * y_hat * (1 - y_hat)      # derivada de sigmoid
    d_W2 = h.T @ d_z2
    d_h = d_z2 @ W2.T
    d_z1 = d_h * h * (1 - h)
    d_W1 = X.T @ d_z1

    # --- Actualización (descenso de gradiente) ---
    W2 -= lr * d_W2; b2 -= lr * d_z2.sum(axis=0)
    W1 -= lr * d_W1; b1 -= lr * d_z1.sum(axis=0)

print(y_hat.round(2))  # ≈ [[0], [1], [1], [0]] — aprendió XOR

Eso es todo el truco. PyTorch y TensorFlow hacen exactamente esto, pero con diferenciación automática (autograd): construyen el grafo de operaciones y calculan los gradientes por ti. Cuando escribes loss.backward() en PyTorch, estás invocando backpropagation sobre un grafo de millones de nodos.

Lo fascinante es que entrenar un LLM de frontera usa este mismo algoritmo, solo que con miles de GPUs, billones de tokens y meses de cómputo.

De las redes neuronales a los LLMs: la arquitectura Transformer

Un Large Language Model es una red neuronal entrenada para una tarea engañosamente simple: predecir el siguiente token. De esa tarea humilde, a escala suficiente, emergen capacidades de traducción, razonamiento, programación y síntesis.

Las piezas clave:

Tokens

Los LLMs no ven letras ni palabras: ven tokens, fragmentos de texto de un vocabulario fijo (~100K entradas). “Inteligencia artificial” pueden ser 3–5 tokens. Esto explica varias rarezas: por qué los modelos cuentan mal las letras de una palabra, por qué el precio de las APIs se mide en tokens, y por qué el “context window” (la memoria de trabajo del modelo) se mide en tokens también.

Atención (Attention)

El paper Attention Is All You Need (Vaswani et al., 2017) introdujo la arquitectura Transformer, donde cada token puede “mirar” a todos los demás tokens del contexto y decidir cuáles son relevantes para interpretarlo. En la frase “el banco estaba cerrado porque era feriado”, el mecanismo de atención permite que “banco” se asocie con “feriado” y no con “río”.

Escala y leyes de escalamiento

Kaplan et al. (2020) mostraron que el rendimiento de los LLMs mejora de forma predecible al aumentar parámetros, datos y cómputo — las famosas scaling laws. Esa predictibilidad es lo que justificó las inversiones masivas que produjeron GPT-3, y luego los modelos actuales.

Alineamiento: de predecir texto a ser útil

Un modelo que solo predice el siguiente token es un loro estadístico peligrosamente convincente. Para convertirlo en asistente se aplican técnicas de alineamiento: RLHF y, en el caso de Anthropic, Constitutional AI — entrenar el modelo para que critique y revise sus propias respuestas según un conjunto de principios explícitos.

Claude en la práctica: cómo usar un LLM en tus proyectos

Bajemos a tierra. Hoy la familia de modelos de Anthropic cubre tres niveles de costo/capacidad:

Modelo	Para qué sirve	Ejemplo de uso
Claude Opus 4.8	Tareas complejas, razonamiento profundo, trabajo agéntico de largo aliento	Refactorizaciones grandes, investigación, análisis de documentos extensos
Claude Sonnet 4.6	Balance velocidad/inteligencia	Chatbots de producción, asistentes de código, pipelines de extracción
Claude Haiku 4.5	Velocidad y costo mínimo	Clasificación, moderación, autocompletado, tareas de alto volumen

Tu primera llamada a la API

Con el SDK oficial de Python:

from anthropic import Anthropic

client = Anthropic()  # lee ANTHROPIC_API_KEY del entorno

response = client.messages.create(
    model="claude-opus-4-8",
    max_tokens=16000,
    thinking={"type": "adaptive"},  # el modelo decide cuánto "pensar"
    system="Eres un asistente técnico. Responde en español, con ejemplos.",
    messages=[
        {"role": "user", "content": "Explícame el backpropagation en 3 párrafos."}
    ],
)

for block in response.content:
    if block.type == "text":
        print(block.text)

Tres conceptos que conviene dominar desde el día uno:

1. System prompt: define el rol y las reglas del asistente. Es tu herramienta de control más barata y efectiva.
2. Thinking adaptativo: los modelos recientes pueden razonar internamente antes de responder; con {"type": "adaptive"} el propio modelo decide cuánto esfuerzo dedicar.
3. Tool use (function calling): puedes declarar herramientas (buscar en tu base de datos, llamar a tu API) y el modelo decide cuándo invocarlas. Es la base de los agentes.

Casos de uso donde los LLMs brillan (y donde no)

Brillan en:

• Asistencia de código: generación, revisión, explicación de bases de código legadas. Herramientas como Claude Code llevan esto al terminal con acceso a tu repositorio.
• Extracción estructurada: convertir texto libre (correos, PDFs, tickets) en JSON validado contra un esquema.
• RAG (Retrieval-Augmented Generation): responder preguntas sobre tus documentos, recuperando contexto relevante e inyectándolo en el prompt. Reduce alucinaciones porque el modelo cita material real.
• Síntesis y resumen: condensar reuniones, papers o hilos interminables.

No brillan en:

• Aritmética y conteo exacto (para eso dales una calculadora vía tool use).
• Hechos posteriores a su corte de entrenamiento (para eso, búsqueda web o RAG).
• Tareas donde un error es inaceptable sin supervisión humana: son sistemas probabilísticos; diseña siempre con verificación.

La regla de oro: trata al LLM como un colaborador brillante pero falible, no como una base de datos ni como un oráculo.

Conclusión: la cadena completa

Recapitulemos el viaje:

1. Un modelo de IA es una función parametrizada.
2. El machine learning ajusta esos parámetros minimizando una función de pérdida con descenso de gradiente.
3. El backpropagation hace ese cálculo de gradientes computacionalmente viable, capa por capa, con la regla de la cadena.
4. Los Transformers aplican esa maquinaria a la predicción del siguiente token, con el mecanismo de atención como pieza clave.
5. A escala suficiente, y con técnicas de alineamiento, obtienes LLMs como Claude: útiles, versátiles y falibles.

No hay magia: hay cálculo diferencial, mucha ingeniería y una escala difícil de imaginar. Entender esta cadena te da dos superpoderes: dejas de tenerle miedo (o fe ciega) a la IA, y empiezas a usarla con criterio de ingeniero — sabiendo qué pedirle, cómo verificarla y dónde encaja en tu arquitectura.

Si quieres ensuciarte las manos, mi recomendación: implementa el XOR de este artículo desde cero, luego pasa a la serie Neural Networks: Zero to Hero de Karpathy, y en paralelo crea una API key y haz tu primera llamada a Claude. La teoría y la práctica se refuerzan mutuamente.

---

Referencias

Papers fundacionales

• Rumelhart, D., Hinton, G., Williams, R. (1986). Learning representations by back-propagating errors. Nature 323.
• Vaswani, A. et al. (2017). Attention Is All You Need. arXiv:1706.03762.
• Kaplan, J. et al. (2020). Scaling Laws for Neural Language Models. arXiv:2001.08361.
• Brown, T. et al. (2020). Language Models are Few-Shot Learners (GPT-3). arXiv:2005.14165.
• Bai, Y. et al. (2022). Constitutional AI: Harmlessness from AI Feedback. arXiv:2212.08073.

Libros y cursos

• Goodfellow, I., Bengio, Y., Courville, A. Deep Learning. MIT Press (gratuito en línea).
• Karpathy, A. Neural Networks: Zero to Hero (serie de video, construye backprop y un GPT desde cero).
• 3Blue1Brown. Neural Networks (la mejor visualización de backpropagation que existe).
• Stanford CS231n. Deep Learning for Computer Vision (notas del curso, excelente capítulo de optimización y backprop).

Documentación técnica

• Anthropic. Claude Developer Platform — Documentación.
• Anthropic. Claude Code — Documentación.
• PyTorch. Autograd: Automatic Differentiation.
• scikit-learn. User Guide (machine learning clásico en Python).

---

#Inteligencia Artificial, #Machine Learning, #LLM, #Claude, #Backpropagation, #Deep Learning,