Backtesting delle decisioni dell’agente
Simulazione delle strategie dell’agente su dati storici per convalidarne le prestazioni.
Backtesting delle decisioni dell’agente è una lezione AI Agents gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento AI Agents, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso AI Agents include 4 lezioni in totale.
Perché eseguire il backtest delle decisioni dell'agente?
Non è possibile sapere se il vostro agente finanziario genera buone raccomandazioni senza testarlo su dati storici. Il backtesting riproduce le condizioni di mercato passate attraverso la logica decisionale dell'agente e misura quale sarebbe stata la performance di tali decisioni.
È lo strumento principale per convalidare la qualità della strategia prima della distribuzione in produzione.
La trappola del look-ahead bias
Il look-ahead bias è l'errore più comune e pericoloso nel backtesting: utilizzare dati futuri per prendere una decisione «passata». Ad esempio, usare il prezzo di chiusura della giornata per decidere se acquistare all'apertura della stessa giornata.
Ogni decisione storica deve utilizzare esclusivamente i dati disponibili al momento decisionale simulato.
import pandas as pd
import yfinance as yf
# WRONG — uses today's close to decide today's trade
def bad_signal(history: pd.DataFrame, date: str) -> str:
today_close = history.loc[date, 'Close'] # look-ahead!
if today_close > history['Close'].mean():
return 'BUY'
return 'HOLD'
# CORRECT — uses only data available BEFORE the decision date
def good_signal(history: pd.DataFrame, date: str) -> str:
past_data = history.loc[:date].iloc[:-1] # exclude today
if past_data.empty:
return 'HOLD'
today_open = history.loc[date, 'Open'] # open price known at market open
if today_open > past_data['Close'].mean():
return 'BUY'
return 'HOLD'Creazione del ciclo di replay storico
Iterare su ogni data storica. A ogni passaggio, l'agente vede solo i dati disponibili fino a quel momento. Registrare la decisione, quindi passare alla data successiva per osservarne l'esito.
import yfinance as yf
import pandas as pd
def backtest_simple(ticker: str, start: str, end: str) -> list[dict]:
hist = yf.Ticker(ticker).history(start=start, end=end)
results = []
for i in range(20, len(hist)): # need 20 days of history for signals
window = hist.iloc[:i] # data available on day i
today = hist.iloc[i]
decision = good_signal(window, str(hist.index[i].date()))
results.append({
'date': str(hist.index[i].date()),
'decision': decision,
'open': float(today['Open']),
'close': float(today['Close']),
'next_day_return': None # filled in next iteration
})
return resultsSimulazione della logica dell'agente a ogni passaggio
Per un backtest più realistico, simulare la chiamata completa allo strumento dell'agente a ogni data, inclusi la costruzione del prompt, la chiamata all'LLM e il parsing della decisione. In questo modo si testa l'intero sistema, non solo la logica del segnale.
import openai, json
import yfinance as yf
client = openai.OpenAI(api_key='YOUR_OPENAI_KEY')
def agent_decision_at_date(ticker: str, hist_up_to: pd.DataFrame) -> str:
recent = hist_up_to.tail(20)
closes = recent['Close'].tolist()
returns = [round((closes[i] - closes[i-1]) / closes[i-1], 4)
for i in range(1, len(closes))]
prompt = (
f'Ticker: {ticker}\n'
f'Last 20 closing prices: {closes}\n'
f'Daily returns: {returns}\n'
f'Based on this data, recommend: BUY, SELL, or HOLD.\n'
f'Return JSON: {{"action": "BUY/SELL/HOLD", "reason": "..."}}'
)
resp = client.chat.completions.create(
model='gpt-4o-mini',
messages=[{'role': 'user', 'content': prompt}],
response_format={'type': 'json_object'}
)
return json.loads(resp.choices[0].message.content).get('action', 'HOLD')Calcolo del tasso di successo
Il tasso di successo misura la percentuale di decisioni BUY seguite da un rendimento positivo il giorno successivo. Un tasso di successo superiore al 50% significa che l'agente prevede correttamente la direzione più spesso di quanto accadrebbe per caso.
def compute_hit_rate(results: list[dict]) -> dict:
buy_decisions = [r for r in results if r['decision'] == 'BUY'
and r.get('next_day_return') is not None]
if not buy_decisions:
return {'hit_rate': None, 'sample_size': 0}
correct = sum(1 for r in buy_decisions if r['next_day_return'] > 0)
return {
'hit_rate': round(correct / len(buy_decisions), 4),
'sample_size': len(buy_decisions),
'correct': correct,
'interpretation': 'above_chance' if correct / len(buy_decisions) > 0.52 else 'at_or_below_chance'
}
if __name__ == '__main__':
results = [
{'decision': 'BUY', 'next_day_return': 0.012},
{'decision': 'BUY', 'next_day_return': -0.004},
{'decision': 'HOLD', 'next_day_return': None},
{'decision': 'BUY', 'next_day_return': 0.007},
]
print('Hit rate:', compute_hit_rate(results))
Calcolo del rendimento rispetto al benchmark
Confrontare il rendimento della strategia con il benchmark buy-and-hold. Se l'agente ottiene risultati peggiori rispetto al semplice mantenimento dell'indice, la sua complessità non è giustificata.
def compare_to_benchmark(results: list[dict], ticker: str, period: str = '1y') -> dict:
import yfinance as yf
# Strategy return: only invested on BUY days
buy_days = [r for r in results if r['decision'] == 'BUY'
and r.get('next_day_return') is not None]
strategy_return = sum(r['next_day_return'] for r in buy_days)
# Benchmark: buy-and-hold
hist = yf.Ticker(ticker).history(period=period)['Close']
bh_return = float((hist.iloc[-1] - hist.iloc[0]) / hist.iloc[0])
return {
'strategy_return_pct': round(strategy_return * 100, 2),
'benchmark_return_pct': round(bh_return * 100, 2),
'outperformed': strategy_return > bh_return,
'alpha_pct': round((strategy_return - bh_return) * 100, 2)
}Impatto dei costi di transazione
Senza tenere conto dei costi di transazione (commissioni, spread e slippage), una strategia può sembrare redditizia ma in realtà generare perdite nella pratica. Anche lo 0,1% per operazione si accumula in modo significativo su molte operazioni.
COMMISSION_PCT = 0.001 # 0.1% per trade (buy + sell)
SLIPPAGE_PCT = 0.0005 # 0.05% per trade
def returns_after_costs(decisions: list[dict]) -> dict:
total_return = 0.0
total_cost = 0.0
for d in decisions:
if d['decision'] == 'BUY' and d.get('next_day_return') is not None:
gross = d['next_day_return']
cost = COMMISSION_PCT + SLIPPAGE_PCT
net = gross - cost
total_return += net
total_cost += cost
return {
'gross_return_pct': round((total_return + total_cost) * 100, 2),
'net_return_pct': round(total_return * 100, 2),
'total_costs_pct': round(total_cost * 100, 2),
'num_trades': sum(1 for d in decisions if d['decision'] == 'BUY')
}
if __name__ == '__main__':
decisions = [
{'decision': 'BUY', 'next_day_return': 0.012},
{'decision': 'BUY', 'next_day_return': -0.004},
{'decision': 'HOLD', 'next_day_return': None},
]
print('Returns after trading costs:', returns_after_costs(decisions))
Validazione walk-forward
L'ottimizzazione in-sample (addestrare la strategia sullo stesso periodo utilizzato per il test) porta all'overfitting. La validazione walk-forward utilizza una finestra di addestramento scorrevole seguita da un nuovo periodo di test, proprio come nella distribuzione reale.
def walk_forward_test(ticker: str, total_years: int = 3,
train_months: int = 12, test_months: int = 3) -> list[dict]:
import yfinance as yf
from dateutil.relativedelta import relativedelta
from datetime import date
results = []
start = date(date.today().year - total_years, 1, 1)
end = date.today()
window_start = start
while True:
train_end = window_start + relativedelta(months=train_months)
test_end = train_end + relativedelta(months=test_months)
if test_end > end:
break
# In practice: train your signal on window_start->train_end
# then evaluate on train_end->test_end
results.append({
'train_period': f'{window_start} to {train_end}',
'test_period': f'{train_end} to {test_end}'
})
window_start += relativedelta(months=test_months)
return resultsReport del backtest
Riassumere i risultati del backtest in un report strutturato: tasso di successo, rendimento totale rispetto al benchmark, alpha, Sharpe ratio, drawdown massimo, numero di operazioni e rendimento al netto dei costi.
def backtest_report(ticker: str, results: list[dict]) -> dict:
hit = compute_hit_rate(results)
benchmark = compare_to_benchmark(results, ticker)
costs = returns_after_costs(results)
return {
'ticker': ticker,
'total_decisions': len(results),
'buy_signals': costs['num_trades'],
'hit_rate': hit.get('hit_rate'),
'strategy_return_gross': f'{costs["gross_return_pct"]}%',
'strategy_return_net': f'{costs["net_return_pct"]}%',
'benchmark_return': f'{benchmark["benchmark_return_pct"]}%',
'alpha': f'{benchmark["alpha_pct"]}%',
'outperformed_benchmark': benchmark['outperformed'],
'transaction_costs': f'{costs["total_costs_pct"]}%'
}Interpretazione dei risultati del backtest
Buoni risultati del backtest non garantiscono performance future, ma risultati negativi identificano le strategie che non dovrebbero essere distribuite. Segnali d'allarme importanti: tasso di successo inferiore al 50%, alpha negativo dopo i costi, Sharpe inferiore a 0,5 oppure drawdown massimo superiore alla vostra tolleranza al rischio.
def interpret_backtest(report: dict) -> list[str]:
warnings = []
hit_rate = report.get('hit_rate')
if hit_rate and hit_rate < 0.50:
warnings.append(f'Hit rate {hit_rate:.1%} is below chance — strategy predicts direction poorly')
alpha_str = report.get('alpha', '0%')
alpha = float(alpha_str.replace('%', '')) / 100
if alpha < 0:
warnings.append(f'Negative alpha {alpha_str}: strategy underperforms buy-and-hold')
if not warnings:
return ['Backtest results look acceptable — proceed with paper trading before live deployment']
return warnings
if __name__ == '__main__':
report = {'hit_rate': 0.45, 'alpha': '-1.2%'}
for warning in interpret_backtest(report):
print('-', warning)
Simulazione Monte Carlo per valutare la robustezza
Un singolo backtest è sensibile allo specifico periodo scelto. La simulazione Monte Carlo randomizza l'ordine dei rendimenti storici per verificare se la performance rimane valida con sequenze diverse, mostrando se la strategia è robusta o semplicemente fortunata.
import numpy as np
def monte_carlo_backtest(daily_returns: list[float],
simulations: int = 1000) -> dict:
returns_arr = np.array(daily_returns)
final_returns = []
for _ in range(simulations):
shuffled = np.random.choice(returns_arr, size=len(returns_arr), replace=True)
cumulative = float((1 + shuffled).prod() - 1)
final_returns.append(cumulative)
final_returns = sorted(final_returns)
return {
'median_return': round(float(np.median(final_returns)) * 100, 2),
'percentile_5': round(float(np.percentile(final_returns, 5)) * 100, 2),
'percentile_95': round(float(np.percentile(final_returns, 95)) * 100, 2),
'prob_positive': round(sum(1 for r in final_returns if r > 0) / simulations, 3)
}Che cos'è il look-ahead bias nel backtesting?
Il look-ahead bias è il modo più comune di sovrastimare accidentalmente la performance di un backtest. Comprenderne la definizione precisa evita di costruire backtest non validi.
Riepilogo del backtesting delle decisioni dell'agente
Un backtesting corretto richiede di: evitare il look-ahead bias (le decisioni usano solo dati passati), simulare una logica realistica dell'agente a ogni passaggio storico, misurare il tasso di successo e l'alpha rispetto al benchmark, tenere conto dei costi di transazione e convalidare la strategia con suddivisioni walk-forward per rilevare l'overfitting.
Domande Frequenti
La lezione «Backtesting delle decisioni dell’agente» è gratuita?
Sì — il testo completo di «Backtesting delle decisioni dell’agente» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso AI Agents, passa a CoddyKit PRO. Il corso AI Agents include 4 lezioni in totale.
Cosa imparerò in «Backtesting delle decisioni dell’agente»?
Simulazione delle strategie dell’agente su dati storici per convalidarne le prestazioni. Eserciti AI Agents con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare AI Agents?
Non è richiesta alcuna esperienza precedente. AI Agents su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.
Quanto tempo richiede la lezione «Backtesting delle decisioni dell’agente»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione AI Agents?
Sì. Ogni lezione AI Agents include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Integrazione delle API per i dati di mercato
- Strumenti dell’agente per l’analisi dei portafogli
- Limiti di sicurezza per rischio e conformità
- Backtesting delle decisioni dell’agente