Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Izmaksas un optimizācija

Nodarbība 15 no 16 Atjaunota 2026. gada 2. novembris Augstākais
Šajā lapā
  1. Izmaksu struktūras izpratne
  2. Apmācības izmaksas
  3. Secinājumu (Inference) izmaksas
  4. Ievades tokeni samazināšana
  5. Datu kopas lieluma un epochu līdzsvarošana
  6. Izdevumu uzraudzība ražošanas vidē
  7. Ieguldījuma attaisnošana
  8. Galvenās atziņas

Atjauninājums 2026. gada 2. novembrī — Modeļu pielāgošanas pieejamība. OpenAI pašapkalpošanās modeļu pielāgošana tiek pakāpeniski izslēgta: kopš 2026. gada 7. maija organizācijas, kas to nekad nav izmantojušas, vairs nevar izveidot uzdevumus; kopš 2. jūlija jums ir jābūt izmantojušam pielāgotu modeli pēdējo 60 dienu laikā; un sākot ar 2027. gada 6. janvāri, neviens klients nevarēs uzsākt jaunus uzdevumus. Jau apmācīti modeļi paliek lietojami, līdz tiek izslēgts to bāzes modelis. Šis kurss joprojām ir noderīgs, lai saprastu un izmantotu esošu modeli; jauniem projektiem dodiet priekšroku promptu inženierijai, RAG un novērtējumiem.

Izmaksu struktūras izpratne

OpenAI modeļu pielāgošana ietver divu veidu izmaksas: vienreizējas apmācības izmaksas un atkārtotas secinājumu (inference) izmaksas. Šo izmaksu izpratne un optimizācija ir būtiska veiksmīgai izvietošanai. Atšķirība nav tikai grāmatvedībā: pirmās ir vienreizējs lēmums, kas pieņemts pirms uzdevuma uzsākšanas, un tās nemainās; otrās tevi pavada katru mēnesi un pieaug līdz ar tavu datplūsmu. Komanda, kas kaulējas par apmācības izmaksām, ļaujot tūkstoš tokenus garam promptam darboties pie pieciem tūkstošiem ikdienas pieprasījumu, cīnās nepareizā kaujā.

Apmācības izmaksas

Par apmācību tiek fakturēts par katru apstrādāto tokeni, un šis skaitlis ir tieši atkarīgs no diviem mainīgajiem, kurus tu kontrolē: tavas datu kopas lieluma un pārlūkojumu (epoch) skaita.

Training cost = total_tokens × number_epochs × price_per_training_token

Šī formula ļauj tev novērtēt rēķinu pirms jebkādas darbības uzsākšanas. Tālāk redzamā funkcija skenē JSONL failu un aptuveni aprēķina tokeni skaitu, balstoties uz ziņojuma garumu — aplēse par vienu tokeni uz četriem simboliem franču valodā ir aptuvena, taču pietiekama, lai atšķirtu dažus dolārus vērtu uzdevumu no tāda, kas maksā vairākus simtus. Pieradi sevi to izpildīt sistemātiski: sagatavošanas kļūda, kas trīskāršo tavu datu kopu, rezultātā parādīsies uzreiz.

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

Secinājumu (Inference) izmaksas

Par secinājumiem tiek fakturēts par katru izsaukumu, balstoties uz ievades un izvades tokeniem, un pielāgotiem modeļiem parasti ir nedaudz augstāks tarifs nekā bāzes modelim. Šī vienības piemaksa bieži rada šaubas, un kļūdaini: tā attiecas uz daudz mazāku tokeni skaitu, jo uzvedība, kas iepriekš bija aprakstīta garā sistēmas promptā, tagad ir iebūvēta modelī. Tālāk redzamais aprēķins salīdzina abus scenārijus blakus vienam mēnesim ar identisku datplūsmu, kur prompts samazinās no 800 līdz 100 tokeniem, pretstatā dubultotiem tarifiem. Pirms secinājumu izdarīšanas pielāgo parametrus ar saviem skaitļiem: lietojumos, kur prompts jau bija īss, līdzsvars mainās uz otru pusi.

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

Ievades tokeni samazināšana

Galvenais svira ietaupījumiem, izmantojot pielāgotu modeli, ir prompta saīsināšana. Katra instrukcija, ko tev izdodas noņemt, jo modelis to ir internalizējis, ir ieguvums, kas atkārtojas katrā izsaukumā, līdz pakalpojums sasniedz dzīves cikla beigas. Tālāk redzamajā tabulā norādīti novērotie lieluma rādi atkarībā no sasniegtās integrācijas pakāpes.

Pieeja Ievades tokeni Ietaupījumi
Bāzes modelis + detalizēts prompts 500–1000 tokeni Atsauce
Pielāgots modelis + minimāls prompts 50–100 tokeni 80–90% uz ievadi
Pielāgots modelis + bez sistēmas prompta 20–50 tokeni 95% uz ievadi

Neizņem šīs instrukcijas visas uzreiz, cerot, ka viss noturēsies. Izņem tās grupās, pēc katras izņemšanas atkārtoti izpildot savu testa kopu: tu atklāsi, ka daži noteikumi ir perfekti apgūti, bet citi, kas mazāk pārstāvēti tavos piemēros, ir jāatstāj promptā.

Datu kopas lieluma un epochu līdzsvarošana

Lielāks datu apjoms nodrošina labāku modeli, bet arī augstākas apmācības izmaksas, un atdeve samazinās. Pāreja no simta uz trīs simtiem piemēru parasti daudz ko maina; pāreja no tūkstoša uz trim tūkstošiem maina maz, par trīsreiz lielāku cenu. Apmāci vairākus izmērus, izmēri sasniegto kvalitāti un salīdzini to ar izmaksām, lai atrastu savu bezzaudējumu punktu.

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

Bāzes modeļa izvēlei ir tāda pati nozīme. Luna ir lētāks par Terra gan apmācībā, gan secinājumos: vienmēr sāc ar lētāko modeli un pārej uz augstāku tikai tad, ja sasniegtā kvalitāte ir nepietiekama. Pārbaudi OpenAI dokumentācijā, kuri modeļi ir piemēroti pielāgošanai — saraksts mainās ar katru paaudzi un nekad neaptver visu katalogu. Tad ir epochu skaits, jo katrs papildu pārlūkojums mehāniski reizina apmācības izmaksas. Ja 2 epochas nodrošina 95% no 4 epochu kvalitātes, izvēle ir ātra.

Izdevumu uzraudzība ražošanas vidē

Pirms palaišanas veiktais aprēķins attiecas tikai uz apmācību. Ražošanas vidē izmaksas diktē faktiskā datplūsma, un tā bieži rada pārsteigumus uz augšu. Skaitītājs, kas tiek barots ar katru izsaukumu un piesaistīts mēneša budžetam, tevi brīdinās pirms rēķina. 80% slieksnis atstāj laiku reaģēt: saīsini promptu, ierobežo atbilžu garumu vai novirzi daļu datplūsmas uz lētāku modeli.

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

Ieguldījuma attaisnošana

Paliek jautājums, ko tava vadība agrāk vai vēlāk uzdos: cik ilgs laiks būs vajadzīgs, lai apmācība atmaksātos? Aprēķins saista vienreizējas izmaksas ar mēneša ieguvumu, kas summē tokeni ietaupījumus un vērtību, ko tu piedēvē kvalitātes uzlabojumiem. Šis otrais loceklis ir visgrūtākais, un labāk to atstāt nulles līmenī, nevis izgudrot: atmaksāšanās, kas demonstrēta tikai uz izmērāmiem ietaupījumiem, rada lielāku pārliecību nekā dāsna prognoze.

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

Galvenās atziņas

  • Novērtē apmācības izmaksas pirms uzdevuma uzsākšanas
  • Galvenā svira ietaupījumiem ir ievades tokeni samazināšana
  • Sāc ar lētāko bāzes modeli (Luna), pirms pāriet uz Terra
  • Uzraugi izmaksas ražošanas vidē ar budžeta brīdinājumiem
  • Aprēķini ROI, iekļaujot kvalitātes uzlabojumus un tokeni ietaupījumus