Wall Street quants guard their algorithms like state secrets. But what if you could build sophisticated financial models on your laptop without sending sensitive data to the cloud? Enter Ollama—your local AI assistant for quantitative finance that won't judge your portfolio performance.
This guide shows you how to implement the Black-Scholes options pricing model and Monte Carlo simulations using Ollama's local AI capabilities. You'll build production-ready financial models while keeping your data private.
Why Use Ollama for Quantitative Finance?
Traditional quantitative finance tools often require expensive licenses or cloud services. Ollama changes this equation by providing local AI assistance for financial modeling. You get privacy, control, and zero recurring costs.
Benefits of Ollama for financial modeling:
- Complete data privacy - Models run locally
- Zero ongoing costs - No API fees or subscriptions
- Instant responses - No network latency
- Custom fine-tuning - Adapt models to your trading strategies
- Offline capability - Trade models work without internet
Prerequisites and Setup
Before building financial models, you need the right tools installed.
Required Software
# Install Ollama
curl -fsSL https://ollama.ai/install.sh | sh
# Pull a capable model for mathematical computations
ollama pull codellama:13b
# Install Python dependencies
pip install numpy pandas matplotlib scipy ollama-python
Essential Python Libraries
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.stats import norm
import ollama
import json
from datetime import datetime, timedelta
Setting Up Ollama for Financial Calculations
Ollama excels at generating and explaining complex financial code. Configure it properly for quantitative work.
Initialize Ollama Client
class FinanceAI:
def __init__(self, model="codellama:13b"):
self.model = model
self.client = ollama.Client()
def generate_code(self, prompt, context=""):
"""Generate financial modeling code with Ollama"""
full_prompt = f"""
Context: {context}
Generate Python code for: {prompt}
Requirements:
- Use numpy and scipy for calculations
- Include proper error handling
- Add clear comments explaining each step
- Follow quantitative finance best practices
"""
response = self.client.chat(
model=self.model,
messages=[{"role": "user", "content": full_prompt}]
)
return response['message']['content']
# Initialize the AI assistant
finance_ai = FinanceAI()
Black-Scholes Model Implementation
The Black-Scholes model calculates theoretical options prices. This implementation handles both call and put options with dividend yields.
Core Black-Scholes Formula
class BlackScholesCalculator:
def __init__(self):
self.cache = {}
def calculate_option_price(self, S, K, T, r, sigma, option_type='call', q=0):
"""
Calculate Black-Scholes option price
Parameters:
S: Current stock price
K: Strike price
T: Time to expiration (years)
r: Risk-free rate
sigma: Volatility
option_type: 'call' or 'put'
q: Dividend yield (default 0)
"""
# Calculate d1 and d2
d1 = (np.log(S/K) + (r - q + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
d2 = d1 - sigma * np.sqrt(T)
if option_type.lower() == 'call':
price = (S * np.exp(-q * T) * norm.cdf(d1) -
K * np.exp(-r * T) * norm.cdf(d2))
else: # put option
price = (K * np.exp(-r * T) * norm.cdf(-d2) -
S * np.exp(-q * T) * norm.cdf(-d1))
return {
'price': price,
'd1': d1,
'd2': d2,
'delta': self._calculate_delta(S, K, T, r, sigma, option_type, q),
'gamma': self._calculate_gamma(S, K, T, r, sigma, q),
'theta': self._calculate_theta(S, K, T, r, sigma, option_type, q),
'vega': self._calculate_vega(S, K, T, r, sigma, q)
}
def _calculate_delta(self, S, K, T, r, sigma, option_type, q):
"""Calculate option delta (price sensitivity to underlying)"""
d1 = (np.log(S/K) + (r - q + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
if option_type.lower() == 'call':
return np.exp(-q * T) * norm.cdf(d1)
else:
return -np.exp(-q * T) * norm.cdf(-d1)
def _calculate_gamma(self, S, K, T, r, sigma, q):
"""Calculate option gamma (delta sensitivity to underlying)"""
d1 = (np.log(S/K) + (r - q + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
return (np.exp(-q * T) * norm.pdf(d1)) / (S * sigma * np.sqrt(T))
def _calculate_theta(self, S, K, T, r, sigma, option_type, q):
"""Calculate option theta (time decay)"""
d1 = (np.log(S/K) + (r - q + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
d2 = d1 - sigma * np.sqrt(T)
term1 = -(S * norm.pdf(d1) * sigma * np.exp(-q * T)) / (2 * np.sqrt(T))
if option_type.lower() == 'call':
term2 = r * K * np.exp(-r * T) * norm.cdf(d2)
term3 = -q * S * np.exp(-q * T) * norm.cdf(d1)
else:
term2 = -r * K * np.exp(-r * T) * norm.cdf(-d2)
term3 = q * S * np.exp(-q * T) * norm.cdf(-d1)
return (term1 - term2 + term3) / 365 # Convert to daily theta
def _calculate_vega(self, S, K, T, r, sigma, q):
"""Calculate option vega (volatility sensitivity)"""
d1 = (np.log(S/K) + (r - q + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
return S * np.exp(-q * T) * norm.pdf(d1) * np.sqrt(T) / 100 # Per 1% vol change
# Example usage
bs_calc = BlackScholesCalculator()
# Calculate call option price
result = bs_calc.calculate_option_price(
S=100, # Current stock price
K=105, # Strike price
T=0.25, # 3 months to expiration
r=0.05, # 5% risk-free rate
sigma=0.2, # 20% volatility
option_type='call'
)
print(f"Call Option Price: ${result['price']:.2f}")
print(f"Delta: {result['delta']:.4f}")
print(f"Gamma: {result['gamma']:.4f}")
print(f"Theta: ${result['theta']:.2f} per day")
print(f"Vega: ${result['vega']:.2f} per 1% vol change")
Advanced Black-Scholes Features
def analyze_option_sensitivity(S_range, K, T, r, sigma, option_type='call'):
"""Analyze how option price changes with underlying price"""
prices = []
deltas = []
gammas = []
bs_calc = BlackScholesCalculator()
for S in S_range:
result = bs_calc.calculate_option_price(S, K, T, r, sigma, option_type)
prices.append(result['price'])
deltas.append(result['delta'])
gammas.append(result['gamma'])
return {
'prices': prices,
'deltas': deltas,
'gammas': gammas,
'underlying_prices': S_range
}
# Generate sensitivity analysis
S_range = np.linspace(80, 120, 50)
sensitivity = analyze_option_sensitivity(S_range, K=100, T=0.25, r=0.05, sigma=0.2)
# Plot results
fig, (ax1, ax2, ax3) = plt.subplots(3, 1, figsize=(10, 12))
ax1.plot(S_range, sensitivity['prices'])
ax1.set_title('Option Price vs Underlying Price')
ax1.set_xlabel('Stock Price')
ax1.set_ylabel('Option Price')
ax1.grid(True)
ax2.plot(S_range, sensitivity['deltas'])
ax2.set_title('Delta vs Underlying Price')
ax2.set_xlabel('Stock Price')
ax2.set_ylabel('Delta')
ax2.grid(True)
ax3.plot(S_range, sensitivity['gammas'])
ax3.set_title('Gamma vs Underlying Price')
ax3.set_xlabel('Stock Price')
ax3.set_ylabel('Gamma')
ax3.grid(True)
plt.tight_layout()
plt.show()
Monte Carlo Simulation Implementation
Monte Carlo methods simulate thousands of possible price paths. This approach handles complex derivatives that lack closed-form solutions.
Basic Monte Carlo Engine
class MonteCarloEngine:
def __init__(self, random_seed=42):
np.random.seed(random_seed)
def simulate_stock_paths(self, S0, mu, sigma, T, dt, num_paths):
"""
Simulate stock price paths using geometric Brownian motion
Parameters:
S0: Initial stock price
mu: Expected return (drift)
sigma: Volatility
T: Time horizon
dt: Time step
num_paths: Number of simulation paths
"""
num_steps = int(T / dt)
# Pre-allocate arrays for efficiency
paths = np.zeros((num_paths, num_steps + 1))
paths[:, 0] = S0
# Generate random shocks
random_shocks = np.random.normal(0, 1, (num_paths, num_steps))
# Calculate price paths
for i in range(num_steps):
paths[:, i + 1] = paths[:, i] * np.exp(
(mu - 0.5 * sigma**2) * dt + sigma * np.sqrt(dt) * random_shocks[:, i]
)
return paths
def price_european_option(self, S0, K, T, r, sigma, option_type='call',
num_paths=100000, num_steps=252):
"""Price European option using Monte Carlo simulation"""
dt = T / num_steps
# Simulate stock paths
paths = self.simulate_stock_paths(S0, r, sigma, T, dt, num_paths)
# Calculate payoffs at expiration
final_prices = paths[:, -1]
if option_type.lower() == 'call':
payoffs = np.maximum(final_prices - K, 0)
else: # put option
payoffs = np.maximum(K - final_prices, 0)
# Discount payoffs to present value
option_price = np.exp(-r * T) * np.mean(payoffs)
# Calculate confidence interval
std_error = np.std(payoffs) / np.sqrt(num_paths)
confidence_interval = 1.96 * std_error * np.exp(-r * T)
return {
'price': option_price,
'std_error': std_error,
'confidence_interval': confidence_interval,
'payoffs': payoffs,
'final_prices': final_prices
}
def price_asian_option(self, S0, K, T, r, sigma, option_type='call',
num_paths=100000, num_steps=252):
"""Price Asian (average price) option using Monte Carlo"""
dt = T / num_steps
paths = self.simulate_stock_paths(S0, r, sigma, T, dt, num_paths)
# Calculate average prices for each path
avg_prices = np.mean(paths, axis=1)
if option_type.lower() == 'call':
payoffs = np.maximum(avg_prices - K, 0)
else:
payoffs = np.maximum(K - avg_prices, 0)
option_price = np.exp(-r * T) * np.mean(payoffs)
std_error = np.std(payoffs) / np.sqrt(num_paths)
return {
'price': option_price,
'std_error': std_error,
'average_prices': avg_prices,
'payoffs': payoffs
}
# Example usage
mc_engine = MonteCarloEngine()
# Price European call option
european_result = mc_engine.price_european_option(
S0=100, K=105, T=0.25, r=0.05, sigma=0.2,
option_type='call', num_paths=100000
)
print(f"Monte Carlo European Call Price: ${european_result['price']:.2f}")
print(f"Standard Error: ${european_result['std_error']:.4f}")
print(f"95% Confidence Interval: ±${european_result['confidence_interval']:.2f}")
# Price Asian call option
asian_result = mc_engine.price_asian_option(
S0=100, K=105, T=0.25, r=0.05, sigma=0.2,
option_type='call', num_paths=100000
)
print(f"Monte Carlo Asian Call Price: ${asian_result['price']:.2f}")
Advanced Monte Carlo Features
class AdvancedMonteCarloEngine(MonteCarloEngine):
def simulate_with_jumps(self, S0, mu, sigma, T, dt, num_paths,
jump_intensity=0.1, jump_size_mean=-0.05, jump_size_std=0.1):
"""Simulate stock paths with jump diffusion (Merton model)"""
num_steps = int(T / dt)
paths = np.zeros((num_paths, num_steps + 1))
paths[:, 0] = S0
for i in range(num_steps):
# Regular Brownian motion component
random_normal = np.random.normal(0, 1, num_paths)
# Jump component
jump_times = np.random.poisson(jump_intensity * dt, num_paths)
jumps = np.zeros(num_paths)
for j in range(num_paths):
if jump_times[j] > 0:
jump_sizes = np.random.normal(jump_size_mean, jump_size_std, jump_times[j])
jumps[j] = np.sum(jump_sizes)
# Update paths
paths[:, i + 1] = paths[:, i] * np.exp(
(mu - 0.5 * sigma**2) * dt +
sigma * np.sqrt(dt) * random_normal +
jumps
)
return paths
def calculate_var_es(self, returns, confidence_level=0.95):
"""Calculate Value at Risk and Expected Shortfall"""
sorted_returns = np.sort(returns)
var_index = int((1 - confidence_level) * len(sorted_returns))
var = -sorted_returns[var_index]
es = -np.mean(sorted_returns[:var_index])
return {
'var': var,
'expected_shortfall': es,
'confidence_level': confidence_level
}
def portfolio_risk_analysis(self, portfolio_weights, asset_returns,
num_simulations=10000, horizon_days=30):
"""Comprehensive portfolio risk analysis"""
# Calculate portfolio returns
portfolio_returns = []
for _ in range(num_simulations):
# Sample from historical returns or use Monte Carlo
simulated_returns = np.random.multivariate_normal(
np.mean(asset_returns, axis=0),
np.cov(asset_returns.T),
horizon_days
)
portfolio_return = np.sum(
np.sum(simulated_returns * portfolio_weights, axis=1)
)
portfolio_returns.append(portfolio_return)
portfolio_returns = np.array(portfolio_returns)
# Calculate risk metrics
var_es = self.calculate_var_es(portfolio_returns)
return {
'expected_return': np.mean(portfolio_returns),
'volatility': np.std(portfolio_returns),
'var_95': var_es['var'],
'expected_shortfall_95': var_es['expected_shortfall'],
'returns_distribution': portfolio_returns
}
# Example risk analysis
advanced_mc = AdvancedMonteCarloEngine()
# Simulate asset returns (example data)
np.random.seed(42)
asset_returns = np.random.multivariate_normal(
[0.08, 0.12, 0.06], # Expected returns for 3 assets
[[0.04, 0.01, 0.005], [0.01, 0.09, 0.01], [0.005, 0.01, 0.02]], # Covariance matrix
252 # One year of daily returns
)
portfolio_weights = np.array([0.4, 0.4, 0.2]) # Portfolio allocation
risk_analysis = advanced_mc.portfolio_risk_analysis(
portfolio_weights, asset_returns, num_simulations=10000
)
print("Portfolio Risk Analysis:")
print(f"Expected Annual Return: {risk_analysis['expected_return']:.2%}")
print(f"Annual Volatility: {risk_analysis['volatility']:.2%}")
print(f"95% VaR (30-day): ${risk_analysis['var_95']:.2f}")
print(f"95% Expected Shortfall: ${risk_analysis['expected_shortfall_95']:.2f}")
Using Ollama for Model Enhancement
Ollama can generate sophisticated financial models and explain complex concepts. Here's how to leverage it effectively.
AI-Assisted Model Development
def generate_custom_model(finance_ai, model_description):
"""Use Ollama to generate custom financial models"""
prompt = f"""
Create a Python class for this financial model: {model_description}
Requirements:
- Include proper docstrings
- Handle edge cases and validation
- Use numpy for numerical calculations
- Follow quantitative finance conventions
- Include example usage
"""
code = finance_ai.generate_code(prompt)
return code
# Example: Generate a volatility surface model
vol_surface_code = generate_custom_model(
finance_ai,
"A volatility surface interpolation model that takes strike prices, "
"expiration dates, and implied volatilities to create a smooth surface "
"for pricing exotic options"
)
print("Generated Volatility Surface Model:")
print(vol_surface_code)
Model Validation with AI
def validate_model_results(finance_ai, model_output, expected_range):
"""Use AI to validate model results and suggest improvements"""
prompt = f"""
Analyze these quantitative finance model results:
Model Output: {model_output}
Expected Range: {expected_range}
Tasks:
1. Check if results are reasonable
2. Identify potential issues
3. Suggest model improvements
4. Recommend additional validation tests
"""
analysis = finance_ai.generate_code(prompt)
return analysis
# Example validation
bs_price = 8.45
expected_range = "5-12 for similar market conditions"
validation = validate_model_results(finance_ai, bs_price, expected_range)
print("Model Validation Analysis:")
print(validation)
Practical Trading Applications
Transform theoretical models into practical trading tools.
Real-Time Options Scanner
class OptionsScanner:
def __init__(self):
self.bs_calc = BlackScholesCalculator()
self.mc_engine = MonteCarloEngine()
def scan_opportunities(self, market_data, criteria):
"""Scan for trading opportunities based on model criteria"""
opportunities = []
for option in market_data:
# Calculate theoretical price
theoretical = self.bs_calc.calculate_option_price(
S=option['underlying_price'],
K=option['strike'],
T=option['time_to_expiration'],
r=option['risk_free_rate'],
sigma=option['implied_vol'],
option_type=option['type']
)
# Compare with market price
market_price = option['market_price']
edge = (theoretical['price'] - market_price) / market_price
# Check if opportunity meets criteria
if self._meets_criteria(edge, theoretical, criteria):
opportunities.append({
'symbol': option['symbol'],
'market_price': market_price,
'theoretical_price': theoretical['price'],
'edge': edge,
'delta': theoretical['delta'],
'gamma': theoretical['gamma'],
'theta': theoretical['theta'],
'vega': theoretical['vega']
})
return sorted(opportunities, key=lambda x: abs(x['edge']), reverse=True)
def _meets_criteria(self, edge, greeks, criteria):
"""Check if opportunity meets trading criteria"""
return (
abs(edge) >= criteria.get('min_edge', 0.05) and
abs(greeks['delta']) >= criteria.get('min_delta', 0.1) and
greeks['gamma'] >= criteria.get('min_gamma', 0.01)
)
# Example usage
scanner = OptionsScanner()
# Sample market data (in practice, this comes from your data feed)
sample_market_data = [
{
'symbol': 'SPY_240315C420',
'underlying_price': 425,
'strike': 420,
'time_to_expiration': 0.08, # ~1 month
'risk_free_rate': 0.05,
'implied_vol': 0.18,
'market_price': 8.50,
'type': 'call'
},
# Add more options...
]
criteria = {
'min_edge': 0.03, # 3% minimum edge
'min_delta': 0.15,
'min_gamma': 0.005
}
opportunities = scanner.scan_opportunities(sample_market_data, criteria)
for opp in opportunities[:5]: # Show top 5 opportunities
print(f"Symbol: {opp['symbol']}")
print(f"Edge: {opp['edge']:.2%}")
print(f"Market: ${opp['market_price']:.2f}, Theoretical: ${opp['theoretical_price']:.2f}")
print("---")
Risk Management System
class RiskManager:
def __init__(self, max_portfolio_delta=1000, max_portfolio_gamma=100):
self.max_portfolio_delta = max_portfolio_delta
self.max_portfolio_gamma = max_portfolio_gamma
self.mc_engine = MonteCarloEngine()
def calculate_portfolio_greeks(self, positions):
"""Calculate total portfolio Greeks"""
total_delta = sum(pos['delta'] * pos['quantity'] for pos in positions)
total_gamma = sum(pos['gamma'] * pos['quantity'] for pos in positions)
total_theta = sum(pos['theta'] * pos['quantity'] for pos in positions)
total_vega = sum(pos['vega'] * pos['quantity'] for pos in positions)
return {
'delta': total_delta,
'gamma': total_gamma,
'theta': total_theta,
'vega': total_vega
}
def check_risk_limits(self, positions):
"""Check if positions violate risk limits"""
greeks = self.calculate_portfolio_greeks(positions)
violations = []
if abs(greeks['delta']) > self.max_portfolio_delta:
violations.append(f"Delta limit exceeded: {greeks['delta']:.0f}")
if abs(greeks['gamma']) > self.max_portfolio_gamma:
violations.append(f"Gamma limit exceeded: {greeks['gamma']:.2f}")
return {
'violations': violations,
'portfolio_greeks': greeks,
'within_limits': len(violations) == 0
}
def simulate_portfolio_pnl(self, positions, price_scenarios, vol_scenarios):
"""Simulate portfolio P&L under different market scenarios"""
pnl_scenarios = []
for price_change in price_scenarios:
for vol_change in vol_scenarios:
scenario_pnl = 0
for pos in positions:
# Approximate P&L using Greeks
delta_pnl = pos['delta'] * pos['quantity'] * price_change
gamma_pnl = 0.5 * pos['gamma'] * pos['quantity'] * price_change**2
vega_pnl = pos['vega'] * pos['quantity'] * vol_change
theta_pnl = pos['theta'] * pos['quantity'] # One day theta decay
position_pnl = delta_pnl + gamma_pnl + vega_pnl + theta_pnl
scenario_pnl += position_pnl
pnl_scenarios.append({
'price_change': price_change,
'vol_change': vol_change,
'pnl': scenario_pnl
})
return pnl_scenarios
# Example risk monitoring
risk_manager = RiskManager()
# Sample portfolio positions
portfolio_positions = [
{
'symbol': 'SPY_240315C420',
'quantity': 10,
'delta': 0.6,
'gamma': 0.02,
'theta': -0.15,
'vega': 0.25
},
{
'symbol': 'SPY_240315P415',
'quantity': -5,
'delta': -0.4,
'gamma': 0.02,
'theta': -0.12,
'vega': 0.22
}
]
# Check risk limits
risk_check = risk_manager.check_risk_limits(portfolio_positions)
print("Risk Check Results:")
print(f"Portfolio Delta: {risk_check['portfolio_greeks']['delta']:.1f}")
print(f"Portfolio Gamma: {risk_check['portfolio_greeks']['gamma']:.2f}")
print(f"Within Limits: {risk_check['within_limits']}")
if risk_check['violations']:
print("Violations:")
for violation in risk_check['violations']:
print(f" - {violation}")
Performance Optimization Tips
Optimize your quantitative models for production trading systems.
Efficient Computation Strategies
import numba
from numba import jit
import concurrent.futures
@jit(nopython=True)
def fast_black_scholes_batch(S, K, T, r, sigma, is_call):
"""Vectorized Black-Scholes calculation using Numba JIT compilation"""
d1 = (np.log(S/K) + (r + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
d2 = d1 - sigma * np.sqrt(T)
# Use approximation for normal CDF for speed
def norm_cdf_approx(x):
return 0.5 * (1 + np.tanh(np.sqrt(2/np.pi) * (x + 0.044715 * x**3)))
if is_call:
price = S * norm_cdf_approx(d1) - K * np.exp(-r * T) * norm_cdf_approx(d2)
else:
price = K * np.exp(-r * T) * norm_cdf_approx(-d2) - S * norm_cdf_approx(-d1)
return price
# Parallel Monte Carlo simulation
def parallel_monte_carlo(S0, K, T, r, sigma, option_type, total_paths, num_workers=4):
"""Run Monte Carlo simulation in parallel"""
paths_per_worker = total_paths // num_workers
def worker_simulation(paths):
mc_engine = MonteCarloEngine()
return mc_engine.price_european_option(
S0, K, T, r, sigma, option_type, num_paths=paths
)
with concurrent.futures.ProcessPoolExecutor(max_workers=num_workers) as executor:
futures = [
executor.submit(worker_simulation, paths_per_worker)
for _ in range(num_workers)
]
results = [future.result() for future in futures]
# Combine results
all_payoffs = np.concatenate([result['payoffs'] for result in results])
combined_price = np.exp(-r * T) * np.mean(all_payoffs)
return {
'price': combined_price,
'std_error': np.std(all_payoffs) / np.sqrt(len(all_payoffs)),
'total_paths': len(all_payoffs)
}
# Performance comparison
import time
# Standard calculation
start_time = time.time()
standard_result = mc_engine.price_european_option(
S0=100, K=105, T=0.25, r=0.05, sigma=0.2,
num_paths=1000000
)
standard_time = time.time() - start_time
# Parallel calculation
start_time = time.time()
parallel_result = parallel_monte_carlo(
S0=100, K=105, T=0.25, r=0.05, sigma=0.2,
option_type='call', total_paths=1000000
)
parallel_time = time.time() - start_time
print(f"Standard MC: ${standard_result['price']:.3f} in {standard_time:.2f}s")
print(f"Parallel MC: ${parallel_result['price']:.3f} in {parallel_time:.2f}s")
print(f"Speedup: {standard_time/parallel_time:.1f}x")
Conclusion
You now have production-ready quantitative finance models using Ollama's local AI capabilities. The Black-Scholes implementation handles standard European options with full Greeks calculations. The Monte Carlo engine prices complex derivatives and performs risk analysis.
Key benefits of this Ollama-powered approach:
- Complete data privacy for sensitive trading algorithms
- Zero ongoing costs compared to cloud-based solutions
- Customizable AI assistance for model development and validation
- Production-ready performance with optimization techniques
The next step involves deploying these models in your trading infrastructure. Consider adding real-time data feeds, database integration, and monitoring systems for live trading applications.
Your quantitative finance toolkit now combines traditional mathematical rigor with modern AI assistance—all running securely on your local machine.