Salt la conținutul principal
Română— Alege o limbă
Meniu

Costuri și optimizare

Lecția 15 din 16 Actualizată 2 noiembrie 2026 Avansat
Pe această pagină
  1. Înțelegerea structurii costurilor
  2. Costul de antrenament
  3. Costul de inferență
  4. Reducerea tokenilor de intrare
  5. Echilibrarea dimensiunii setului de date și a epocilor
  6. Monitorizarea cheltuielilor în producție
  7. Justificarea investiției
  8. Puncte cheie

Actualizare 2 noiembrie 2026 — Disponibilitatea fine-tuning-ului. Funcționalitatea de fine-tuning self-service de la OpenAI este în curs de eliminare: începând cu 7 mai 2026, organizațiile care nu au utilizat-o niciodată nu mai pot crea job-uri; începând cu 2 iulie, trebuie să fi utilizat un model fine-tuned în ultimele 60 de zile; iar începând cu 6 ianuarie 2027, niciun client nu va mai putea lansa job-uri noi. Modelele deja antrenate rămân utilizabile până la retragerea modelului lor de bază. Acest curs rămâne util pentru înțelegerea și exploatarea unui model existent; pentru proiecte noi, prioritizați ingineria prompt-urilor, RAG și evaluările.

Înțelegerea structurii costurilor

Fine-tuning-ul OpenAI implică două tipuri de costuri: un cost unic de antrenament și un cost recurent de inferență. Înțelegerea și optimizarea acestor costuri sunt esențiale pentru o implementare profitabilă. Distincția nu este doar contabilă: primul este o decizie unică luată înainte de lansarea job-ului și nu se schimbă; al doilea vă însoțește în fiecare lună și crește odată cu traficul dumneavoastră. O echipă care se zbate pentru costurile de antrenament în timp ce lasă un prompt de o mie de tokeni să ruleze la cinci mii de cereri zilnice duce lupta greșită.

Costul de antrenament

Antrenamentul este facturat per token procesat, iar acest număr depinde direct de două variabile pe care le controlați: dimensiunea setului de date și numărul de parcurgeri ale acestuia.

Training cost = total_tokens × number_epochs × price_per_training_token

Această formulă vă permite să estimați factura înainte de a lansa orice. Funcția următoare scanează fișierul JSONL și aproximează numărul de tokeni pe baza lungimii mesajelor — estimarea unui token la patru caractere în franceză este grosieră, dar suficientă pentru a distinge un job de câțiva dolari de unul care costă câteva sute. Obișnuiți-vă să rulați acest lucru sistematic: o eroare de pregătire care triplează setul de date apare imediat în rezultat.

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}")

Costul de inferență

Inferența este facturat per apel, pe baza tokenilor de intrare și de ieșire, iar modelele fine-tuned au, în general, o tarifare ușor mai mare decât modelul de bază. Acest supliment unitar cauză adesea ezitare, în mod eronat: se aplică la mult mai puțini tokeni, deoarece comportamentul descris anterior într-un prompt de sistem lung este acum integrat în model. Calculul de mai jos pune alături ambele scenarii pentru o lună de trafic identic, cu un prompt care scade de la 800 la 100 de tokeni față de tarife dublate. Ajustați parametrii cu propriile dumneavoastră cifre înainte de a trage concluzii: pentru utilizări unde promptul era deja scurt, compromisul se inversează.

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}")

Reducerea tokenilor de intrare

Principala pârghie de economisire cu un model fine-tuned este reducerea prompt-ului. Fiecare instrucțiune pe care reușiți să o eliminați deoarece modelul a internalizat-o reprezintă un câștig repetat la fiecare apel, până când serviciul ajunge la sfârșitul vieții utile. Tabelul de mai jos oferă ordinele de mărime observate în funcție de gradul de integrare realizat.

Approach Input tokens Savings
Base model + detailed prompt 500-1000 tokens Reference
Fine-tuned + minimal prompt 50-100 tokens 80-90% on input
Fine-tuned + no system prompt 20-50 tokens 95% on input

Nu eliminați aceste instrucțiuni toate deodată sperând că totul va rezista. Eliminați-le pe grupuri, rerulând setul de testare după fiecare eliminare: veți descoperi că unele reguli au fost perfect învățate, în timp ce altele, mai puțin reprezentate în exemplele dumneavoastră, trebuie să rămână în prompt.

Echilibrarea dimensiunii setului de date și a epocilor

Mai multe date oferă un model mai bun, dar și un cost de antrenament mai ridicat, iar randamentele scad. Trecerea de la o sută la trei sute de exemple schimbă de obicei mult; trecerea de la o mie la trei mii schimbă puțin, pentru un preț de trei ori mai mare. Antrenați mai multe dimensiuni, măsurați calitatea obținută și corelați-o cu costul pentru a găsi punctul de echilibru.

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")

Alegerea modelului de bază cântărește pe aceeași balanță. Luna este mai ieftin decât Terra, atât pentru antrenament, cât și pentru inferență: începeți întotdeauna cu cel mai ieftin model și urcați doar dacă calitatea obținută este insuficientă. Verificați în documentația OpenAI care modele sunt eligibile pentru fine-tuning — lista se schimbă cu fiecare generație și nu acoperă niciodată întregul catalog. Apoi există numărul de epoci, deoarece fiecare parcurgere suplimentară multiplică mecanic costul de antrenament. Dacă 2 epoci oferă 95% din calitatea a 4 epoci, alegerea este rapidă.

Monitorizarea cheltuielilor în producție

Estimarea făcută înainte de lansare se aplică doar antrenamentului. În producție, traficul real este cel care conduce costurile și adesea surprinde în sus. Un contor alimentat la fiecare apel, legat de un buget lunar, vă alertează înainte să o facă factura. Pragul de 80% lasă timp de reacție: reduceți un prompt, limitați lungimile răspunsurilor sau mutați o parte din trafic către un model mai ieftin.

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}")

Justificarea investiției

Rămâne întrebarea pe care conducerea dumneavoastră o va pune mai devreme sau mai târziu: cât durează până când antrenamentul se amortizează? Calculul corelează un cost unic cu un beneficiu lunar, care adună economiile de tokeni și valoarea pe care o atribuiți câștigurilor de calitate. Al doilea termen este cel mai delicat și este mai bine să îl lăsați la zero decât să îl inventați: o recuperare demonstrată doar pe economii măsurabile are mai multă forță de convingere decât o proiecție generoasă.

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}%"
    }

Puncte cheie

  • Estimați costul de antrenament înainte de a lansa job-ul
  • Principala pârghie de economisire este reducerea tokenilor de intrare
  • Începeți cu cel mai ieftin model de bază (Luna) înainte de a trece la Terra
  • Monitorizați costurile în producție cu alerte de buget
  • Calculați ROI incluzând câștigurile de calitate și economiile de tokeni