Ir al contenido principal
Español— Elegir un idioma
Menú

Costes y optimización

Lección 15 de 16 Actualizado el 2 de noviembre de 2026 Avanzado
En esta página
  1. Comprensión de la estructura de costes
  2. El coste de entrenamiento
  3. El coste de inferencia
  4. Reducción de tokens de entrada
  5. Equilibrio entre tamaño del conjunto de datos y épocas
  6. Supervisión del gasto en producción
  7. Justificación de la inversión
  8. Puntos clave

Actualización 2 de noviembre de 2026 — Disponibilidad del ajuste fino. OpenAI está eliminando gradualmente el ajuste fino autoservicio: desde el 7 de mayo de 2026, las organizaciones que nunca lo han utilizado ya no pueden crear tareas; desde el 2 de julio, debes haber usado un modelo ajustado en los últimos 60 días; y a partir del 6 de enero de 2027, ningún cliente podrá lanzar nuevas tareas. Los modelos ya entrenados siguen siendo utilizables hasta que se retire su modelo base. Este curso sigue siendo útil para comprender y aprovechar un modelo existente; para nuevos proyectos, prioriza la ingeniería de prompts, RAG y las evaluaciones.

Comprensión de la estructura de costes

El ajuste fino de OpenAI implica dos tipos de costes: un coste de entrenamiento único y un coste de inferencia recurrente. Comprender y optimizar estos costes es esencial para un despliegue rentable. La distinción no es solo contable: la primera es una decisión única que se toma antes de lanzar la tarea y no cambia; la segunda te acompaña cada mes y crece con tu tráfico. Un equipo que regatea los costes de entrenamiento mientras deja correr un prompt de mil tokens en cinco mil solicitudes diarias está librando la batalla equivocada.

El coste de entrenamiento

El entrenamiento se factura por token procesado, y esa cifra depende directamente de dos variables que controlas: el tamaño de tu conjunto de datos y el número de pasadas sobre él.

Coste de entrenamiento = total_tokens × number_epochs × price_per_training_token

Esta fórmula te permite estimar la factura antes de lanzar nada. La siguiente función escanea el archivo JSONL y aproxima el recuento de tokens basándose en la longitud del mensaje; la estimación de un token por cada cuatro caracteres en francés es aproximada, pero basta para distinguir una tarea de unos pocos dólares de otra que cuesta varios cientos. Acostúmbrate a ejecutar esto sistemáticamente: un error de preparación que triplique tu conjunto de datos aparecerá inmediatamente en el resultado.

import json

def estimate_training_cost(
    jsonl_file: str,
    n_epochs: int,
    price_per_million_tokens: float
) -> dict:
    """Estima el coste de entrenamiento antes de lanzar la tarea."""
    total_tokens = 0

    with open(jsonl_file, "r") as f:
        num_examples = 0
        for line in f:
            num_examples += 1
            obj = json.loads(line)
            for msg in obj["messages"]:
                # Estimación aproximada: 1 token ~ 4 caracteres en francés
                total_tokens += len(msg["content"]) // 4

    training_tokens = total_tokens * n_epochs
    cost = training_tokens * price_per_million_tokens / 1_000_000

    return {
        "examples": num_examples,
        "tokens_per_pass": total_tokens,
        "epochs": n_epochs,
        "total_tokens": training_tokens,
        "estimated_cost": f"${cost:.2f}"
    }

result = estimate_training_cost(
    "training_data.jsonl",
    n_epochs=3,
    price_per_million_tokens=8.0  # consulta los precios actuales
)

for k, v in result.items():
    print(f"{k}: {v}")

El coste de inferencia

La inferencia se factura por llamada, basándose en los tokens de entrada y salida, y los modelos ajustados suelen tener una tarifa ligeramente superior a la del modelo base. Este recargo unitario suele causar dudas, erróneamente: se aplica a muchos menos tokens, ya que el comportamiento descrito anteriormente en un prompt de sistema largo ahora está integrado en el modelo. El cálculo siguiente pone ambos escenarios lado a lado para un mes de tráfico idéntico, con un prompt que cae de 800 a 100 tokens frente a tarifas duplicadas. Ajusta los parámetros con tus propios números antes de sacar conclusiones: para usos donde el prompt ya era corto, la compensación se invierte.

def monthly_cost(
    requests_per_day: int,
    avg_input_tokens: int,
    avg_output_tokens: int,
    price_input_per_million: float,
    price_output_per_million: float
) -> float:
    """Calcula el coste mensual de inferencia."""
    requests_month = requests_per_day * 30
    input_cost = requests_month * avg_input_tokens * price_input_per_million / 1_000_000
    output_cost = requests_month * avg_output_tokens * price_output_per_million / 1_000_000
    return input_cost + output_cost

# Escenario: modelo base con prompt largo
base_cost = monthly_cost(
    requests_per_day=5000,
    avg_input_tokens=800,    # prompt de sistema largo + pregunta
    avg_output_tokens=200,
    price_input_per_million=0.15,
    price_output_per_million=0.60
)

# Escenario: modelo ajustado con prompt mínimo
ft_cost = monthly_cost(
    requests_per_day=5000,
    avg_input_tokens=100,    # prompt corto, comportamiento integrado
    avg_output_tokens=200,
    price_input_per_million=0.30,  # tarifa FT más alta
    price_output_per_million=1.20
)

print(f"Monthly base cost: ${base_cost:.2f}")
print(f"Monthly fine-tuned cost: ${ft_cost:.2f}")
print(f"Difference: ${ft_cost - base_cost:+.2f}")

Reducción de tokens de entrada

La principal palanca de ahorro con un modelo ajustado es la reducción del prompt. Cada instrucción que logras eliminar porque el modelo la ha interiorizado es una ganancia que se repite en cada llamada, hasta que el servicio llegue al final de su vida útil. La tabla siguiente muestra los órdenes de magnitud observados según el grado de integración alcanzado.

Enfoque Tokens de entrada Ahorro
Modelo base + prompt detallado 500-1000 tokens Referencia
Ajustado + prompt mínimo 50-100 tokens 80-90% en entrada
Ajustado + sin prompt de sistema 20-50 tokens 95% en entrada

No elimines estas instrucciones todas de golpe esperando que todo se mantenga. Elimínalas en grupos, volviendo a ejecutar tu conjunto de pruebas tras cada eliminación: descubrirás que algunas reglas se han aprendido perfectamente mientras que otras, menos representadas en tus ejemplos, deben permanecer en el prompt.

Equilibrio entre tamaño del conjunto de datos y épocas

Más datos ofrecen un mejor modelo, pero también un coste de entrenamiento mayor, y los rendimientos son decrecientes. Pasar de cien a trescientos ejemplos suele cambiar mucho; pasar de mil a tres mil cambia poco, por tres veces el precio. Entrena varios tamaños, mide la calidad alcanzada y relaciónala con el coste para encontrar tu punto de equilibrio.

def find_optimal(results_by_size: dict):
    """Identifica el tamaño óptimo del conjunto de datos."""
    print("Tamaño dataset | Puntuación calidad | Coste entrenamiento")
    print("-" * 55)

    best_ratio = 0
    optimal_size = 0

    for size, data in sorted(results_by_size.items()):
        score = data["score"]
        cost = data["cost"]
        ratio = score / cost if cost > 0 else 0

        print(f"{size:>14} | {score:>13.2f} | {cost:>17.2f} $")

        if ratio > best_ratio:
            best_ratio = ratio
            optimal_size = size

    print(f"\nTamaño óptimo: {optimal_size} ejemplos")

La elección del modelo base pesa en la misma balanza. Luna es más barato que Terra, tanto para entrenamiento como para inferencia: empieza siempre con el modelo más barato y sube solo si la calidad alcanzada es insuficiente. Consulta qué modelos son elegibles para ajuste fino en la documentación de OpenAI; la lista cambia con cada generación y nunca cubre todo el catálogo. Luego está el número de épocas, ya que cada pasada adicional multiplica mecánicamente el coste de entrenamiento. Si 2 épocas ofrecen el 95 % de la calidad de 4 épocas, la elección es rápida.

Supervisión del gasto en producción

La estimación realizada antes del lanzamiento solo se aplica al entrenamiento. En producción, es el tráfico real el que impulsa los costes, y a menudo sorprende al alza. Un contador alimentado en cada llamada, vinculado a un presupuesto mensual, te alerta antes que la factura. El umbral del 80 % deja tiempo para reaccionar: reducir un prompt, limitar las longitudes de respuesta o desplazar parte del tráfico a un modelo más barato.

class CostTracker:
    """Seguimiento de costes en tiempo real."""

    def __init__(self, monthly_budget: float):
        self.budget = monthly_budget
        self.spending = 0.0
        self.calls = 0

    def record(self, input_tokens: int, output_tokens: int,
               input_price: float, output_price: float):
        """Registra el coste de una llamada."""
        cost = (
            input_tokens * input_price / 1_000_000 +
            output_tokens * output_price / 1_000_000
        )
        self.spending += cost
        self.calls += 1

        # Alerta si se acerca al presupuesto
        utilization = self.spending / self.budget * 100
        if utilization > 80:
            print(f"ALERTA: {utilization:.1f}% del presupuesto mensual utilizado")

    def report(self):
        """Informe de consumo."""
        print(f"Llamadas: {self.calls}")
        print(f"Gasto: ${self.spending:.2f}")
        print(f"Presupuesto restante: ${self.budget - self.spending:.2f}")
        if self.calls > 0:
            print(f"Coste medio por llamada: ${self.spending / self.calls:.4f}")

Justificación de la inversión

Queda la pregunta que tu dirección hará tarde o temprano: ¿cuánto tiempo hasta que el entrenamiento se amortice? El cálculo relaciona un coste único con un beneficio mensual, que suma el ahorro de tokens y el valor que asignas a las ganancias de calidad. Este segundo término es el más complicado, y es mejor dejarlo en cero que inventarlo: un periodo de recuperación demostrado solo con ahorros medibles tiene más convicción que una proyección generosa.

def calculate_roi(
    training_cost: float,
    monthly_savings: float,
    quality_gain_value: float = 0
) -> dict:
    """Calcula el retorno de la inversión para el ajuste fino."""
    monthly_benefit = monthly_savings + quality_gain_value
    payback_months = training_cost / monthly_benefit if monthly_benefit > 0 else float("inf")

    return {
        "training_cost": f"${training_cost:.2f}",
        "monthly_benefit": f"${monthly_benefit:.2f}",
        "payback": f"{payback_months:.1f} meses",
        "annual_roi": f"{(monthly_benefit * 12 - training_cost) / training_cost * 100:.0f}%"
    }

Puntos clave

  • Estima el coste de entrenamiento antes de lanzar la tarea
  • La principal palanca de ahorro es reducir los tokens de entrada
  • Empieza con el modelo base más barato (Luna) antes de subir a Terra
  • Supervisa los costes en producción con alertas de presupuesto
  • Calcula el ROI incluyendo las ganancias de calidad y el ahorro de tokens