Módulo 2: Zero-Shot y Few-Shot Prompting

1. Introducción: Las Dos Técnicas Fundamentales

Descripción de la cápsula

Zero-shot y few-shot prompting son la base de todo prompt engineering. Sin entender cuándo usar cada técnica, desperdicias tokens (few-shot cuando zero-shot basta) u obtienes resultados inconsistentes (zero-shot cuando few-shot es necesario). La mayoría de tareas del mundo real se resuelven con una de estas dos técnicas — dominarlas te permite evaluar correctamente si necesitas algo más complejo como Chain-of-Thought o ReAct.

Zero-shot significa dar al modelo una instrucción sin ejemplos. El modelo infiere la tarea solo con la descripción, aprovechando su conocimiento pre-entrenado. Few-shot significa incluir 2-10 ejemplos de input→output que muestran el patrón deseado. El modelo aprende por analogía, no por actualización de parámetros (eso sería fine-tuning). Ambas técnicas son complementarias: zero-shot es más económico y rápido; few-shot es más preciso para tareas con formatos específicos o dominios nicho.

Por qué importa: Este módulo te da el framework de decisión y los patrones concretos para ambas técnicas. El Few-Shot Classification System que construyes en la cápsula 08 es reutilizable: puedes llevarlo a tus proyectos reales con tus propias categorías y banco de ejemplos.

Zero-Shot: Definición, Casos de Uso y Limitaciones

Qué es zero-shot

El modelo recibe solo la instrucción y el input. No hay ejemplos previos. El modelo usa su conocimiento pre-entrenado para inferir qué hacer con esa instrucción.

from openai import OpenAI
from dotenv import load_dotenv

load_dotenv()
client = OpenAI()

# Zero-shot puro: instrucción + input, sin un solo ejemplo
response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {
            "role": "system",
            "content": "Clasifica el sentimiento como POSITIVO, NEGATIVO o NEUTRO. Responde solo con la categoría."
        },
        {
            "role": "user",
            "content": "El producto llegó a tiempo y superó mis expectativas."
        }
    ],
    temperature=0,
    max_tokens=10
)
print(response.choices[0].message.content)
# Output: POSITIVO

Por qué funciona zero-shot

Los LLMs fueron entrenados en corpus masivos donde clasificación de sentimiento, traducción, resumen y extracción de entidades aparecen miles de veces. Cuando dices "clasifica el sentimiento", el modelo ya internalizó el concepto. Zero-shot aprovecha ese conocimiento pre-entrenado directamente, sin necesidad de ejemplos.

Analogía: Es como pedirle a un programador senior "Escribe una función que invierta una lista en Python." No necesitas darle ejemplos de cómo invertir listas — ya lo sabe. Zero-shot funciona igual para tareas que el modelo ya conoce bien.

Cuándo zero-shot es suficiente

Tareas comunes: Traducción, resumen, clasificación de sentimiento, extracción de entidades — el modelo las conoce bien del pre-entrenamiento
Formatos estándar: No necesitas ejemplos para "devuelve JSON" o "haz una lista de bullets"
Dominios generales: Noticias, reseñas de productos, texto genérico de negocio
Costo y latencia críticos: Cada ejemplo adds tokens; zero-shot minimiza ambos
Prototipado rápido: Validar concepto antes de invertir en curación de ejemplos

Cuándo zero-shot falla

El output tiene formato muy específico que el modelo no conoce (ej: schema JSON interno de tu empresa)
Las categorías son jerga interna o de dominio muy especializado
Hay ambigüedad en la tarea que solo los ejemplos pueden resolver
Necesitas consistency extrema entre llamadas para parsear programáticamente
El task requiere seguir un patrón de output muy particular

Few-Shot: Definición, Casos de Uso y Limitaciones

Qué es few-shot

Incluyes 2-10 ejemplos de la forma input → output deseado. El modelo infiere el patrón y lo aplica al nuevo input. "Few" significa pocos — y pocos son suficientes porque los LLMs son excelentes en reconocimiento de patrones.

Diferencia importante vs fine-tuning: Few-shot provee ejemplos en el prompt. Fine-tuning actualiza los pesos del modelo. Few-shot es más rápido, flexible y reversible. Fine-tuning es más costoso y permanente. Para la mayoría de tareas de producción, few-shot basta.

from openai import OpenAI

client = OpenAI()

# Few-shot: 3 ejemplos antes de la tarea real
FEW_SHOT_TEMPLATE = """
Clasifica el tipo de consulta del cliente.
Categorías: FACTURACIÓN, TÉCNICO, CUENTA, OTRO.

Ejemplo 1:
Consulta: "No puedo acceder a mi cuenta desde ayer"
Tipo: TÉCNICO

Ejemplo 2:
Consulta: "¿Puedo cambiar mi plan de facturación?"
Tipo: FACTURACIÓN

Ejemplo 3:
Consulta: "Quiero cancelar mi suscripción"
Tipo: CUENTA

Ahora clasifica:
Consulta: {consulta}
Tipo:"""

def classify_few_shot(consulta: str) -> str:
    prompt = FEW_SHOT_TEMPLATE.format(consulta=consulta)
    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "user", "content": prompt}],
        temperature=0,
        max_tokens=15
    )
    return response.choices[0].message.content.strip()

# Test
consultas = [
    "Mi factura de marzo tiene un cargo incorrecto",
    "La app no carga las imágenes",
    "Quiero actualizar mi contraseña"
]

for c in consultas:
    print(f"{c}: {classify_few_shot(c)}")

Output:

Mi factura de marzo tiene un cargo incorrecto: FACTURACIÓN
La app no carga las imágenes: TÉCNICO
Quiero actualizar mi contraseña: CUENTA

Por qué funcionan los ejemplos

Los LLMs son excelentes en reconocimiento de patrones en contexto. Al ver 3 pares input → output, el modelo infiere: "Dado este patrón, el siguiente output debe seguir la misma estructura." Los ejemplos:

Anclan el formato: Si los ejemplos devuelven una palabra, el modelo devuelve una palabra
Reducen ambigüedad: "TÉCNICO vs CUENTA" queda claro cuando ves ejemplos de cada uno
Definen el dominio: Ejemplos de categorías internas enseñan al modelo tu jerga específica

Cuándo few-shot es necesario

Formatos custom: Tu output tiene estructura específica que el modelo no conoce por defecto
Dominios nicho: Categorías internas, jerga de negocio, edge cases de tu empresa
Consistency crítica: Los ejemplos anclan el formato y reducen variabilidad entre llamadas
Tareas ambiguas: "Clasifica" sin ejemplos puede dar formatos inconsistentes ("POSITIVO", "Positivo", "positivo")
Accuracy requerida > 90%: En dominios especializados, few-shot puede dar +10-20% accuracy vs zero-shot

Cuándo few-shot puede ser contraproducente

Los ejemplos no cubren casos edge → el modelo extrapola mal
Los ejemplos tienen sesgo de selección → el modelo solo clasifica como las categorías de los ejemplos
Demasiados ejemplos de una categoría → sesgo hacia esa categoría
Los ejemplos son inconsistentes → el modelo aprende el patrón equivocado

Comparación Side-by-Side

from openai import OpenAI
import time

client = OpenAI()

# Tarea: clasificar tickets con 12 categorías internas
CATEGORIAS = [
    "ACCESO", "FACTURA", "RENDIMIENTO", "ERROR", "INTEGRACION",
    "CONFIGURACION", "DATOS", "MIGRACION", "SEGURIDAD", 
    "CAPACITACION", "ESCALAMIENTO", "OTRO"
]

# Zero-shot: describe las categorías pero sin ejemplos
def classify_zero_shot(ticket: str) -> str:
    cats = ", ".join(CATEGORIAS)
    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {
                "role": "system",
                "content": f"Clasifica en UNA categoría: {cats}. Solo la categoría, nada más."
            },
            {"role": "user", "content": ticket}
        ],
        temperature=0,
        max_tokens=15
    )
    return response.choices[0].message.content.strip()

# Few-shot: 5 ejemplos representativos
EJEMPLOS = [
    ("No puedo entrar al sistema desde las 9am", "ACCESO"),
    ("La plataforma tarda 30 segundos en cargar", "RENDIMIENTO"),
    ("Necesito conectar nuestro CRM con la API", "INTEGRACION"),
    ("Error 500 cuando guardo un registro", "ERROR"),
    ("¿Cómo exporto los datos a Excel?", "DATOS"),
]

def classify_few_shot_v2(ticket: str) -> str:
    cats = ", ".join(CATEGORIAS)
    ejemplos_texto = "\n".join([
        f"Ticket: {t}\nCategoría: {c}"
        for t, c in EJEMPLOS
    ])
    prompt = f"""Clasifica tickets de soporte en: {cats}.

Ejemplos:
{ejemplos_texto}

Ticket: {ticket}
Categoría:"""
    
    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "user", "content": prompt}],
        temperature=0,
        max_tokens=15
    )
    return response.choices[0].message.content.strip()

# Benchmark comparativo
tickets_test = [
    ("Mi contraseña expiró y no puedo resetearla", "ACCESO"),
    ("La factura del mes pasado tiene un cobro doble", "FACTURA"),
    ("Necesitamos migrar datos del sistema antiguo", "MIGRACION"),
    ("Error al generar reportes de compliance", "ERROR"),
    ("¿Tienen certificación SOC 2?", "SEGURIDAD"),
]

print(f"{'Ticket':<45} {'Ground Truth':<14} {'Zero-shot':<14} {'Few-shot':<14} {'Match'}")
print("-" * 100)

zs_correct = 0
fs_correct = 0
for ticket, ground_truth in tickets_test:
    zs = classify_zero_shot(ticket)
    fs = classify_few_shot_v2(ticket)
    
    zs_ok = "✅" if zs == ground_truth else "❌"
    fs_ok = "✅" if fs == ground_truth else "❌"
    
    zs_correct += (zs == ground_truth)
    fs_correct += (fs == ground_truth)
    
    print(f"{ticket[:44]:<45} {ground_truth:<14} {zs:<14} {fs:<14} {zs_ok}/{fs_ok}")

print(f"\nAccuracy: Zero-shot={zs_correct/len(tickets_test):.0%}, Few-shot={fs_correct/len(tickets_test):.0%}")

Output típico:

Ticket                                         Ground Truth   Zero-shot      Few-shot       Match
----------------------------------------------------------------------------------------------------
Mi contraseña expiró y no puedo resetearla    ACCESO         ACCESO         ACCESO         ✅/✅
La factura del mes pasado tiene un cobro dob  FACTURA        FACTURA        FACTURA        ✅/✅
Necesitamos migrar datos del sistema antiguo  MIGRACION      DATOS          MIGRACION      ❌/✅
Error al generar reportes de compliance       ERROR          ERROR          ERROR          ✅/✅
¿Tienen certificación SOC 2?                  SEGURIDAD      CONFIGURACION  SEGURIDAD      ❌/✅

Accuracy: Zero-shot=60%, Few-shot=100%

En este caso, las categorías de dominio especializado (MIGRACION vs DATOS, SEGURIDAD vs CONFIGURACION) son ambiguas para zero-shot pero se resuelven con ejemplos.

El Continuo de Técnicas

Zero-shot y few-shot forman parte de un continuo de técnicas con distintos trade-offs:

Zero-Shot           Few-Shot        Chain-of-Thought      ReAct
    │                   │                  │                │
Sin ejemplos       2-10 ejemplos      Razonamiento      Razonamiento
Sin razonamiento   Sin razonamiento    step-by-step       + Acción
                                                        (herramientas)

Costo:    Bajo          Medio              Alto          Muy alto
Setup:    Ninguno       Ejemplos          Moderado          Alto
Latencia: Baja          Media              Alta           Muy alta

Usar cuando:
- Tareas estándar   - Dominio nicho    - Math/lógica     - Tool use
- Formatos simples  - Formato custom   - Razonamiento    - Datos externos
- Cost crítico      - Consistency      - Step-by-step    - Verificación

Regla de escalada: Empieza con zero-shot. Si falla, sube a few-shot. Si sigue fallando para razonamiento, usa CoT (Módulo 4). Reserva ReAct (Módulo 5) para cuando necesites herramientas externas.

Trade-offs Cuantitativos

Dimensión	Zero-Shot	Few-Shot (5 ejemplos)
Tokens input	50-200	300-800
Costo relativo	1x	3-6x más tokens
Latencia	~0.3s	~0.5s
Accuracy (dominio general)	80-90%	85-95%
Accuracy (dominio nicho)	50-70%	75-90%
Consistency de formato	Media	Alta
Mantenimiento	Bajo	Medio (curar ejemplos)

Implicación de costo: Con gpt-4o-mini a $0.15/1M input tokens, un prompt zero-shot de 100 tokens vs few-shot de 500 tokens = $0.000015 vs $0.000075 por llamada. A 10,000 llamadas/día: $0.05 vs $0.25/día. La diferencia es real pero pequeña en gpt-4o-mini; con gpt-4o se multiplica ~20x.

Roadmap del Módulo 2

#	Cápsula	Qué verás
01	Introducción (esta)	Zero-shot vs few-shot: definiciones, cuándo usar cada uno, el continuo
02	Zero-shot patterns	Instrucciones directas, role-playing, format specification, constraint-based
03	Few-shot: selección de ejemplos	Cuántos usar, diversidad, orden, positivos/negativos
04	Example engineering	Ejemplos sintéticos, dynamic few-shot, K-nearest similarity
05	Output formatting y parsing	JSON, XML, consistencia, regex extraction, handling malformed
06	Boundary testing	Inputs adversarios, null, context overflow, defensive prompting
07	Decision framework	Zero-shot vs few-shot: tabla comparativa con métricas y benchmarks
08	Proyecto: Few-Shot Classification System	Sistema configurable con example bank y evaluación cuantitativa

Duración estimada: 1.25-1.5 hrs para el módulo completo.

Conexión con el Proyecto

En el Few-Shot Classification System (cápsula 08) construirás:

Sistema de clasificación configurable con N categorías definidas por ti
Banco de ejemplos con selección dinámica por similaridad al input (dynamic few-shot)
Comparación cuantitativa zero-shot vs few-shot: accuracy, latencia, costo por llamada
Soporte para múltiples dominios (tickets de soporte, sentimiento, intención de compra)

Los conceptos de esta cápsula — cuándo cada técnica es suficiente — son la base del decision engine del proyecto. Cuando el sistema recibe un nuevo dominio, evalúa automáticamente qué técnica es más efectiva.

Qué NO Cubre Este Módulo

Chain-of-Thought: Razonamiento step-by-step para tareas de lógica/math (Módulo 4)
ReAct: Combinar razonamiento con uso de herramientas externas como APIs o buscadores (Módulo 5)
Fine-tuning: Actualizar pesos del modelo con tus datos (requiere infraestructura distinta, mucho más costoso)
Retrieval-Augmented Generation: Buscar en base de datos para añadir contexto (guía Advanced RAG, #8)
Prompt chaining: Encadenar múltiples prompts en pipeline (Módulo 6)

Evidencia de Éxito

Al terminar este módulo debes poder:

Explicar la diferencia entre zero-shot y few-shot en 2 oraciones
Dado un caso de uso, decidir cuál técnica usar y justificar con criterios cuantitativos
Implementar los 4 patrones de zero-shot (directas, role-playing, format spec, constraint-based)
Seleccionar y ordenar ejemplos para few-shot efectivo
Construir un Few-Shot Classification System con example bank y evaluación comparativa

Primer Experimento: Medir el Impacto en 10 Líneas

Antes de continuar, ejecuta este snippet para ver la diferencia en acción:

from openai import OpenAI
from dotenv import load_dotenv

load_dotenv()
client = OpenAI()

# Tarea: clasificar si un texto habla de finanzas personales o inversiones
texto = "Abrí un plazo fijo al 8% anual para cubrir la cuota de la hipoteca."

# Zero-shot
r_zs = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {"role": "system", "content": "Clasifica en: AHORRO, INVERSION, DEUDA, GASTO. Solo la categoría."},
        {"role": "user", "content": texto}
    ],
    temperature=0, max_tokens=10
)

# Few-shot (con 2 ejemplos para guiar el patrón)
r_fs = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": f"""
Clasifica en: AHORRO, INVERSION, DEUDA, GASTO. Solo la categoría.

Ejemplos:
"Compré ETFs del S&P500" → INVERSION
"Pagué el mínimo de la tarjeta" → DEUDA

Texto: {texto}
Categoría:"""}],
    temperature=0, max_tokens=10
)

print(f"Zero-shot: {r_zs.choices[0].message.content}")
print(f"Few-shot:  {r_fs.choices[0].message.content}")
print(f"Tokens ZS: {r_zs.usage.total_tokens} | Tokens FS: {r_fs.usage.total_tokens}")
# Observa: la clasificación correcta es AHORRO (plazo fijo) + DEUDA (hipoteca)
# ¿Cuál técnica lo maneja mejor?

Este experimento revela inmediatamente el trade-off: few-shot usa más tokens pero puede ser más preciso en categorías custom. En las próximas cápsulas aprenderás exactamente cuándo esa diferencia importa.

Resumen

En esta cápsula aprendiste:

Zero-shot: Instrucción + input, sin ejemplos. Funciona para tareas comunes y formatos estándar. Más económico en tokens
Few-shot: 2-10 ejemplos input→output. Necesario para formatos custom, dominios nicho, consistency crítica
Trade-off central: Zero-shot = menos tokens, más rápido. Few-shot = más preciso, más consistente, más costoso
El continuo: Zero-shot → Few-shot → Chain-of-Thought → ReAct. Empieza simple, sube según necesidad
Regla de escalada: Cada técnica tiene un costo adicional; sube solo cuando el beneficio lo justifica

Próxima cápsula: Los 4 patrones de zero-shot con código ejecutable — instrucciones directas, role-playing, format specification y constraint-based prompting.

Recursos adicionales

Language Models are Few-Shot Learners (Brown et al., 2020) — Paper original de GPT-3 que introdujo few-shot prompting como disciplina; la base teórica de este módulo
OpenAI Prompt Engineering Guide — Estrategias oficiales de OpenAI para ambas técnicas, con ejemplos de tácticas concretas
Anthropic: Use Examples (Few-Shot) — Guía de Claude sobre cuándo y cómo usar few-shot efectivamente
Prompt Engineering Guide (DAIR.AI) — Few-Shot — Comparativa técnica con benchmarks de accuracy en distintas tareas
Learn Prompting: Zero-Shot & Few-Shot — Recursos introductorios con ejemplos en múltiples dominios

← Anterior8. Proyecto: Prompt Analyzer Siguiente →2. Zero-Shot Prompting Patterns