Разработка системы оптимизации портфеля (Modern Portfolio Theory)
Modern Portfolio Theory (MPT) Гарри Марковица — математический фреймворк для построения оптимального портфеля. Центральная идея: правильная диверсификация позволяет достичь более высокой доходности при том же уровне риска (или того же уровня доходности при меньшем риске). «Efficient Frontier» — граница портфелей с оптимальным соотношением доходность/риск.
Математическая основа
Portfolio Return: E[Rp] = Σ(wi × E[Ri])
Portfolio Variance: σ²p = Σi Σj wi × wj × σij
где σij — ковариация между активами i и j.
Ключевое insight: если активы не коррелируют идеально (ρ < 1), комбинированный риск портфеля меньше средневзвешенного риска отдельных активов.
Efficient Frontier для криптопортфеля
import numpy as np
import pandas as pd
from scipy.optimize import minimize
class MarkowitzOptimizer:
def __init__(self, returns_df, risk_free_rate=0.05):
self.returns = returns_df
self.mean_returns = returns_df.mean() * 252 # annualized
self.cov_matrix = returns_df.cov() * 252 # annualized
self.n_assets = len(returns_df.columns)
self.symbols = list(returns_df.columns)
self.rf = risk_free_rate
def portfolio_performance(self, weights):
ret = np.dot(weights, self.mean_returns)
std = np.sqrt(np.dot(weights.T, np.dot(self.cov_matrix, weights)))
sharpe = (ret - self.rf) / std
return ret, std, sharpe
def minimize_volatility(self, target_return):
"""Минимизируем волатильность при заданной целевой доходности"""
constraints = [
{'type': 'eq', 'fun': lambda w: np.sum(w) - 1},
{'type': 'eq', 'fun': lambda w: self.portfolio_performance(w)[0] - target_return}
]
bounds = [(0, 0.40) for _ in range(self.n_assets)] # max 40% в одном активе
result = minimize(
lambda w: self.portfolio_performance(w)[1],
x0=np.ones(self.n_assets) / self.n_assets,
method='SLSQP',
bounds=bounds,
constraints=constraints
)
return result.x
def maximize_sharpe_ratio(self):
"""Максимизируем Sharpe Ratio — tangency portfolio"""
constraints = [{'type': 'eq', 'fun': lambda w: np.sum(w) - 1}]
bounds = [(0, 0.40) for _ in range(self.n_assets)]
result = minimize(
lambda w: -self.portfolio_performance(w)[2], # минус Sharpe
x0=np.ones(self.n_assets) / self.n_assets,
method='SLSQP',
bounds=bounds,
constraints=constraints
)
return result.x
def build_efficient_frontier(self, n_points=100):
"""Строим Efficient Frontier"""
min_ret = self.mean_returns.min()
max_ret = self.mean_returns.max()
target_returns = np.linspace(min_ret, max_ret, n_points)
frontier_points = []
for target in target_returns:
try:
weights = self.minimize_volatility(target)
ret, std, sharpe = self.portfolio_performance(weights)
frontier_points.append({
'return': ret,
'volatility': std,
'sharpe': sharpe,
'weights': dict(zip(self.symbols, weights))
})
except:
continue
return frontier_points
Критика классической MPT для крипты
Проблема 1: Нестационарные корреляции. В крипте корреляции нестабильны. В bull market BTC и altcoins двигаются вместе (ρ > 0.8), в медвежьем — также. Диверсификация «исчезает» именно когда нужна.
Решение: rolling correlation window (30–90 дней), stress-tested covariance matrix.
Проблема 2: Fat tails. MPT предполагает нормальное распределение. Крипто returns имеют значительные хвосты.
Решение: CVaR optimization вместо variance minimization.
Проблема 3: Estimation error. Ковариационная матрица оценивается по историческим данным — ошибки в оценках приводят к экстремальным весам.
Решение:
- Regularization: Ledoit-Wolf shrinkage estimator
- Black-Litterman model: комбинирует рыночное «prior» с собственными взглядами
Black-Litterman Model
Улучшение MPT: вместо использования исторических returns как ожидаемых, комбинируем рыночное равновесие с субъективными взглядами аналитика.
def black_litterman(market_weights, cov_matrix, views, view_confidences,
risk_aversion=2.5, tau=0.05):
"""
market_weights: веса рыночного портфеля
views: матрица P (который актив относительно которого)
view_confidences: omega матрица (уверенность в взглядах)
"""
# Prior: рыночное равновесие
pi = risk_aversion * cov_matrix @ market_weights
# Posterior
tau_sigma = tau * cov_matrix
M_inverse = np.linalg.inv(
np.linalg.inv(tau_sigma) + views.T @ np.linalg.inv(view_confidences) @ views
)
bl_mu = M_inverse @ (
np.linalg.inv(tau_sigma) @ pi +
views.T @ np.linalg.inv(view_confidences) @ view_confidences.diagonal()
)
bl_sigma = cov_matrix + M_inverse
return bl_mu, bl_sigma
CVaR Portfolio Optimization
from scipy.optimize import linprog
def cvar_optimization(returns, confidence=0.95, target_return=None):
"""
Минимизируем CVaR (Expected Shortfall) вместо variance
Более устойчиво к fat tails
"""
T, n = returns.shape
alpha = 1 - confidence
# Переменные: [weights (n), VaR_threshold (1), auxiliary (T)]
# Линейная программа для CVaR минимизации
# (формула Rockafellar-Uryasev)
c = np.zeros(n + 1 + T)
c[n] = 1 # VaR
c[n+1:] = 1 / (alpha * T) # CVaR auxiliary
# ... (полная линейная программа для CVaR)
return None # упрощённо
Risk Parity Portfolio
Альтернатива MPT: каждый актив вносит равный вклад в риск портфеля.
def risk_parity_weights(cov_matrix, target_risk_contributions=None):
n = len(cov_matrix)
if target_risk_contributions is None:
target_risk_contributions = np.ones(n) / n # equal risk
def risk_contribution(weights):
sigma = np.sqrt(weights @ cov_matrix @ weights)
marginal_risk = cov_matrix @ weights / sigma
risk_contrib = weights * marginal_risk
return risk_contrib
def objective(weights):
rc = risk_contribution(weights)
# Минимизируем отклонение от целевого вклада
return np.sum((rc / rc.sum() - target_risk_contributions) ** 2)
constraints = [{'type': 'eq', 'fun': lambda w: np.sum(w) - 1}]
bounds = [(0.01, 0.50) for _ in range(n)]
result = minimize(objective, x0=np.ones(n)/n, method='SLSQP',
bounds=bounds, constraints=constraints)
return result.x
Risk Parity в крипте: BTC имеет низшую волатильность среди крупных криптоактивов → получает наибольший вес. Altcoins с высокой волатильностью → малый вес. Практично и устойчиво.
Rebalancing
Оптимальный портфель со временем отклоняется от целевых весов из-за разных returns активов. Rebalancing возвращает к целевым весам.
Стратегии rebalancing:
- Periodic: раз в месяц/квартал. Простой подход.
- Threshold: при отклонении веса актива > 5% от цели.
- Optimal: минимизация transaction costs при rebalancing.
def calculate_rebalancing_trades(current_values, target_weights, total_portfolio):
current_weights = {s: v/total_portfolio for s, v in current_values.items()}
trades = {}
for symbol in target_weights:
target_value = target_weights[symbol] * total_portfolio
current_value = current_values.get(symbol, 0)
delta = target_value - current_value
if abs(delta) > total_portfolio * 0.005: # игнорируем малые изменения
trades[symbol] = delta
return trades
Технический стек
Python (numpy, scipy для оптимизации, pandas для данных), PyPortfolioOpt библиотека (готовые алгоритмы оптимизации), cvxpy для convex optimization. Веб-интерфейс на React для ввода параметров, визуализации Efficient Frontier (scatter plot risk/return) и загрузки результирующих весов.
Разрабатываем систему с Markovitz оптимизацией, Black-Litterman, Risk Parity, CVaR optimization, backtesting с walk-forward validation и автоматическим rebalancing с контролем transaction costs.