Comencemos con lo que realmente es un LLM: una función matemática masiva que predice la siguiente palabra en una secuencia. Eso es todo. Sin conciencia, sin comprensión en el sentido humano, solo coincidencias estadísticas de patrones a una escala que empieza a parecer inquietantemente inteligente. Cuando escribes "La capital de Francia es" en Claude o ChatGPT, el modelo no "sabe" que existe París. Calcula que, basado en miles de millones de ejemplos de entrenamiento, el token "París" tiene la mayor probabilidad de aparecer. Es autocompletado que ha leído todo el internet. La arquitectura que hace esto posible se llama transformer, inventada por investigadores de Google en 2017. Aquí está el desglose paso a paso de cómo el texto se convierte en una respuesta:

  1. Tokenización: Tu texto de entrada se divide en fragmentos llamados tokens (aproximadamente 3/4 de una palabra cada uno). "Hola mundo" se convierte en ["Hola", " mundo"].
  1. Representación: Cada token se convierte en un vector, una lista de cientos de números que representan su significado en un espacio matemático. Las palabras con significados similares se agrupan en esta geometría abstracta.
  1. Mecanismo de atención: Esta es la salsa secreta. El modelo calcula qué tokens deben "prestar atención" a cuáles otros tokens. En "El animal no cruzó la calle porque estaba demasiado cansado", la atención ayuda al modelo a vincular "estaba" con "animal" en lugar de "calle".
  1. Capas de procesamiento: Los LLMs modernos como GPT-4 o Claude 3 tienen docenas de capas de transformers, cada una refinando la representación. Las capas tempranas detectan patrones sintácticos, las intermedias comprenden la semántica, las finales manejan el razonamiento.
  1. Predicción: La capa final produce probabilidades para cada posible siguiente token. El modelo toma muestras de esta distribución (con algo de aleatoriedad para la creatividad) y produce una palabra. Luego retroalimenta esa palabra y predice la siguiente. Repite hasta terminar.

Así es como se ve en pseudocódigo y matemáticas. Esto está simplificado pero captura la lógica central: function generate_text(input_text, max_tokens): tokens = tokenize(input_text) for i in range(max_tokens): # Convert tokens to embeddings (vectors) embeddings = embedding_layer(tokens) # embeddings shape: [sequence_length, embedding_dim] # Apply transformer layers hidden_state = embeddings for layer in transformer_layers: hidden_state = layer.apply(hidden_state) # Get probabilities for next token logits = output_layer(hidden_state[-1]) # Use last position probabilities = softmax(logits) # probabilities shape: [vocabulary_size] # Sample next token (with temperature for randomness) next_token = sample(probabilities, temperature=0.7) tokens.append(next_token) if next_token == END_TOKEN: break return detokenize(tokens) function transformer_layer(hidden_state): # Multi-head self-attention attention_output = multi_head_attention(hidden_state) hidden_state = layer_norm(hidden_state + attention_output) # Residual connection # Feed-forward network ff_output = feed_forward(hidden_state) hidden_state = layer_norm(hidden_state + ff_output) # Residual connection return hidden_state function multi_head_attention(X): # X shape: [seq_len, d_model] # Split into multiple attention heads outputs = [] for head in range(num_heads): # Linear projections to Query, Key, Value Q = X @ W_q[head] # [seq_len, d_k] K = X @ W_k[head] # [seq_len, d_k] V = X @ W_v[head] # [seq_len, d_v] # Scaled dot-product attention # scores[i,j] = how much position i attends to position j scores = (Q @ K.transpose()) / sqrt(d_k) # [seq_len, seq_len] # Mask future positions (can't look ahead) scores = mask_future(scores) # Convert to probabilities attention_weights = softmax(scores) # [seq_len, seq_len] # Apply attention to values output = attention_weights @ V # [seq_len, d_v] outputs.append(output) # Concatenate all heads and project return concatenate(outputs) @ W_o Las matemáticas detrás de la atención es donde sucede la magia. Para cada posición en la secuencia, el modelo calcula: Attention(Q, K, V) = softmax(QK^T / sqrt(d_k)) * V Lo que esto significa: Q (consulta/pregunta) pregunta "¿qué estoy buscando?", K (clave) responde "¿qué contengo?", y V (valor) proporciona "aquí está mi información real". El producto punto QK^T mide la similitud entre preguntas y claves. Las posiciones con alta similitud obtienen altos pesos de atención después del softmax. Esos pesos extraen información relevante de los valores. Por ejemplo, procesando "El gato se sentó en la alfombra porque estaba suave":

  • Al predecir después de "estaba", la consulta para "estaba" calcula alta similitud con la clave para "alfombra" (el softmax podría dar un peso de 0.7) y baja similitud con "gato" (peso de 0.1)
  • Los vectores de valor se ponderan por estas puntuaciones, por lo que "estaba" extrae principalmente de la representación de "alfombra"
  • Esto fluye a través de docenas de capas, cada una refinando las asociaciones

El proceso de entrenamiento es el descenso de gradiente a gran escala: function train_llm(training_data, num_epochs): # Initialize billions of parameters randomly model = initialize_model(num_parameters=175_000_000_000) for epoch in range(num_epochs): for batch in training_data: # Mask out some tokens to predict input_tokens = batch[:-1] # All but last target_tokens = batch[1:] # All but first # Forward pass: predict next tokens predictions = model.forward(input_tokens) # Calculate loss: how wrong were we? loss = cross_entropy(predictions, target_tokens) # Cross entropy: -sum(target * log(prediction)) # Penalizes confident wrong predictions heavily # Backward pass: calculate gradients gradients = compute_gradients(loss, model.parameters) # Update parameters to reduce loss for param, grad in zip(model.parameters, gradients): param -= learning_rate * grad return model Cada actualización de parámetros intenta minimizar la pérdida de entropía cruzada: ¿qué tan sorprendido está el modelo por el token real siguiente? Si predijo "París" con un 95% de probabilidad y "París" era correcto, la pérdida es pequeña. Si predijo "Londres" con un 60% de probabilidad pero "París" era correcto, la pérdida es enorme. Haz esto a través de billones de ejemplos y miles de millones de parámetros, y el modelo aprende la estructura estadística del lenguaje. El proceso de entrenamiento es donde las cosas se ponen caras y salvajes. Estos modelos aprenden a través de un proceso llamado aprendizaje no supervisado en grandes conjuntos de textos: libros, sitios web, repositorios de códigos, artículos científicos. Durante el preentrenamiento, los investigadores muestran al modelo texto con algunas palabras enmascaradas y lo obligan a predecirlas. Cada suposición incorrecta genera una señal de error que empuja miles de millones de parámetros (los números ajustables dentro del modelo) ligeramente más cerca de mejores predicciones. Se informa que GPT-4 tiene más de 1 billón de parámetros y costó más de 100 millones de dólares entrenar en decenas de miles de GPUs funcionando durante meses. Después del preentrenamiento viene el ajuste fino, donde los entrenadores humanos califican las respuestas del modelo, enseñándole a ser útil en lugar de solo preciso. Esta es la razón por la que Claude no escribirá tu manifiesto o ChatGPT se niega a ciertas solicitudes. El aprendizaje por refuerzo a partir del feedback humano (RLHF) literalmente rehace las distribuciones de probabilidad para evitar salidas tóxicas. El modelo aprende que ciertos patrones de respuesta obtienen puntuaciones más altas de los humanos, por lo que favorece esos patrones. Ahora, aquí está la razón por la que las industrias de predicción están siendo avasalladas. Cualquier dominio donde el éxito significa reconocer patrones y pronosticar resultados es, fundamentalmente, un problema de LLM en su núcleo. Predicción del clima? Coincidencia de patrones de datos atmosféricos históricos. Comercio de acciones? Encontrar correlaciones en movimientos de precios y sentimiento de noticias. Diagnóstico médico? Coincidencia de síntomas con patrones de enfermedades a partir de millones de historias clínicas. Revisión de documentos legales? Identificar precedentes y cláusulas contractuales relevantes. Atención al cliente? Predecir qué respuesta resolverá el problema basándose en tickets anteriores. La ventaja de la IA es brutal y simple: escala. Un radiólogo humano puede revisar 50,000 radiografías en una carrera. Un modelo de IA se entrena en 50 millones. Un analista de fondos de cobertura lee cientos de informes trimestrales de ganancias. Un LLM procesa cada transcripción de llamada de ganancias, presentación ante la SEC y nota de analista publicada a nivel mundial en tiempo real. La ventaja del reconocimiento de patrones se compone hasta que la experiencia humana se vuelva decorativa en lugar de funcional. Ya estamos viendo cómo la toma de control acelera. Bloomberg GPT, entrenado específicamente en datos financieros, supera a los analistas humanos en la predicción de movimientos del mercado a partir de noticias. AlphaFold de DeepMind resolvió el problema del plegamiento de proteínas que confundió a biólogos durante 50 años tratándolo como una tarea de predicción. GitHub Copilot escribe el 40% del código en repositorios donde está habilitado. Estos no son herramientas estrechas que ayudan a los humanos, son tecnologías de reemplazo que hacen obsoletas conjuntos de habilidades enteros. La verdad incómoda es que la mayoría del trabajo basado en el conocimiento es la predicción disfrazada de experiencia. Los abogados predicen resultados de casos y redactan documentos siguiendo plantillas. Los contadores predicen responsabilidad tributaria y riesgo de auditoría. Los mercadólogos predicen qué mensaje resonará con qué audiencia. Los maestros predicen qué explicación aclarará un concepto. Los médicos predicen qué tratamiento curará qué dolencia. Si tu trabajo implica mirar datos y decir "basado en X, creo que sucederá Y", estás en el radio de explosión. La única pregunta es cuándo.