Simulare Monte Carlo de Riscuri — Modelarea Rezultatelor Portofoliului

Simulările Monte Carlo vă permit să modelați peste 100.000 de scenarii viitoare posibile pentru portofoliul dumneavoastră, cuantificând metrici de risc precum Valoarea la Risc (VaR) și pierderea așteptată. În loc să presupuneți un singur rezultat, vedeți distribuția posibilităților.

Exemplu: Rulează 100.000 de simulări pentru strategia ta de tranzacționare. Vei vedea: 68% din rezultate au un profit de $10-$50, 25% pierd $10-$30, 5% pierd $50-$200, și 2% profită $100+. Acum îți înțelegi profilul de risc.

Mișcare Browniană Geometrică de Bază (GBM)

Modelează prețurile viitoare ca niște plimbări aleatorii cu derivă și volatilitate:

Python — Căi de preț Monte Carlo
import numpy as np
def simulate_price_paths(S0, mu, sigma, T, dt, n_sims=10000):
# S0: preț curent, mu: derivă, sigma: volatilitate
# T: orizont de timp (zile), dt: pas de timp, n_sims: simulări
steps = int(T / dt)
paths = np.zeros((n_sims, steps))
paths[:, 0] = S0
for i in range(1, steps):
# dS = mu*S*dt + sigma*S*sqrt(dt)*Z
Z = np.random.normal(0, 1, n_sims)
dS = mu * paths[:, i-1] * dt + sigma * paths[:, i-1] * np.sqrt(dt) * Z
paths[:, i] = paths[:, i-1] + dS
return paths

Metrici de Risc pentru Portofoliu

Valoarea la Risc (VaR)

Pierderea pe care ai depăși-o doar în 5% din scenarii (95% încredere):

Python — Calculează VaR
def calculate_var(simulations, confidence=0.95):
pnl = simulations[:, -1] - simulations[:, 0]
var = np.percentile(pnl, (1 - confidence) * 100)
return var # ex., -$2,340

Pierderea Așteptată (CVaR)

Pierderea medie în cele mai rele 5% cazuri:

Python — Calculează CVaR
def calculate_cvar(simulations, confidence=0.95):
pnl = simulations[:, -1] - simulations[:, 0]
var_threshold = np.percentile(pnl, (1 - confidence) * 100)
worst_5_pct = pnl[pnl <= var_threshold]
cvar = np.mean(worst_5_pct)
return cvar # ex., -$3,800 (mai rău decât VaR)

Simulare Specifică Strategiei

Simulează regulile tale reale de tranzacționare, nu doar căi de preț:

Python — Monte Carlo pentru Strategie
def simulate_strategy(capital, win_rate, avg_win, avg_loss, trades_per_day=10, days=30, n_sims=10000):
results = np.zeros(n_sims)
for sim in range(n_sims):
equity = capital
n_trades = trades_per_day * days
for _ in range(n_trades):
if np.random.rand() < win_rate:
pnl = np.random.normal(avg_win, avg_win * 0.2)
else:
pnl = -np.random.normal(avg_loss, avg_loss * 0.2)
equity += pnl
if equity < capital * 0.5:
break # Stop la pierdere de 50%
results[sim] = equity
return results

Testare de Stres cu Semnale Smart Money

Modelează scenarii de caz cel mai rău când încrederea Smart Money scade:

Python — Scenarii de testare de stres
def stress_test_scenarios(base_win_rate):
# Scenariul 1: Condiții normale (încredere MARE)
scenario_normal = simulate_strategy(10000, win_rate=base_win_rate)
# Scenariul 2: Semnale în deteriorare (încredere MEDIE)
scenario_medium = simulate_strategy(10000, win_rate=base_win_rate * 0.95)
# Scenariul 3: Colaps (condiție VETO)
scenario_veto = simulate_strategy(10000, win_rate=0.45) # margine negativă
return {
'normal': {'var': np.percentile(scenario_normal, 5), 'mean': np.mean(scenario_normal)},
'medium': {'var': np.percentile(scenario_medium, 5), 'mean': np.mean(scenario_medium)},
'veto': {'var': np.percentile(scenario_veto, 5), 'mean': np.mean(scenario_veto)}
}

Interpretare

Din 10.000 de simulări, afli:

Testează strategiile în condiții de stres cu semnale Smart Money

Înțelege riscul portofoliului în condiții normale, în deteriorare și VETO ale Smart Money. API-ul nostru vă oferă semnalele; Monte Carlo modelează rezultatele.

Modelează Riscul Astăzi →