Vai al contenuto principale
Italiano— Scegli una lingua
Menu

Costi e ottimizzazione

Lezione 15 di 16 Aggiornata il 2 novembre 2026 Avanzato
In questa pagina
  1. Comprendere la struttura dei costi
  2. Il costo di addestramento
  3. Il costo di inferenza
  4. Ridurre i token di input
  5. Bilanciare dimensione del dataset ed epoche
  6. Monitorare la spesa in produzione
  7. Giustificare l’investimento
  8. Punti chiave

Aggiornamento 2 novembre 2026 — Disponibilità del fine-tuning. Il servizio di fine-tuning self-service di OpenAI sta venendo dismesso: dal 7 maggio 2026, le organizzazioni che non lo hanno mai utilizzato non possono più creare job; dal 2 luglio, devi aver usato un modello fine-tunato negli ultimi 60 giorni; e a partire dal 6 gennaio 2027, nessun cliente potrà avviare nuovi job. I modelli già addestrati rimangono utilizzabili fino al ritiro del loro modello base. Questo corso resta utile per comprendere e sfruttare un modello esistente; per i nuovi progetti, dai priorità al prompt engineering, al RAG e alle valutazioni.

Comprendere la struttura dei costi

Il fine-tuning di OpenAI comporta due tipi di costi: un costo di addestramento una tantum e un costo ricorrente di inferenza. Comprendere e ottimizzare questi costi è essenziale per un deployment redditizio. La distinzione non è solo contabile: la prima è una decisione una tantum presa prima di avviare il job e non cambia; la seconda ti accompagna ogni mese e cresce con il tuo traffico. Un team che contratta sui costi di addestramento mentre lascia girare un prompt da mille token su cinquemila richieste giornaliere sta combattendo la battaglia sbagliata.

Il costo di addestramento

L’addestramento viene fatturato per token elaborato e quel numero dipende direttamente da due variabili che controlli: la dimensione del tuo dataset e il numero di passaggi su di esso.

Training cost = total_tokens × number_epochs × price_per_training_token

Questa formula ti permette di stimare la fattura prima di lanciare qualsiasi cosa. La funzione seguente scansiona il file JSONL e approssima il conteggio dei token in base alla lunghezza del messaggio: la stima di un token ogni quattro caratteri in francese è grossolana, ma basta a distinguere un job da pochi dollari da uno che ne costa diverse centinaia. Prendi l’abitudine di eseguirla sistematicamente: un errore di preparazione che triplica il tuo dataset appare immediatamente nel risultato.

import json

def estimate_training_cost(
    jsonl_file: str,
    n_epochs: int,
    price_per_million_tokens: float
) -> dict:
    """Stima il costo di addestramento prima di avviare il 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"]:
                # Stima approssimativa: 1 token ~ 4 caratteri in francese
                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  # verifica i prezzi attuali
)

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

Il costo di inferenza

L’inferenza viene fatturata per chiamata, in base ai token di input e output, e i modelli fine-tunati hanno generalmente una tariffa leggermente superiore rispetto al modello base. Questo sovrapprezzo unitario spesso causa esitazione, a torto: si applica a molti meno token, poiché il comportamento precedentemente descritto in un lungo prompt di sistema è ora integrato nel modello. Il calcolo seguente mette a confronto entrambi gli scenari per un mese di traffico identico, con un prompt che scende da 800 a 100 token contro tariffe raddoppiate. Regola i parametri con i tuoi numeri prima di trarre conclusioni: per utilizzi in cui il prompt era già breve, il compromesso si inverte.

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:
    """Calcola il costo mensile di inferenza."""
    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: modello base con prompt lungo
base_cost = monthly_cost(
    requests_per_day=5000,
    avg_input_tokens=800,    # lungo prompt di sistema + domanda
    avg_output_tokens=200,
    price_input_per_million=0.15,
    price_output_per_million=0.60
)

# Scenario: modello fine-tunato con prompt minimo
ft_cost = monthly_cost(
    requests_per_day=5000,
    avg_input_tokens=100,    # prompt breve, comportamento integrato
    avg_output_tokens=200,
    price_input_per_million=0.30,  # tariffa FT più alta
    price_output_per_million=1.20
)

print(f"Costo mensile base: ${base_cost:.2f}")
print(f"Costo mensile fine-tunato: ${ft_cost:.2f}")
print(f"Differenza: ${ft_cost - base_cost:+.2f}")

Ridurre i token di input

La leva principale per il risparmio con un modello fine-tunato è la riduzione del prompt. Ogni istruzione che riesci a rimuovere perché il modello l’ha interiorizzata è un guadagno ripetuto su ogni chiamata, fino alla fine del vita del servizio. La tabella seguente fornisce gli ordini di grandezza osservati in base al grado di integrazione raggiunto.

Approccio Token di input Risparmio
Modello base + prompt dettagliato 500-1000 token Riferimento
Fine-tunato + prompt minimo 50-100 token 80-90% sull'input
Fine-tunato + nessun prompt di sistema 20-50 token 95% sull'input

Non rimuovere tutte queste istruzioni in una volta sola sperando che tutto regga. Rimuovile a gruppi, rieseguendo il tuo set di test dopo ogni rimozione: scoprirai che alcune regole sono state apprese perfettamente mentre altre, meno rappresentate nei tuoi esempi, devono restare nel prompt.

Bilanciare dimensione del dataset ed epoche

Più dati offrono un modello migliore, ma anche un costo di addestramento più elevato, e i rendimenti diminuiscono. Passare da cento a trecento esempi cambia solitamente molto; passare da mille a tremila cambia poco, per tre volte il prezzo. Addestra diverse dimensioni, misura la qualità ottenuta e mettila in relazione con il costo per trovare il tuo punto di pareggio.

def find_optimal(results_by_size: dict):
    """Identifica la dimensione ottimale del dataset."""
    print("Dimensione dataset | Punteggio qualità | Costo addestramento")
    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"\nDimensione ottimale: {optimal_size} esempi")

La scelta del modello base pesa sulla stessa bilancia. Luna è più economico di Terra, sia per l’addestramento che per l’inferenza: inizia sempre con il modello più economico e passa a quello superiore solo se la qualità ottenuta è insufficiente. Verifica quali modelli sono idonei per il fine-tuning nella documentazione di OpenAI: l’elenco cambia con ogni generazione e non copre mai l’intero catalogo. Poi c’è il numero di epoche, poiché ogni passaggio aggiuntivo moltiplica meccanicamente il costo di addestramento. Se 2 epoche danno il 95% della qualità di 4 epoche, la scelta è rapida.

Monitorare la spesa in produzione

La stima fatta prima del lancio si applica solo all’addestramento. In produzione, è il traffico reale a guidare i costi, e spesso sorprende al rialzo. Un contatore alimentato a ogni chiamata, legato a un budget mensile, ti avvisa prima che lo faccia la fattura. La soglia dell’80% lascia il tempo di reagire: ridurre un prompt, limitare le lunghezze di risposta o spostare parte del traffico su un modello più economico.

class CostTracker:
    """Tracciamento dei costi in tempo reale."""

    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 il costo di una chiamata."""
        cost = (
            input_tokens * input_price / 1_000_000 +
            output_tokens * output_price / 1_000_000
        )
        self.spending += cost
        self.calls += 1

        # Avviso se ci si avvicina al budget
        utilization = self.spending / self.budget * 100
        if utilization > 80:
            print(f"ALLARME: {utilization:.1f}% del budget mensile utilizzato")

    def report(self):
        """Rapporto di consumo."""
        print(f"Chiamate: {self.calls}")
        print(f"Spesa: ${self.spending:.2f}")
        print(f"Budget residuo: ${self.budget - self.spending:.2f}")
        if self.calls > 0:
            print(f"Costo medio per chiamata: ${self.spending / self.calls:.4f}")

Giustificare l’investimento

Rimane la domanda che la tua leadership ti porrà prima o poi: quanto tempo ci vuole perché l’addestramento si ripaghi? Il calcolo mette in relazione un costo una tantum con un beneficio mensile, che somma i risparmi di token e il valore che assegni ai guadagni di qualità. Questo secondo termine è il più delicato, ed è meglio lasciarlo a zero piuttosto che inventarlo: un payback dimostrato sui soli risparmi misurabili ha più forza di una proiezione generosa.

def calculate_roi(
    training_cost: float,
    monthly_savings: float,
    quality_gain_value: float = 0
) -> dict:
    """Calcola il ritorno sull'investimento per il 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} mesi",
        "annual_roi": f"{(monthly_benefit * 12 - training_cost) / training_cost * 100:.0f}%"
    }

Punti chiave

  • Stima il costo di addestramento prima di avviare il job
  • La leva principale per il risparmio è ridurre i token di input
  • Inizia con il modello base più economico (Luna) prima di passare a Terra
  • Monitora i costi in produzione con avvisi di budget
  • Calcola il ROI includendo i guadagni di qualità e i risparmi di token