Przejdź do głównej treści
Polski— Wybierz język
Menu

Koszty i optymalizacja

Lekcja 15 z 16 Zaktualizowano 2 listopada 2026 Zaawansowany
Na tej stronie
  1. Zrozumienie struktury kosztów
  2. Koszt treningu
  3. Koszt wnioskowania (Inference)
  4. Redukcja tokenów wejściowych
  5. Bilansowanie rozmiaru zbioru danych i liczby epok
  6. Monitorowanie wydatków w produkcji
  7. Uzasadnienie inwestycji
  8. Kluczowe wnioski

Aktualizacja z 2 listopada 2026 r. — Dostępność dostrajania. Usługa samodzielnego dostrajania modeli OpenAI jest wycofywana: od 7 maja 2026 r. organizacje, które nigdy z niej nie korzystały, nie mogą już tworzyć zadań; od 2 lipca musisz użyć dostrojonego modelu w ciągu ostatnich 60 dni; a począwszy od 6 stycznia 2027 r., żaden klient nie będzie mógł uruchomić nowych zadań. Już wytrenowane modele pozostają użyteczne do momentu wycofania ich modelu bazowego. Ten kurs nadal przydaje się do zrozumienia i wykorzystania istniejącego modelu; w przypadku nowych projektów priorytetowo traktuj inżynierię promptów, RAG oraz ewaluacje.

Zrozumienie struktury kosztów

Dostrajanie modeli OpenAI wiąże się z dwoma rodzajami kosztów: jednorazowym kosztem treningu i cyklicznym kosztem wnioskowania (inference). Zrozumienie i optymalizacja tych kosztów są kluczowe dla opłacalnego wdrożenia. To rozróżnienie to nie tylko kwestia księgowa: pierwszy koszt to jednorazowa decyzja podejmowana przed uruchomieniem zadania, która się nie zmienia; drugi podąża za Tobą co miesiąc i rośnie wraz z ruchem. Zespół, który targuje się o koszty treningu, pozwalając jednocześnie, by prompt liczący tysiąc tokenów był przetwarzany pięć tysięcy razy dziennie, toczy niewłaściwą bitwę.

Koszt treningu

Trening jest rozliczany za każdy przetworzony token, a liczba ta zależy bezpośrednio od dwóch zmiennych, które kontrolujesz: rozmiaru zbioru danych i liczby przejść (epok) po nim.

Koszt treningu = całkowita_liczba_tokenów × liczba_epok × cena_za_token_treningowy

Ten wzór pozwala oszacować rachunek przed uruchomieniem czegokolwiek. Poniższa funkcja skanuje plik JSONL i przybliża liczbę tokenów na podstawie długości wiadomości — szacunek jednego tokena na cztery znaki w języku polskim jest zgrubny, ale wystarcza, by odróżnić zadanie za kilka dolarów od takiego kosztującego kilkaset. Weź sobie za nawyk uruchamianie tego systematycznie: błąd przygotowania, który potraja rozmiar zbioru danych, natychmiast uwidoczni się w wyniku.

import json

def estimate_training_cost(
    jsonl_file: str,
    n_epochs: int,
    price_per_million_tokens: float
) -> dict:
    """Szacuje koszt treningu przed uruchomieniem zadania."""
    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"]:
                # Zgrubne szacowanie: 1 token ~ 4 znaki w języku polskim
                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  # sprawdź aktualne cenniki
)

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

Koszt wnioskowania (Inference)

Wnioskowanie jest rozliczane za każde wywołanie, w oparciu o tokeny wejściowe i wyjściowe, a modele dostrojone mają zazwyczaj nieco wyższą stawkę niż model bazowy. Ta dodatkowa opłata jednostkowa często powoduje wahanie, co jest błędem: dotyczy ona znacznie mniejszej liczby tokenów, ponieważ zachowanie wcześniej opisywane w długim prompcie systemowym jest teraz wbudowane w model. Poniższe obliczenie zestawia oba scenariusze obok siebie dla miesiąca z identycznym ruchem, przy czym prompt zmniejsza się z 800 do 100 tokenów przy podwojonych stawkach. Dostosuj parametry do własnych liczb przed wyciągnięciem wniosków: w przypadkach, gdy prompt był już krótki, bilans zysków i strat odwraca się.

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:
    """Oblicza miesięczny koszt wnioskowania."""
    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

# Scenariusz: model bazowy z długim promptem
base_cost = monthly_cost(
    requests_per_day=5000,
    avg_input_tokens=800,    # długi prompt systemowy + pytanie
    avg_output_tokens=200,
    price_input_per_million=0.15,
    price_output_per_million=0.60
)

# Scenariusz: model dostrojony z minimalnym promptem
ft_cost = monthly_cost(
    requests_per_day=5000,
    avg_input_tokens=100,    # krótki prompt, zachowanie zintegrowane
    avg_output_tokens=200,
    price_input_per_million=0.30,  # wyższa stawka FT
    price_output_per_million=1.20
)

print(f"Miesięczny koszt bazowy: ${base_cost:.2f}")
print(f"Miesięczny koszt modelu dostrojonego: ${ft_cost:.2f}")
print(f"Różnica: ${ft_cost - base_cost:+.2f}")

Redukcja tokenów wejściowych

Głównym dźwigiem oszczędności przy modelu dostrojonym jest redukcja promptu. Każda instrukcja, którą uda Ci się usunąć, ponieważ model ją zinternalizował, to zysk powtarzany przy każdym wywołaniu, aż do zakończenia działania usługi. Poniższa tabela przedstawia obserwowane rzędy wielkości w zależności od osiągniętego stopnia integracji.

Podejście Tokeny wejściowe Oszczędności
Model bazowy + szczegółowy prompt 500–1000 tokenów Wartość odniesienia
Model dostrojony + minimalny prompt 50–100 tokenów 80–90% na wejściu
Model dostrojony + brak promptu systemowego 20–50 tokenów 95% na wejściu

Nie usuwaj tych instrukcji wszystkie naraz, licząc, że wszystko się utrzyma. Usuwaj je grupami, ponownie uruchamiając swój zestaw testowy po każdym usunięciu: odkryjesz, że niektóre reguły zostały perfekcyjnie przyswojone, podczas gdy inne, mniej reprezentowane w Twoich przykładach, muszą pozostać w prompcie.

Bilansowanie rozmiaru zbioru danych i liczby epok

Więcej danych daje lepszy model, ale też wyższy koszt treningu, a zwroty maleją. Przejście ze stu do trzystu przykładów zazwyczaj dużo zmienia; przejście z tysiąca do trzech tysięcy zmienia niewiele, przy trzykrotnie wyższej cenie. Wytrenuj kilka wariantów o różnym rozmiarze, zmierz osiągniętą jakość i odnieś ją do kosztu, aby znaleźć swój punkt równowagi.

def find_optimal(results_by_size: dict):
    """Identyfikuje optymalny rozmiar zbioru danych."""
    print("Rozmiar zbioru | Wynik jakości | Koszt treningu")
    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"\nOptymalny rozmiar: {optimal_size} przykładów")

Wybór modelu bazowego również wpływa na tę wagę. Luna jest tańsza niż Terra, zarówno w treningu, jak i wnioskowaniu: zawsze zaczynaj od najtańszego modelu i przechodź wyżej tylko wtedy, gdy osiągnięta jakość jest niewystarczająca. Sprawdź, które modele kwalifikują się do dostrajania w dokumentacji OpenAI — lista zmienia się z każdą generacją i nigdy nie obejmuje całego katalogu. Dochodzi do tego liczba epok, ponieważ każde dodatkowe przejście mechanicznie mnoży koszt treningu. Jeśli 2 epoki dają 95% jakości 4 epok, wybór jest szybki.

Monitorowanie wydatków w produkcji

Szacunek wykonany przed uruchomieniem dotyczy tylko treningu. W produkcji to rzeczywisty ruch napędza koszty i często zaskakuje wzrostem. Licznik zasilany przy każdym wywołaniu, powiązany z miesięcznym budżetem, ostrzeże Cię zanim zrobi to rachunek. Próg 80% zostawia czas na reakcję: skróć prompt, ogranicz długość odpowiedzi lub przekieruj część ruchu na tańszy model.

class CostTracker:
    """Śledzenie kosztów w czasie rzeczywistym."""

    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):
        """Rejestruje koszt wywołania."""
        cost = (
            input_tokens * input_price / 1_000_000 +
            output_tokens * output_price / 1_000_000
        )
        self.spending += cost
        self.calls += 1

        # Alert przy zbliżaniu się do budżetu
        utilization = self.spending / self.budget * 100
        if utilization > 80:
            print(f"ALERT: Wykorzystano {utilization:.1f}% miesięcznego budżetu")

    def report(self):
        """Raport zużycia."""
        print(f"Liczba wywołań: {self.calls}")
        print(f"Wydatki: ${self.spending:.2f}")
        print(f"Pozostały budżet: ${self.budget - self.spending:.2f}")
        if self.calls > 0:
            print(f"Średni koszt na wywołanie: ${self.spending / self.calls:.4f}")

Uzasadnienie inwestycji

Pozostaje pytanie, które Twoje kierownictwo prędzej czy później zada: jak długo potrwa, zanim trening się zwróci? Obliczenie to odnosi jednorazowy koszt do miesięcznej korzyści, która sumuje oszczędności na tokenach i wartość, jaką przypisujesz zyskom na jakości. Ten drugi składnik jest najbardziej podchwytliwy i lepiej zostawić go jako zero, niż go wymyślać: zwrot z inwestycji wykazany wyłącznie na mierzalnych oszczędnościach niesie większą siłę przekonywania niż hojna projekcja.

def calculate_roi(
    training_cost: float,
    monthly_savings: float,
    quality_gain_value: float = 0
) -> dict:
    """Oblicza zwrot z inwestycji (ROI) dla dostrajania."""
    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} miesięcy",
        "annual_roi": f"{(monthly_benefit * 12 - training_cost) / training_cost * 100:.0f}%"
    }

Kluczowe wnioski

  • Szacuj koszt treningu przed uruchomieniem zadania
  • Głównym dźwigiem oszczędności jest redukcja tokenów wejściowych
  • Zacznij od najtańszego modelu bazowego (Luna), zanim przejdziesz do Terry
  • Monitoruj koszty w produkcji, używając alertów budżetowych
  • Obliczaj ROI, uwzględniając zyski na jakości i oszczędności tokenów