Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Náklady a optimalizace

Lekce 15 z 16 Aktualizováno 2. listopadu 2026 Pokročilý
Na této stránce
  1. Porozumění struktuře nákladů
  2. Náklady na trénink
  3. Náklady na inferenci
  4. Redukce vstupních tokenů
  5. Vyvážení velikosti datasetu a počtu epoch
  6. Monitorování výdajů v produkci
  7. Ospravedlnění investice
  8. Klíčové poznatky

Aktualizace 2. listopadu 2026 — Dostupnost jemného ladění. Služba pro vlastní jemné ladění od OpenAI se postupně ukončuje: od 7. května 2026 ji organizace, které ji nikdy nepoužily, již nemohou aktivovat; od 2. července musíte mít v posledních 60 dnech spuštěný alespoň jeden model po jemném ladění; a počínaje 6. lednem 2027 nebude žádný zákazník moci spustit nové úlohy. Již natrénované modely zůstávají použitelné až do vyřazení jejich základního modelu. Tento kurz je stále užitečný pro pochopení a využití existujícího modelu; u nových projektů dejte přednost inženýrství promptů, RAG a evaluacím.

Porozumění struktuře nákladů

Jemné ladění modelů OpenAI zahrnuje dva typy nákladů: jednorázové náklady na trénink a opakované náklady na inferenci. Pochopení a optimalizace těchto nákladů jsou klíčové pro ziskové nasazení. Rozdíl není jen účetní záležitostí: první představuje jednorázové rozhodnutí učiněné před spuštěním úlohy, které se již nemění; druhé vás doprovází každý měsíc a roste s vaším provozem. Tým, který se přetahuje o náklady na trénink, zatímco nechává běžet prompt o tisíci tokenech při pěti tisících denních požadavcích, bojuje špatnou bitvu.

Náklady na trénink

Trénink je účtován za zpracovaný token a toto číslo závisí přímo na dvou proměnných, které máte pod kontrolou: velikosti vašeho datasetu a počtu průchůů (epoch) přes něj.

Training cost = total_tokens × number_epochs × price_per_training_token

Tento vzorec vám umožní odhadnout fakturu před spuštěním čehokoli. Následující funkce naskenuje soubor JSONL a aproximuje počet tokenů na základě délky zpráv – odhad jednoho tokenu na čtyři znaky ve francouzštině je hrubý, ale stačí k rozlišení úlohy za pár dolarů od té, která stojí několik set. Zvykněte si tuto kontrolu provádět systematicky: chyba v přípravě, která ztrojnásobí váš dataset, se okamžitě projeví ve výsledku.

import json

def estimate_training_cost(
    jsonl_file: str,
    n_epochs: int,
    price_per_million_tokens: float
) -> dict:
    """Estimates training cost before launching the job."""
    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"]:
                # Rough estimate: 1 token ~ 4 characters in French
                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  # check current pricing
)

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

Náklady na inferenci

Inference se účtuje za každý požadavek na základě vstupních a výstupních tokenů a modely po jemném ladění mají obvykle o něco vyšší sazbu než základní model. Tento příplatek za jednotku často vyvolává váhání, mylně: vztahuje se na mnohem menší počet tokenů, protože chování dříve popsané v dlouhém systémovém promptu je nyní zabudováno přímo do modelu. Níže uvedený výpočet staví oba scénáře vedle sebe pro měsíc identického provozu, přičemž prompt klesá z 800 na 100 tokenů proti dvojnásobným sazbám. Před vyvozením závěrů si parametry upravte podle svých vlastních čísel: u použití, kde byl prompt již krátký, se poměr sil obrací.

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:
    """Calculates monthly inference cost."""
    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

# Scenario: base model with long prompt
base_cost = monthly_cost(
    requests_per_day=5000,
    avg_input_tokens=800,    # long system prompt + question
    avg_output_tokens=200,
    price_input_per_million=0.15,
    price_output_per_million=0.60
)

# Scenario: fine-tuned model with minimal prompt
ft_cost = monthly_cost(
    requests_per_day=5000,
    avg_input_tokens=100,    # short prompt, behavior integrated
    avg_output_tokens=200,
    price_input_per_million=0.30,  # higher FT rate
    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}")

Redukce vstupních tokenů

Hlavní pákou pro úspory u modelu po jemném ladění je zkrácení promptu. Každá instrukce, kterou dokážete odstranit, protože si ji model internalizoval, představuje zisk opakovaný při každém volání, dokud služba nedosáhne konce své životnosti. Níže uvedená tabulka uvádí pozorované řády velikosti v závislosti na dosaženém stupni integrace.

Přístup Vstupní tokeny Úspory
Základní model + podrobný prompt 500–1000 tokenů Reference
Jemně laděný + minimální prompt 50–100 tokenů 80–90 % u vstupu
Jemně laděný + žádný systémový prompt 20–50 tokenů 95 % u vstupu

Neodstraňujte tyto instrukce všechny najednou v naději, že vše vydrží. Odstraňujte je ve skupinách a po každém odstranění znovu spusťte svou testovací sadu: zjistíte, že některá pravidla byla dokonale naučena, zatímco jiná, méně zastoupená ve vašich příkladech, musí v promptu zůstat.

Vyvážení velikosti datasetu a počtu epoch

Více dat znamená lepší model, ale také vyšší náklady na trénink a návratnost klesá. Přechod ze sta na tři sta příkladů obvykle hodně změní; přechod z tisíce na tři tisíce změní málo, za trojnásobnou cenu. Natrénujte několik velikostí, změřte dosaženou kvalitu a porovnejte ji s náklady, abyste našli svůj bod zvratu.

def find_optimal(results_by_size: dict):
    """Identifies the optimal dataset size."""
    print("Dataset size | Quality score | Training cost")
    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"\nOptimal size: {optimal_size} examples")

Výběr základního modelu váží na stejné misce vah. Luna je levnější než Terra, jak pro trénink, tak pro inferenci: vždy začněte s nejlevnějším modelem a přejděte výše pouze tehdy, pokud je dosažená kvalita nedostatečná. Zkontrolujte, které modely jsou způsobilé pro jemné ladění v dokumentaci OpenAI – seznam se mění s každou generací a nikdy nezahrnuje celý katalog. Pak je tu počet epoch, protože každý další průchod mechanicky násobí náklady na trénink. Pokud 2 epochy poskytnou 95 % kvality oproti 4 epochám, je volba rychlá.

Monitorování výdajů v produkci

Odhad provedený před spuštěním platí pouze pro trénink. V produkci jsou to skutečné provozní údaje, které řídí náklady, a ty často překvapí směrem nahoru. Počítadlo napájené při každém volání, svázané s měsíčním rozpočtem, vás upozorní dříve než samotná faktura. Hranice 80 % ponechává čas na reakci: zkrátit prompt, omezit délky odpovědí nebo přesunout část provozu na levnější model.

class CostTracker:
    """Real-time cost tracking."""

    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):
        """Records the cost of a call."""
        cost = (
            input_tokens * input_price / 1_000_000 +
            output_tokens * output_price / 1_000_000
        )
        self.spending += cost
        self.calls += 1

        # Alert if approaching budget
        utilization = self.spending / self.budget * 100
        if utilization > 80:
            print(f"ALERT: {utilization:.1f}% of monthly budget used")

    def report(self):
        """Consumption report."""
        print(f"Calls: {self.calls}")
        print(f"Spending: ${self.spending:.2f}")
        print(f"Remaining budget: ${self.budget - self.spending:.2f}")
        if self.calls > 0:
            print(f"Average cost per call: ${self.spending / self.calls:.4f}")

Ospravedlnění investice

Zbývá otázka, kterou se vás dříve či později zeptá vaše vedení: jak dlouho potrvá, než se trénink zaplatí? Výpočet vztahuje jednorázové náklady k měsíčnímu přínosu, který zahrnuje úspory tokenů a hodnotu, kterou přikládáte zlepšení kvality. Tento druhý člen je nejobtížnější a je lepší ho ponechat na nule, než si ho vymýšlet: návratnost prokázaná pouze na měřitelných úsporách působí přesvědčivěji než štědrá projekce.

def calculate_roi(
    training_cost: float,
    monthly_savings: float,
    quality_gain_value: float = 0
) -> dict:
    """Calculates the return on investment for fine-tuning."""
    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} months",
        "annual_roi": f"{(monthly_benefit * 12 - training_cost) / training_cost * 100:.0f}%"
    }

Klíčové poznatky

  • Odhadněte náklady na trénink před spuštěním úlohy
  • Hlavní pákou pro úspory je redukce vstupních tokenů
  • Začněte s nejlevnějším základním modelem (Luna), než přejdete na Terru
  • Monitorujte náklady v produkci pomocí alertů na rozpočet
  • Vypočítejte ROI včetně zlepšení kvality a úspor tokenů