シャープレシオを最大化するポートフォリオ最適化

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

import yfinance as yf
import pandas as pd
import numpy as np
from scipy.optimize import minimize
import matplotlib.pyplot as plt

# データ取得
tickers = ['AAPL', 'MSFT', 'GOOGL', 'AMZN', 'TSLA']
data = yf.download(tickers, period='2y')['Close']

# 日次リターン
returns = np.log(data / data.shift(1)).dropna()

# 年率換算
annual_returns = returns.mean() * 252
cov_matrix = returns.cov() * 252

# 無リスク金利（2%と仮定）
rf = 0.02

print("年率期待リターン:")
for ticker, ret in annual_returns.items():
    print(f"  {ticker}: {ret*100:.2f}%")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

def portfolio_performance(weights, returns, cov_matrix):
    """
    ポートフォリオのリターンとリスクを計算
    """
    portfolio_return = np.dot(weights, returns)
    portfolio_std = np.sqrt(np.dot(weights.T, np.dot(cov_matrix, weights)))
    return portfolio_return, portfolio_std

def negative_sharpe(weights, returns, cov_matrix, rf):
    """
    シャープレシオの負の値（最小化のため）
    """
    p_return, p_std = portfolio_performance(weights, returns, cov_matrix)
    return -(p_return - rf) / p_std

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

# 初期値（等ウェイト）
n_assets = len(tickers)
initial_weights = np.array([1/n_assets] * n_assets)

# 制約条件
constraints = ({'type': 'eq', 'fun': lambda x: np.sum(x) - 1})  # 合計=1

# 境界条件（0 <= w <= 1）
bounds = tuple((0, 1) for _ in range(n_assets))

# 最適化
result = minimize(
    negative_sharpe,
    initial_weights,
    args=(annual_returns, cov_matrix, rf),
    method='SLSQP',
    bounds=bounds,
    constraints=constraints
)

# 結果の表示
optimal_weights = result.x
optimal_return, optimal_std = portfolio_performance(optimal_weights, annual_returns, cov_matrix)
optimal_sharpe = (optimal_return - rf) / optimal_std

print("\n=== 最適ポートフォリオ ===")
print("資産配分:")
for ticker, weight in zip(tickers, optimal_weights):
    if weight > 0.001:  # 0.1%以上を表示
        print(f"  {ticker}: {weight*100:.2f}%")

print(f"\n期待リターン: {optimal_return*100:.2f}%")
print(f"リスク（標準偏差）: {optimal_std*100:.2f}%")
print(f"シャープレシオ: {optimal_sharpe:.4f}")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

# ランダムポートフォリオを生成
def random_portfolios(num_portfolios, returns, cov_matrix, rf):
    results = np.zeros((3, num_portfolios))
    weights_record = []
    
    for i in range(num_portfolios):
        weights = np.random.random(len(returns))
        weights /= np.sum(weights)
        weights_record.append(weights)
        
        p_return, p_std = portfolio_performance(weights, returns, cov_matrix)
        sharpe = (p_return - rf) / p_std
        
        results[0,i] = p_return
        results[1,i] = p_std
        results[2,i] = sharpe
    
    return results, weights_record

# 生成
results, _ = random_portfolios(10000, annual_returns, cov_matrix, rf)

# プロット
plt.figure(figsize=(12, 8))

# ランダムポートフォリオ
scatter = plt.scatter(results[1], results[0], c=results[2], cmap='viridis', alpha=0.5)
plt.colorbar(scatter, label='Sharpe Ratio')

# 最適ポートフォリオ（赤い星）
plt.scatter(optimal_std, optimal_return, c='red', marker='*', s=500, 
           label=f'Optimal (Sharpe: {optimal_sharpe:.2f})', zorder=5)

# 個別銘柄
for i, ticker in enumerate(tickers):
    std = np.sqrt(cov_matrix.iloc[i,i])
    ret = annual_returns.iloc[i]
    plt.scatter(std, ret, c='black', marker='o', s=100)
    plt.annotate(ticker, (std, ret), xytext=(5, 5), textcoords='offset points')

# 資本市場線（CML）
x_cml = np.linspace(0, max(results[1]) * 1.2, 100)
y_cml = rf + optimal_sharpe * x_cml
plt.plot(x_cml, y_cml, 'r--', alpha=0.5, label='Capital Market Line')

plt.xlabel('Risk (Standard Deviation)')
plt.ylabel('Expected Return')
plt.title('Efficient Frontier with Optimal Portfolio')
plt.legend()
plt.grid(True, alpha=0.3)

plt.tight_layout()
plt.savefig('optimal_portfolio.png', dpi=150)
plt.show()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

def portfolio_variance(weights, cov_matrix):
    """ポートフォリオの分散を計算"""
    return np.dot(weights.T, np.dot(cov_matrix, weights))

# 最小分散ポートフォリオを計算
result_minvar = minimize(
    portfolio_variance,
    initial_weights,
    args=(cov_matrix,),
    method='SLSQP',
    bounds=bounds,
    constraints=constraints
)

minvar_weights = result_minvar.x
minvar_return, minvar_std = portfolio_performance(minvar_weights, annual_returns, cov_matrix)

print("\n=== 最小リスクポートフォリオ ===")
for ticker, weight in zip(tickers, minvar_weights):
    if weight > 0.001:
        print(f"  {ticker}: {weight*100:.2f}%")
print(f"リターン: {minvar_return*100:.2f}%")
print(f"リスク: {minvar_std*100:.2f}%")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

def minimize_risk_for_target_return(target_return, returns, cov_matrix):
    """
    目標リターンを達成する最小リスクポートフォリオ
    """
    constraints = [
        {'type': 'eq', 'fun': lambda x: np.sum(x) - 1},
        {'type': 'eq', 'fun': lambda x: np.dot(x, returns) - target_return}
    ]
    
    result = minimize(
        portfolio_variance,
        initial_weights,
        args=(cov_matrix,),
        method='SLSQP',
        bounds=bounds,
        constraints=constraints
    )
    
    return result.x

# 目標リターンに対する最適ポートフォリオを計算
target_returns = np.linspace(minvar_return, max(annual_returns), 50)
efficient_portfolios = []

for target in target_returns:
    try:
        w = minimize_risk_for_target_return(target, annual_returns, cov_matrix)
        ret, std = portfolio_performance(w, annual_returns, cov_matrix)
        efficient_portfolios.append((std, ret))
    except:
        pass

# 効率的フロンティアをプロット
eff_df = pd.DataFrame(efficient_portfolios, columns=['Risk', 'Return'])
plt.plot(eff_df['Risk'], eff_df['Return'], 'b-', linewidth=2, label='Efficient Frontier')
plt.scatter(optimal_std, optimal_return, c='red', marker='*', s=300, label='Max Sharpe', zorder=5)
plt.scatter(minvar_std, minvar_return, c='green', marker='*', s=300, label='Min Variance', zorder=5)
plt.legend()
plt.show()