0Pricing
AI Prompt Engineering · Lección

Cómo genera respuestas la IA

Predicción de tokens, probabilidad y por qué la IA no «piensa» como los seres humanos.

Cómo genera respuestas la IA es una lección gratuita de AI Prompt Engineering en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de AI Prompt Engineering, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de AI Prompt Engineering incluye 4 lecciones en total.

El texto como problema de probabilidad

En esencia, un modelo de lenguaje hace una sola cosa: predecir el siguiente token dados todos los tokens anteriores.

Un token es una pequeña unidad de texto, aproximadamente una palabra o un fragmento de palabra. El modelo asigna una probabilidad a cada token de su vocabulario y elige uno. Después repite el proceso, token a token, hasta generar una respuesta completa.

Qué es un token

Los tokens son los átomos del procesamiento de texto de los LLM. El texto en inglés se divide aproximadamente así:

  • Palabras frecuentes → 1 token cada una (the, run)
  • Palabras menos frecuentes → se dividen en 2 o 3 tokens (running → run + ning)
  • Los signos de puntuación y los espacios → a menudo son tokens independientes

Los modelos como GPT-4o y Claude utilizan tokenizadores que gestionan más de 100k entradas de vocabulario, incluidos subwords de muchos idiomas.

import tiktoken

encoding = tiktoken.encoding_for_model('gpt-4o')

sentence = 'The temperature parameter controls randomness in token selection.'
tokens = encoding.encode(sentence)
token_strings = [encoding.decode([t]) for t in tokens]

print(f'Sentence: {sentence}')
print(f'Token count: {len(tokens)}')
print(f'Tokens: {token_strings}')

Generación autorregresiva

La generación es autorregresiva: cada token nuevo se añade a la entrada antes de predecir el siguiente.

Por tanto, al generar «El cielo es azul», el modelo:

  • Ve «El» → predice «cielo»
  • Ve «El cielo» → predice «es»
  • Ve «El cielo es» → predice «azul»
  • Ve «El cielo es azul» → predice el fin de la secuencia

Por eso la generación se ralentiza en las salidas muy largas: cada token requiere una pasada completa hacia adelante.

# Simulated autoregressive token-by-token output via streaming
import openai

client = openai.OpenAI(api_key='sk-your-key-here')

stream = client.chat.completions.create(
    model='gpt-4o',
    stream=True,     # receive tokens as they are generated
    messages=[{'role': 'user', 'content': 'Name five planets in our solar system.'}]
)

print('Tokens arriving one by one:')
for chunk in stream:
    delta = chunk.choices[0].delta.content
    if delta:
        print(delta, end='', flush=True)
print()  # newline at end

Temperatura: controlar la aleatoriedad

La temperatura es un número entre 0 y 2 que escala la distribución de probabilidades antes del muestreo:

  • Temperatura 0: siempre elegir el token más probable; determinista y repetitiva
  • Temperatura 1: muestrear según las probabilidades originales; equilibrada
  • Temperatura 2: aplanar las probabilidades; muy aleatoria y, a veces, incoherente

Utilice una temperatura baja para tareas fácticas y una más alta para trabajos creativos.

import openai

client = openai.OpenAI(api_key='sk-your-key-here')

prompt = 'Continue this sentence with one word: The ocean is'

for temp in [0.0, 0.7, 1.5]:
    response = client.chat.completions.create(
        model='gpt-4o',
        temperature=temp,
        max_tokens=5,
        messages=[{'role': 'user', 'content': prompt}]
    )
    word = response.choices[0].message.content.strip()
    print(f'Temperature {temp}: "{word}"')

Por qué las respuestas varían entre ejecuciones

Incluso con el mismo prompt, dos ejecuciones del mismo modelo pueden producir resultados diferentes. Esto ocurre porque:

  • El muestreo es probabilístico: el modelo obtiene valores de una distribución, no de una tabla de consulta
  • Pequeñas diferencias numéricas en las operaciones de coma flotante pueden acumularse
  • El paralelismo del hardware introduce no determinismo

Establezca temperature=0 y seed (si son compatibles) para maximizar la reproducibilidad.

import openai

client = openai.OpenAI(api_key='sk-your-key-here')

prompt = 'Give me a one-word color that feels calm.'

for run in range(3):
    response = client.chat.completions.create(
        model='gpt-4o',
        temperature=1.0,   # randomness ON
        max_tokens=5,
        messages=[{'role': 'user', 'content': prompt}]
    )
    print(f'Run {run + 1}: {response.choices[0].message.content.strip()}')

# For reproducible outputs use seed + temperature=0
response = client.chat.completions.create(
    model='gpt-4o',
    temperature=0,
    seed=42,
    max_tokens=5,
    messages=[{'role': 'user', 'content': prompt}]
)
print(f'Deterministic: {response.choices[0].message.content.strip()}')

Muestreo top-p

Top-p (muestreo de núcleo) es otra forma de controlar la aleatoriedad. En lugar de escalar todas las probabilidades, restringe el muestreo al conjunto más pequeño de tokens cuya probabilidad acumulada supera p.

  • top_p=0.1: solo los tokens principales (conservador)
  • top_p=0.9: un conjunto más amplio (creativo)
  • top_p=1.0: todos los tokens (distribución completa)

En la práctica, la mayoría de los equipos ajustan la temperatura y dejan top-p en 1.0.

import openai

client = openai.OpenAI(api_key='sk-your-key-here')

# Conservative generation: top_p=0.1 restricts to high-confidence tokens
response_conservative = client.chat.completions.create(
    model='gpt-4o',
    top_p=0.1,
    max_tokens=30,
    messages=[{'role': 'user', 'content': 'What is the capital of Japan?'}]
)

# Creative generation: top_p=0.95 allows broader token pool
response_creative = client.chat.completions.create(
    model='gpt-4o',
    top_p=0.95,
    max_tokens=30,
    messages=[{'role': 'user', 'content': 'Write a poetic one-liner about the moon.'}]
)

print('Conservative:', response_conservative.choices[0].message.content)
print('Creative:    ', response_creative.choices[0].message.content)

Sin comprensión real — Coincidencia de patrones

Los LLM no comprenden el lenguaje como lo hacen los seres humanos. Son sistemas extremadamente sofisticados de coincidencia de patrones, entrenados con corpus de texto enormes.

Cuando el modelo responde a «¿Qué es la fotosíntesis?», no está recuperando un dato almacenado: está generando la secuencia de tokens que, desde el punto de vista estadístico, sigue al patrón de la pregunta, basándose en haber visto millones de documentos similares durante el entrenamiento.

# Demonstration: the model can produce plausible-sounding but wrong answers
import anthropic

client = anthropic.Anthropic(api_key='sk-ant-your-key-here')

# Asking about something nonsensical — model may still try to answer
response = client.messages.create(
    model='claude-opus-4-5',
    max_tokens=128,
    messages=[{
        'role': 'user',
        'content': (
            'What is the boiling point of happiness in degrees Celsius? '
            'Please just say "I cannot answer this" if the question makes no sense.'
        )
    }]
)
print(response.content[0].text)

Entrenamiento frente a inferencia

El «conocimiento» del modelo quedó congelado durante el entrenamiento con un corpus de texto extenso. Durante la inferencia (cuando usted envía un prompt), el modelo genera texto basándose en ese conocimiento congelado; no está aprendiendo ni buscando en Internet.

Esto significa que no puede conocer acontecimientos posteriores a su fecha de corte de entrenamiento, acceder a URL ni verificar si un hecho ha cambiado desde el entrenamiento.

import anthropic

client = anthropic.Anthropic(api_key='sk-ant-your-key-here')

# Asking the model about its own knowledge cutoff
response = client.messages.create(
    model='claude-opus-4-5',
    max_tokens=128,
    messages=[{
        'role': 'user',
        'content': (
            'What is your knowledge cutoff date? '
            'And can you access the internet right now to look up today\'s news?'
        )
    }]
)
print(response.content[0].text)

Qué ocurre dentro de una pasada hacia adelante

A grandes rasgos, cada predicción de un token implica:

  1. Convertir todos los tokens de entrada en embeddings numéricos
  2. Pasarlos por muchas capas transformer (atención + feed-forward)
  3. Generar una distribución de probabilidad sobre todo el vocabulario
  4. Muestrear un token de esa distribución

Los modelos modernos tienen miles de millones de parámetros que determinan esta transformación, todos aprendidos durante el entrenamiento a partir de texto escrito por seres humanos.

# You can inspect logprobs (token probabilities) to see the model's confidence
import openai

client = openai.OpenAI(api_key='sk-your-key-here')

response = client.chat.completions.create(
    model='gpt-4o',
    max_tokens=5,
    logprobs=True,
    top_logprobs=3,
    messages=[{'role': 'user', 'content': 'The opposite of hot is'}]
)

for token_info in response.choices[0].logprobs.content:
    print(f'Chosen token: "{token_info.token}"')
    for alt in token_info.top_logprobs:
        import math
        prob = round(math.exp(alt.logprob) * 100, 1)
        print(f'  Option "{alt.token}": {prob}% probability')

Secuencias de parada

Las secuencias de parada indican al modelo que detenga la generación cuando produzca una cadena específica. Resultan útiles para:

  • Evitar que el modelo genere más de una respuesta en una lista
  • Detenerse ante un delimitador como ### o ---END---
  • Forzar salidas de una sola línea

Sin secuencias de parada, el modelo genera texto hasta alcanzar max_tokens o predecir un token de fin de secuencia.

import openai

client = openai.OpenAI(api_key='sk-your-key-here')

# Stop after the first item in a numbered list
response = client.chat.completions.create(
    model='gpt-4o',
    max_tokens=64,
    stop=['2.'],   # halt as soon as '2.' appears
    messages=[{
        'role': 'user',
        'content': 'List 5 programming languages, numbered 1 through 5.'
    }]
)
print(response.choices[0].message.content)
print('Stop reason:', response.choices[0].finish_reason)

Implicaciones prácticas para quienes escriben prompts

Comprender los mecanismos de generación le ayuda a escribir mejores prompts:

  • Use una temperatura de 0 para tareas que requieran una salida coherente y factual
  • Use una temperatura de 0.7-1.0 para la escritura creativa
  • Verifique los hechos: el modelo genera texto verosímil, no una verdad garantizada
  • Use secuencias de parada para controlar con precisión la longitud de la salida
  • Prompts breves → salidas más creativas, pero menos controladas
  • Prompts detallados → salidas más restringidas y centradas
import anthropic

client = anthropic.Anthropic(api_key='sk-ant-your-key-here')

# Low temperature for factual classification
fact_response = client.messages.create(
    model='claude-opus-4-5',
    max_tokens=8,
    temperature=0,   # deterministic
    messages=[{'role': 'user', 'content': 'Is Paris the capital of France? Answer YES or NO only.'}]
)
print('Factual (temp=0):', fact_response.content[0].text.strip())

# Higher temperature for creative tasks
creative_response = client.messages.create(
    model='claude-opus-4-5',
    max_tokens=64,
    temperature=1.0,
    messages=[{'role': 'user', 'content': 'Write a surprising one-line poem about code.'}]
)
print('Creative (temp=1):', creative_response.content[0].text.strip())

Comprobación de conocimientos

Ha aprendido cómo los LLM generan texto token a token. Compruebe ahora su comprensión de la temperatura.

Un desarrollador está creando un chatbot de atención al cliente que debe ofrecer respuestas coherentes y precisas a preguntas sobre facturación. ¿Qué valor de temperatura es el más adecuado?

Cómo genera respuestas la IA — Resumen

Ahora comprende los mecanismos que intervienen en cada respuesta de la IA:

  • Los modelos predicen el siguiente token uno a uno: generación autorregresiva
  • La temperatura controla cuánta aleatoriedad se introduce en la selección de tokens
  • Top-p restringe el muestreo a un núcleo de tokens con alta probabilidad
  • El modelo no comprende: realiza coincidencia de patrones a gran escala
  • El conocimiento queda congelado durante el entrenamiento: no hay datos en tiempo real ni acceso a Internet
  • Las secuencias de parada le permiten controlar exactamente dónde termina la salida

Preguntas frecuentes

¿La lección «Cómo genera respuestas la IA» es gratis?

Sí — el texto completo de «Cómo genera respuestas la IA» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de AI Prompt Engineering, actualiza a CoddyKit PRO. El curso de AI Prompt Engineering incluye 4 lecciones en total.

¿Qué aprenderé en «Cómo genera respuestas la IA»?

Predicción de tokens, probabilidad y por qué la IA no «piensa» como los seres humanos. Practicas AI Prompt Engineering con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar AI Prompt Engineering?

No se requiere experiencia previa. AI Prompt Engineering en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «Cómo genera respuestas la IA»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de AI Prompt Engineering?

Sí. Cada lección de AI Prompt Engineering incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Comprender la interfaz de chat
  2. Tipos de solicitudes que puede gestionar la IA
  3. Cómo genera respuestas la IA
  4. Qué no puede hacer la IA
← Volver a AI Prompt Engineering