Tag: quantitative finance coding

Picture this: You’ve spent weeks analyzing market trends, backtesting strategies, and finally, you pull the trigger on a trade. It’s a winner—your portfolio grows by 10%. You’re feeling invincible. Then, a single bad trade wipes out your gains and half your capital. What went wrong? The answer is simple: inadequate risk management.

Trading isn’t just about picking winners; it’s about surviving the losers. Without a structured approach to managing risk, even the best strategies can fail. As engineers, we thrive on systems, optimization, and logic—qualities that are invaluable in trading. This guide will show you how to apply engineering principles to trading risk management and position sizing, ensuring you stay in the game long enough to win.

Table of Contents

• Kelly Criterion
• Position Sizing Methods
• Maximum Drawdown
• Value at Risk
• Stop-Loss Strategies
• Portfolio Risk
• Risk-Adjusted Returns
• Risk Management Checklist
• FAQ

The Kelly Criterion

The Kelly Criterion is a mathematical formula that calculates the optimal bet size to maximize long-term growth. It’s widely used in trading and gambling to balance risk and reward. Here’s the formula:

f* = (bp - q) / b

Where:

• f*: Fraction of capital to allocate to the trade
• b: Odds received on the trade (net return per dollar wagered)
• p: Probability of winning the trade
• q: Probability of losing the trade (q = 1 - p)

Worked Example

Imagine a trade with a 60% chance of success (p = 0.6) and odds of 2:1 (b = 2). Using the Kelly formula:

f* = (2 * 0.6 - 0.4) / 2
f* = 0.4

According to the Kelly Criterion, you should allocate 40% of your capital to this trade.

⚠️ Gotcha: The Kelly Criterion assumes precise knowledge of probabilities and odds, which is rarely available in real-world trading. Overestimating p or underestimating q can lead to over-betting and catastrophic losses.

Full Kelly vs Fractional Kelly
While the Full Kelly strategy uses the exact fraction calculated, it can lead to high volatility. Many traders prefer fractional approaches:

Half Kelly: Use 50% of the f* value
Quarter Kelly: Use 25% of the f* value

For example, if f* = 0.4, Half Kelly would allocate 20% of capital, and Quarter Kelly would allocate 10%. These methods reduce volatility and better handle estimation errors.
Python Implementation
Here’s a Python implementation of the Kelly Criterion:

def calculate_kelly(b, p):
    q = 1 - p  # Probability of losing
    return (b * p - q) / b

# Example usage
b = 2  # Odds (2:1)
p = 0.6  # Probability of winning (60%)

full_kelly = calculate_kelly(b, p)
half_kelly = full_kelly / 2
quarter_kelly = full_kelly / 4

print(f"Full Kelly Fraction: {full_kelly}")
print(f"Half Kelly Fraction: {half_kelly}")
print(f"Quarter Kelly Fraction: {quarter_kelly}")


💡 Pro Tip: Use conservative estimates for p and q to avoid over-betting. Fractional Kelly is often a safer choice for volatile markets.

Position Sizing Methods
Position sizing determines how much capital to allocate to a trade. It’s a cornerstone of risk management, ensuring you don’t risk too much on a single position. Here are four popular methods:
1. Fixed Dollar Method
Risk a fixed dollar amount per trade. For example, if you risk $100 per trade, your position size depends on the stop-loss distance.

def fixed_dollar_size(risk_per_trade, stop_loss):
    return risk_per_trade / stop_loss

# Example usage
print(fixed_dollar_size(100, 2))  # Risk $100 with $2 stop-loss

Pros: Simple and consistent.
Cons: Does not scale with account size or volatility.
2. Fixed Percentage Method
Risk a fixed percentage of your portfolio per trade (e.g., 1% or 2%). This method adapts to account growth and prevents large losses.

def fixed_percentage_size(account_balance, risk_percentage, stop_loss):
    risk_amount = account_balance * (risk_percentage / 100)
    return risk_amount / stop_loss

# Example usage
print(fixed_percentage_size(10000, 2, 2))  # 2% risk of $10,000 account with $2 stop-loss

Pros: Scales with account size.
Cons: Requires frequent recalculation.
3. Volatility-Based (ATR Method)
Uses the Average True Range (ATR) indicator to measure market volatility. Position size is calculated as risk amount divided by ATR value.

def atr_position_size(risk_per_trade, atr_value):
    return risk_per_trade / atr_value

# Example usage
print(atr_position_size(100, 1.5))  # Risk $100 with ATR of 1.5

Pros: Adapts to market volatility.
Cons: Requires ATR calculation.
4. Fixed Ratio (Ryan Jones Method)
Scale position size based on profit milestones. For example, increase position size after every $500 profit.

def fixed_ratio_size(initial_units, account_balance, delta):
    return (account_balance // delta) + initial_units

# Example usage
print(fixed_ratio_size(1, 10500, 500))  # Start with 1 unit, increase per $500 delta

Pros: Encourages disciplined scaling.
Cons: Requires careful calibration of milestones.
Maximum Drawdown
Maximum Drawdown (MDD) measures the largest peak-to-trough decline in portfolio value. It’s a critical metric for understanding risk.

def calculate_max_drawdown(equity_curve):
    peak = equity_curve[0]
    max_drawdown = 0

    for value in equity_curve:
        if value > peak:
            peak = value
        drawdown = (peak - value) / peak
        max_drawdown = max(max_drawdown, drawdown)

    return max_drawdown

# Example usage
equity_curve = [100, 120, 90, 80, 110]
print(f"Maximum Drawdown: {calculate_max_drawdown(equity_curve)}")


🔐 Security Note: Recovery from drawdowns is non-linear. A 50% loss requires a 100% gain to break even. Always aim to minimize drawdowns to preserve capital.

Value at Risk (VaR)
Value at Risk estimates the potential loss of a portfolio over a specified time period with a given confidence level.
Historical VaR
Calculates potential loss based on historical returns.

def calculate_historical_var(returns, confidence_level):
    sorted_returns = sorted(returns)
    index = int((1 - confidence_level) * len(sorted_returns))
    return -sorted_returns[index]

# Example usage
portfolio_returns = [-0.02, -0.01, 0.01, 0.02, -0.03, 0.03, -0.04]
confidence_level = 0.95
print(f"Historical VaR: {calculate_historical_var(portfolio_returns, confidence_level)}")

Conclusion
Risk management is the backbone of successful trading. Key takeaways:

Use the Kelly Criterion cautiously; fractional approaches are safer.
Adopt position sizing methods that align with your risk tolerance.
Monitor Maximum Drawdown to understand portfolio resilience.
Leverage Value at Risk to quantify potential losses.

What’s your go-to risk management strategy? Email [email protected] with your thoughts!


Related Reading
Want to deepen your trading knowledge? Check out these related guides:

Algorithmic Trading Basics for Engineers — A foundational guide to building your first trading algorithms.
Mastering Options Strategies — A math-driven approach to options trading strategies.


📊 Free AI Market Intelligence
Join Alpha Signal — AI-powered market research delivered daily. Narrative detection, geopolitical risk scoring, sector rotation analysis.
Join Free on Telegram →
Pro with stock conviction scores: $5/mo