免责声明：本文提供的信息仅用于教育和参考目的，不构成财务、投资或交易建议。加密货币交易涉及重大损失风险。
MarketMaker.cc Team
量化研究与策略
用Python构建最优加密货币投资组合 - 因为YOLO不是策略
马科维茨投资组合理论：应用于数字资产的数学优化，以在给定的风险水平下实现回报最大化。
引言：为什么你的加密货币投资组合需要数学（而不仅仅是感觉）
嘿，加密货币投机者们！👋
还记得那次因为埃隆发了条推特，你就把所有资金都投入狗狗币的时候吗？或者上次暴跌时你恐慌性抛售了所有持仓？是的，我们都经历过。今天我们要讨论一个可能拯救你投资组合（和理智）的东西：马科维茨投资组合理论。
哈里·马科维茨在1990年因为这套理论获得了诺贝尔奖。基本思想是什么？你可以通过数学方法优化你的投资组合，在任何给定的风险水平下获得最佳可能回报。这就像为你的投资配备GPS，而不是蒙着眼睛开车。
核心概念：风险与回报（永恒的舞蹈）
在我们深入代码之前，让我们理解我们要处理的内容：
- 预期回报：你期望赚到多少钱
- 风险（波动性）：你的投资组合价值波动的幅度
- 相关性：不同资产之间的联动程度
当你组合那些不完全同步移动的资产时，魔法就发生了。当比特币暴跌时，也许一些DeFi代币会表现得更好。这就是分散化为你工作的原理。
风险与回报：平衡波动的超额收益资产和稳定的基础架构，从而实现最优几何平均回报。
设置我们的Python环境
首先 - 让我们准备工具：
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from scipy.optimize import minimize
import yfinance as yf
import warnings
warnings.filterwarnings('ignore')
plt.style.use('dark_background')
sns.set_palette("husl")
第一级：婴儿步骤 - 简单的投资组合数学
让我们从基础开始。我们将为一个简单的2资产投资组合计算收益和风险。
def get_crypto_data(symbols, period="1y"):
"""
从Yahoo Finance获取加密货币数据
symbols: 加密货币符号列表 (例如, ['BTC-USD', 'ETH-USD'])
period: 数据时间段
"""
data = yf.download(symbols, period=period)['Adj Close']
return data
crypto_symbols = ['BTC-USD', 'ETH-USD']
prices = get_crypto_data(crypto_symbols)
returns = prices.pct_change().dropna()
print("日收益率预览：")
print(returns.head())
现在让我们计算一些基本的投资组合指标：
def portfolio_performance(weights, returns):
"""
计算投资组合收益和波动性
weights: 投资组合权重数组
returns: 资产收益数据框
"""
portfolio_return = np.sum(returns.mean() * weights) * 252
portfolio_vol = np.sqrt(np.dot(weights.T, np.dot(returns.cov() * 252, weights)))
return portfolio_return, portfolio_vol
weights_5050 = np.array([0.5, 0.5])
ret_5050, vol_5050 = portfolio_performance(weights_5050, returns)
print(f"50/50投资组合：")
print(f"预期年收益率：{ret_5050:.2%}")
print(f"年波动性：{vol_5050:.2%}")
print(f"夏普比率：{ret_5050/vol_5050:.3f}")
第二级：认真起来 - 有效前沿
现在我们开始做菜！有效前沿向我们展示了所有可能的最优投资组合。每个点代表在给定风险水平下的最佳可能回报。
def generate_random_portfolios(returns, num_portfolios=10000):
"""
生成随机投资组合组合
"""
num_assets = len(returns.columns)
results = np.zeros((4, num_portfolios))
for i in range(num_portfolios):
weights = np.random.random(num_assets)
weights /= np.sum(weights) # 标准化使其和为1
portfolio_return, portfolio_vol = portfolio_performance(weights, returns)
sharpe_ratio = portfolio_return / portfolio_vol
results[0,i] = portfolio_return
results[1,i] = portfolio_vol
results[2,i] = sharpe_ratio
results[3,i:] = weights
return results
results = generate_random_portfolios(returns)
portfolio_results = pd.DataFrame({
'Returns': results[0],
'Volatility': results[1],
'Sharpe_Ratio': results[2]
})
plt.figure(figsize=(12, 8))
scatter = plt.scatter(portfolio_results['Volatility'],
portfolio_results['Returns'],
c=portfolio_results['Sharpe_Ratio'],
cmap='viridis', alpha=0.6)
plt.colorbar(scatter, label='夏普比率')
plt.xlabel('波动性（风险）')
plt.ylabel('预期收益')
plt.title('有效前沿 - 随机投资组合')
plt.show()
有效前沿：代表特定风险水平下最大可能预期回报的曲线。
第三级：优化大师 - 寻找完美投资组合
随机抽样很有趣，但我们想要数学上的最优解。是时候拿出重型武器 - scipy优化！
def negative_sharpe_ratio(weights, returns, risk_free_rate=0.02):
"""
计算负夏普比率（我们要最小化它）
"""
portfolio_return, portfolio_vol = portfolio_performance(weights, returns)
sharpe = (portfolio_return - risk_free_rate) / portfolio_vol
return -sharpe
def minimize_volatility(weights, returns):
"""
计算投资组合波动性（我们要最小化它）
"""
_, portfolio_vol = portfolio_performance(weights, returns)
return portfolio_vol
def portfolio_return_objective(weights, returns):
"""
计算投资组合收益（我们要最大化它）
"""
portfolio_return, _ = portfolio_performance(weights, returns)
return -portfolio_return # 负数因为我们在最小化
def optimize_portfolio(returns, objective='sharpe', target_return=None):
"""
基于不同目标优化投资组合
"""
num_assets = len(returns.columns)
constraints = ({'type': 'eq', 'fun': lambda x: np.sum(x) - 1}) # 权重和为1
bounds = tuple((0, 1) for _ in range(num_assets)) # 无卖空
initial_guess = num_assets * [1. / num_assets]
if objective == 'sharpe':
result = minimize(negative_sharpe_ratio, initial_guess,
args=(returns,), method='SLSQP',
bounds=bounds, constraints=constraints)
elif objective == 'min_vol':
result = minimize(minimize_volatility, initial_guess,
args=(returns,), method='SLSQP',
bounds=bounds, constraints=constraints)
elif objective == 'target_return':
constraints = ({'type': 'eq', 'fun': lambda x: np.sum(x) - 1},
{'type': 'eq', 'fun': lambda x: portfolio_performance(x, returns)[0] - target_return})
result = minimize(minimize_volatility, initial_guess,
args=(returns,), method='SLSQP',
bounds=bounds, constraints=constraints)
return result
max_sharpe = optimize_portfolio(returns, 'sharpe')
min_vol = optimize_portfolio(returns, 'min_vol')
print("🎯 最大夏普比率投资组合：")
for i, symbol in enumerate(crypto_symbols):
print(f"{symbol}: {max_sharpe.x[i]:.3f}")
ret_sharpe, vol_sharpe = portfolio_performance(max_sharpe.x, returns)
print(f"收益：{ret_sharpe:.2%}，波动性：{vol_sharpe:.2%}")
print(f"夏普比率：{ret_sharpe/vol_sharpe:.3f}\n")
print("🛡️ 最小波动性投资组合：")
for i, symbol in enumerate(crypto_symbols):
print(f"{symbol}: {min_vol.x[i]:.3f}")
ret_minvol, vol_minvol = portfolio_performance(min_vol.x, returns)
print(f"收益：{ret_minvol:.2%}，波动性：{vol_minvol:.2%}")
第四级：多资产疯狂 - 真实的加密货币投资组合
让我们将此扩展到具有多个资产的适当加密货币投资组合：
crypto_portfolio = ['BTC-USD', 'ETH-USD', 'BNB-USD', 'ADA-USD', 'SOL-USD', 'DOT-USD']
prices_multi = get_crypto_data(crypto_portfolio, period="2y")
returns_multi = prices_multi.pct_change().dropna()
correlation_matrix = returns_multi.corr()
plt.figure(figsize=(10, 8))
sns.heatmap(correlation_matrix, annot=True, cmap='RdYlBu_r', center=0)
plt.title('加密资产相关性矩阵')
plt.show()
def efficient_frontier(returns, num_portfolios=50):
"""
计算有效前沿
"""
ret_range = np.linspace(returns.mean().min()*252, returns.mean().max()*252, num_portfolios)
efficient_portfolios = []
for target_ret in ret_range:
try:
result = optimize_portfolio(returns, 'target_return', target_ret)
if result.success:
ret, vol = portfolio_performance(result.x, returns)
efficient_portfolios.append([ret, vol, result.x])
except:
continue
return np.array(efficient_portfolios)
efficient_port = efficient_frontier(returns_multi)
plt.figure(figsize=(14, 10))
random_results = generate_random_portfolios(returns_multi, 5000)
plt.scatter(random_results[1], random_results[0],
c=random_results[2], cmap='viridis', alpha=0.3, s=10)
if len(efficient_port) > 0:
plt.plot(efficient_port[:,1], efficient_port[:,0], 'r-', linewidth=3, label='有效前沿')
max_sharpe_multi = optimize_portfolio(returns_multi, 'sharpe')
min_vol_multi = optimize_portfolio(returns_multi, 'min_vol')
ret_sharpe_multi, vol_sharpe_multi = portfolio_performance(max_sharpe_multi.x, returns_multi)
ret_minvol_multi, vol_minvol_multi = portfolio_performance(min_vol_multi.x, returns_multi)
plt.scatter(vol_sharpe_multi, ret_sharpe_multi, marker='*', color='gold', s=500, label='最大夏普')
plt.scatter(vol_minvol_multi, ret_minvol_multi, marker='*', color='red', s=500, label='最小波动性')
plt.colorbar(label='夏普比率')
plt.xlabel('波动性（风险）')
plt.ylabel('预期收益')
plt.title('多资产加密货币投资组合优化')
plt.legend()
plt.show()
print("🚀 最优多资产配置：")
print("\n最大夏普比率投资组合：")
sharpe_weights = pd.Series(max_sharpe_multi.x, index=crypto_portfolio).sort_values(ascending=False)
for asset, weight in sharpe_weights.items():
if weight > 0.01: # 只显示重要的配置
print(f"{asset}: {weight:.1%}")
print(f"\n投资组合指标：")
print(f"预期收益：{ret_sharpe_multi:.1%}")
print(f"波动性：{vol_sharpe_multi:.1%}")
print(f"夏普比率：{ret_sharpe_multi/vol_sharpe_multi:.2f}")
多资产资产配置：通过结合不相关的加密数字资产以建立一个健壮稳健的投资组合结构。
第五级：高级技术 - Black-Litterman和风险平价
对于真正的投资组合优化忍者，让我们实现一些高级技术：
def risk_parity_portfolio(returns):
"""
风险平价投资组合 - 每个资产对投资组合风险贡献相等
"""
def risk_contribution(weights, cov_matrix):
portfolio_vol = np.sqrt(np.dot(weights.T, np.dot(cov_matrix, weights)))
marginal_contrib = np.dot(cov_matrix, weights) / portfolio_vol
contrib = weights * marginal_contrib
return contrib
def risk_parity_objective(weights, cov_matrix):
contrib = risk_contribution(weights, cov_matrix)
target_contrib = np.ones(len(weights)) / len(weights)
return np.sum((contrib - target_contrib)**2)
num_assets = len(returns.columns)
cov_matrix = returns.cov() * 252
constraints = ({'type': 'eq', 'fun': lambda x: np.sum(x) - 1})
bounds = tuple((0.001, 1) for _ in range(num_assets))
initial_guess = num_assets * [1. / num_assets]
result = minimize(risk_parity_objective, initial_guess,
args=(cov_matrix,), method='SLSQP',
bounds=bounds, constraints=constraints)
return result
risk_parity_result = risk_parity_portfolio(returns_multi)
print("⚖️ 风险平价投资组合：")
rp_weights = pd.Series(risk_parity_result.x, index=crypto_portfolio).sort_values(ascending=False)
for asset, weight in rp_weights.items():
print(f"{asset}: {weight:.1%}")
ret_rp, vol_rp = portfolio_performance(risk_parity_result.x, returns_multi)
print(f"\n风险平价指标：")
print(f"预期收益：{ret_rp:.1%}")
print(f"波动性：{vol_rp:.1%}")
print(f"夏普比率：{ret_rp/vol_rp:.2f}")
def backtest_portfolio(weights, prices):
"""
投资组合表现的简单回测
"""
returns = prices.pct_change().dropna()
portfolio_returns = (returns * weights).sum(axis=1)
cumulative_returns = (1 + portfolio_returns).cumprod()
total_return = cumulative_returns.iloc[-1] - 1
annualized_return = (1 + total_return) ** (252 / len(portfolio_returns)) - 1
annualized_vol = portfolio_returns.std() * np.sqrt(252)
sharpe_ratio = annualized_return / annualized_vol
max_dd = (cumulative_returns / cumulative_returns.expanding().max() - 1).min()
return {
'total_return': total_return,
'annualized_return': annualized_return,
'annualized_volatility': annualized_vol,
'sharpe_ratio': sharpe_ratio,
'max_drawdown': max_dd,
'cumulative_returns': cumulative_returns
}
strategies = {
'最大夏普': max_sharpe_multi.x,
'最小波动性': min_vol_multi.x,
'风险平价': risk_parity_result.x,
'等权重': np.ones(len(crypto_portfolio)) / len(crypto_portfolio)
}
plt.figure(figsize=(14, 8))
for name, weights in strategies.items():
backtest_results = backtest_portfolio(weights, prices_multi)
plt.plot(backtest_results['cumulative_returns'], label=f"{name} (夏普: {backtest_results['sharpe_ratio']:.2f})")
plt.title('投资组合策略回测')
plt.xlabel('日期')
plt.ylabel('累积收益')
plt.legend()
plt.yscale('log')
plt.grid(True, alpha=0.3)
plt.show()
*算法历史回测分析：模拟资产历史记录的表现用以评估和修改理论化的自动投资模型。*
performance_summary = pd.DataFrame()
for name, weights in strategies.items():
results = backtest_portfolio(weights, prices_multi)
performance_summary[name] = [
f"{results['annualized_return']:.1%}",
f"{results['annualized_volatility']:.1%}",
f"{results['sharpe_ratio']:.2f}",
f"{results['max_drawdown']:.1%}"
]
performance_summary.index = ['年化收益', '年化波动性', '夏普比率', '最大回撤']
print("\n📊 策略表现汇总：")
print(performance_summary)
现实检查：马科维茨没有告诉你的事情
在你全力投入数学优化之前，这里有一些关于加密货币的严酷真相：
1. 过去表现 ≠ 未来结果 加密货币市场年轻且混乱。你计算的那些相关性？当监管发生变化或下一次大型黑客攻击发生时，它们可能在一夜之间翻转。
2. 交易成本很重要 重新平衡你的投资组合需要钱。在DeFi中，gas费可能会吃掉你的午餐。将此纳入你的策略。
3. 流动性问题 不是所有加密货币都同样具有流动性。那个小盘山寨币在你的优化中可能看起来很棒，但试着在崩盘期间卖掉它。
4. 制度变化 加密货币市场有不同的"制度" - 牛市、熊市、横盘市场。在一个市场中有效的东西可能在另一个市场中无效。
实用实施技巧
def practical_portfolio_rebalancing(target_weights, current_weights, threshold=0.05):
"""
只有当权重偏离超过阈值时才重新平衡
"""
weight_diff = np.abs(target_weights - current_weights)
needs_rebalancing = np.any(weight_diff > threshold)
if needs_rebalancing:
print("🔄 需要重新平衡！")
for i, (target, current) in enumerate(zip(target_weights, current_weights)):
if abs(target - current) > threshold:
print(f"资产{i}: {current:.1%} → {target:.1%}")
else:
print("✅ 投资组合在容忍范围内，无需重新平衡")
return needs_rebalancing
current_allocation = np.array([0.35, 0.25, 0.15, 0.10, 0.10, 0.05])
target_allocation = max_sharpe_multi.x
practical_portfolio_rebalancing(target_allocation, current_allocation)
结论：你的投资组合优化工具包
你现在拥有了一套完整的加密货币投资组合优化工具包：
- 基本计算用于风险和收益
- 有效前沿可视化
- 数学优化针对不同目标
- 高级策略如风险平价
- 回测框架验证你的策略
- 实际考虑用于现实世界实施
关键要点
- 分散化是免费午餐 - 投资中唯一的免费午餐
- 根据你的风险承受能力优化 - 最大夏普对你来说不总是最好的
- 系统性地重新平衡但不要过度交易
- 保持谦逊 - 模型是工具，不是水晶球
- 从简单开始随着学习增加复杂性
记住：在加密货币中，即使是最好的数学模型也无法预测埃隆何时会发推特谈论狗狗币，或者下一个交易所何时会被黑客攻击。将投资组合理论作为你的基础，但总是保留一些火药干燥，永远不要投资超过你能承受损失的金额。
现在去负责任地优化吧！🚀
延伸阅读
代码仓库
本教程的所有代码都可以在GitHub上找到：https://github.com/suenot/markowitz
祝优化愉快！📈