Posts

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

はじめに

前回はランダムなポートフォリオを生成して効率的フロンティアを描きました。

今回は数理最適化を使って、シャープレシオを最大化する最適な資産配分を計算します。

シャープレシオとは？

シャープレシオは、リスク調整後リターンを表す指標です：

$$Sharpe = \frac{R_p - R_f}{\sigma_p}$$

ここで：

  • $R_p$ = ポートフォリオの期待リターン
  • $R_f$ = 無リスク金利
  • $\sigma_p$ = ポートフォリオの標準偏差（リスク）

目標: シャープレシオを最大化するウェイト $w$ を求める

最適化の定式化

制約条件

  1. ウェイトの合計 = 1: $\sum w_i = 1$
  2. 各銘柄のウェイト ≥ 0（空売りなし）: $w_i \geq 0$

最適化問題

$$\max_w \frac{R_p - R_f}{\sigma_p}$$$$subject\ to: \sum w_i = 1, w_i \geq 0$$

Pythonでの実装

ライブラリ準備

 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()

まとめ

最適化のポイント:

read more
Posts

モンテカルロ法で資産配分シミュレーション

はじめに

「投資でどれくらいの資産を築けるだろう？」

将来の資産推移を知りたい時、モンテカルロ法は強力なツールです。

数万回のシミュレーションを通じて、資産が目標に達する確率や破産リスクを定量的に評価できます。

この記事では、モンテカルロ法を使った資産配分シミュレーションをPythonで実装します。

モンテカルロ法とは？

モンテカルロ法は、乱数を使って不確実性を含む問題をシミュレーションする手法です。

投資への応用

  1. 期待リターンとボラティリティから、将来の資産価値の分布を推定
  2. 数千〜数万回の試行を行い、統計的な確率を計算
  3. 様々なシナリオ（好景気、不景気など）を考慮

シミュレーションのステップ

  1. パラメータ設定（初期資産、年間リターン、ボラティリティ、期間）
  2. 乱数生成（正規分布に基づく年間リターン）
  3. 複利計算で資産推移を計算
  4. 複数回繰り返し
  5. 結果の分析

Pythonでの実装

Step 1: 基本シミュレーション

 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

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

# パラメータ設定
initial_investment = 1000000  # 初期投資額（100万円）
annual_return = 0.07          # 期待年率リターン（7%）
annual_volatility = 0.15      # 年率ボラティリティ（15%）
years = 30                    # 投資期間（30年）
num_simulations = 10000       # シミュレーション回数

# 乱数シード設定（再現性のため）
np.random.seed(42)

# シミュレーション結果を保存する配列
simulations = np.zeros((years + 1, num_simulations))
simulations[0] = initial_investment

# モンテカルロシミュレーション
for i in range(num_simulations):
    for year in range(1, years + 1):
        # 正規分布に基づくランダムなリターン
        random_return = np.random.normal(annual_return, annual_volatility)
        # 資産を更新
        simulations[year, i] = simulations[year - 1, i] * (1 + random_return)

print(f"シミュレーション完了: {num_simulations}回")
print(f"初期資産: ¥{initial_investment:,.0f}")

Step 2: 結果の可視化

 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

# 年次のインデックス
year_index = range(years + 1)

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

# すべてのシミュレーションを薄く表示
for i in range(min(100, num_simulations)):
    plt.plot(year_index, simulations[:, i], alpha=0.1, color='gray')

# パーセンタイルを計算
percentiles = [5, 25, 50, 75, 95]
percentile_values = np.percentile(simulations, percentiles, axis=1)

# パーセンタイルをプロット
colors = ['red', 'orange', 'green', 'orange', 'red']
labels = ['5th percentile', '25th percentile', 'Median', '75th percentile', '95th percentile']

for i, (p, color, label) in enumerate(zip(percentile_values, colors, labels)):
    plt.plot(year_index, p, color=color, linewidth=2, label=label)

plt.xlabel('Years')
plt.ylabel('Portfolio Value (JPY)')
plt.title(f'Monte Carlo Simulation: {num_simulations} Paths\n(Return: {annual_return*100:.0f}%, Volatility: {annual_volatility*100:.0f}%)')
plt.legend()
plt.grid(True, alpha=0.3)
plt.yscale('log')  # 対数スケール

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

Step 3: 最終資産の分布分析

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

# 最終資産
final_values = simulations[-1, :]

# 統計量
print("=== 最終資産の統計 ===")
print(f"平均値: ¥{final_values.mean():,.0f}")
print(f"中央値: ¥{np.median(final_values):,.0f}")
print(f"標準偏差: ¥{final_values.std():,.0f}")
print(f"最小値: ¥{final_values.min():,.0f}")
print(f"最大値: ¥{final_values.max():,.0f}")

# パーセンタイル
for p in [5, 10, 25, 50, 75, 90, 95]:
    value = np.percentile(final_values, p)
    print(f"{p}th percentile: ¥{value:,.0f}")

Step 4: ヒストグラム

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

plt.figure(figsize=(12, 6))

plt.hist(final_values, bins=100, edgecolor='black', alpha=0.7)
plt.axvline(final_values.mean(), color='red', linestyle='--', 
           linewidth=2, label=f'Mean: ¥{final_values.mean():,.0f}')
plt.axvline(np.median(final_values), color='green', linestyle='--', 
           linewidth=2, label=f'Median: ¥{np.median(final_values):,.0f}')

plt.xlabel('Final Portfolio Value (JPY)')
plt.ylabel('Frequency')
plt.title(f'Distribution of Final Portfolio Values\n({num_simulations} Simulations)')
plt.legend()
plt.grid(True, alpha=0.3, axis='y')

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

Step 5: 目標達成確率

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

# 目標資産
target = 10000000  # 1000万円

# 目標達成確率
probability_of_success = np.mean(final_values >= target) * 100

print(f"\n=== 目標達成確率 ===")
print(f"目標資産: ¥{target:,.0f}")
print(f"達成確率: {probability_of_success:.1f}%")

# 損失確率（元本割れ）
loss_probability = np.mean(final_values < initial_investment) * 100
print(f"元本割れ確率: {loss_probability:.1f}%")

積立投資のシミュレーション

実際には、定期的に追加投資（積立）を行うことが多いです。

read more
Posts

ポートフォリオのリターンとリスクをPythonで計算する

はじめに

「分散投資をするとリスクが減る」とはよく聞く言葉ですが、具体的にどう計算するのでしょうか？

この記事では、複数銘柄からなるポートフォリオのリターンとリスクを、**現代的ポートフォリオ理論（MPT）**に基づいてPythonで計算します。

ポートフォリオの基礎

リターンの計算

ポートフォリオ全体のリターンは、各銘柄のリターンを加重平均します：

$$R_p = \sum_{i=1}^{n} w_i R_i$$

ここで：

  • $R_p$ = ポートフォリオのリターン
  • $w_i$ = 銘柄$i$のウェイト（投資比率）
  • $R_i$ = 銘柄$i$のリターン
  • $n$ = 銘柄数

リスク（標準偏差）の計算

ポートフォリオのリスクは、単なる加重平均ではなく、共分散行列を使います：

$$\sigma_p = \sqrt{\mathbf{w}^T \Sigma \mathbf{w}}$$

ここで：

  • $\sigma_p$ = ポートフォリオの標準偏差（リスク）
  • $\mathbf{w}$ = ウェイトベクトル
  • $\Sigma$ = 共分散行列
  • $\mathbf{w}^T$ = ウェイトベクトルの転置

分散（バリアンス）は：

$$\sigma_p^2 = \sum_{i=1}^{n} \sum_{j=1}^{n} w_i w_j \sigma_{ij}$$

ここで$\sigma_{ij}$は銘柄$i$と銘柄$j$の共分散です。

Pythonでの実装

Step 1: データ取得

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

import yfinance as yf
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

# 分析対象銘柄（S&P500の主要銘柄）
tickers = ['AAPL', 'MSFT', 'GOOGL', 'AMZN', 'TSLA']

# 2年分のデータを取得
data = yf.download(tickers, period='2y')['Close']

print(data.head())
print(f"\n銘柄数: {len(tickers)}")
print(f"データ期間: {len(data)}日")

Step 2: 日次リターンの計算

1
2
3
4
5
6
7
8

# 日次リターンを計算（対数リターン）
returns = np.log(data / data.shift(1)).dropna()

# または単純リターン
# returns = data.pct_change().dropna()

print("日次リターンの統計:")
print(returns.describe())

Step 3: 年率換算リターンの計算

1
2
3
4
5
6
7
8
9

# 平均日次リターン
mean_returns = returns.mean()

# 年率換算（252取引日）
annual_returns = mean_returns * 252

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

Step 4: 共分散行列の計算

1
2
3
4
5
6
7
8

# 日次リターンの共分散行列
cov_matrix = returns.cov()

# 年率換算共分散行列（×252）
annual_cov_matrix = cov_matrix * 252

print("共分散行列（年率換算）:")
print(annual_cov_matrix.round(4))

Step 5: 相関行列

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

# 相関行列（標準化された共分散）
corr_matrix = returns.corr()

print("相関行列:")
print(corr_matrix.round(2))

# ヒートマップで可視化
import seaborn as sns

plt.figure(figsize=(8, 6))
sns.heatmap(corr_matrix, annot=True, cmap='coolwarm', center=0, 
            square=True, fmt='.2f')
plt.title('Correlation Matrix')
plt.tight_layout()
plt.savefig('correlation_matrix.png', dpi=150)
plt.show()

Step 6: ポートフォリオのリターンとリスク計算

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

# 等ウェイトポートフォリオ（各銘柄20%ずつ）
weights = np.array([0.2, 0.2, 0.2, 0.2, 0.2])

# ポートフォリオの年率リターン
portfolio_return = np.dot(weights, annual_returns)

# ポートフォリオの年率分散
portfolio_variance = np.dot(weights.T, np.dot(annual_cov_matrix, weights))

# ポートフォリオの年率標準偏差（リスク）
portfolio_std = np.sqrt(portfolio_variance)

print(f"=== 等ウェイトポートフォリオ ===")
print(f"銘柄: {tickers}")
print(f"ウェイト: {weights}")
print(f"年率リターン: {portfolio_return*100:.2f}%")
print(f"年率リスク（標準偏差）: {portfolio_std*100:.2f}%")
print(f"シャープレシオ（仮定無リスク金利2%）: {(portfolio_return - 0.02) / portfolio_std:.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

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 random_portfolios(num_portfolios, returns, cov_matrix):
    """
    ランダムなポートフォリオを生成
    """
    results = np.zeros((3, num_portfolios))
    weights_record = []
    
    for i in range(num_portfolios):
        # ランダムなウェイト（合計1）
        weights = np.random.random(len(returns))
        weights /= np.sum(weights)
        weights_record.append(weights)
        
        # パフォーマンス計算
        portfolio_return, portfolio_std = portfolio_performance(weights, returns, cov_matrix)
        
        # シャープレシオ（無リスク金利2%と仮定）
        sharpe = (portfolio_return - 0.02) / portfolio_std
        
        results[0,i] = portfolio_return
        results[1,i] = portfolio_std
        results[2,i] = sharpe
    
    return results, weights_record

# 10,000個のランダムポートフォリオを生成
num_portfolios = 10000
results, weights_record = random_portfolios(num_portfolios, annual_returns, annual_cov_matrix)

print(f"{num_portfolios}個のポートフォリオを生成しました")

効果的フロンティアの可視化

 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
55

# マックスシャープレシオポートフォリオ
max_sharpe_idx = np.argmax(results[2])
max_sharpe_return = results[0, max_sharpe_idx]
max_sharpe_std = results[1, max_sharpe_idx]
max_sharpe_weights = weights_record[max_sharpe_idx]

# 最小リスクポートフォリオ
min_risk_idx = np.argmin(results[1])
min_risk_return = results[0, min_risk_idx]
min_risk_std = results[1, min_risk_idx]
min_risk_weights = weights_record[min_risk_idx]

# プロット
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(max_sharpe_std, max_sharpe_return, c='red', marker='*', s=300, 
           label=f'Max Sharpe: {results[2, max_sharpe_idx]:.2f}')

# 最小リスク
plt.scatter(min_risk_std, min_risk_return, c='blue', marker='*', s=300, 
           label=f'Min Risk: {results[1, min_risk_idx]*100:.1f}%')

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

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

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

print("\n=== マックスシャープレシオポートフォリオ ===")
for ticker, weight in zip(tickers, max_sharpe_weights):
    print(f"  {ticker}: {weight*100:.1f}%")
print(f"年率リターン: {max_sharpe_return*100:.2f}%")
print(f"年率リスク: {max_sharpe_std*100:.2f}%")

print("\n=== 最小リスクポートフォリオ ===")
for ticker, weight in zip(tickers, min_risk_weights):
    print(f"  {ticker}: {weight*100:.1f}%")
print(f"年率リターン: {min_risk_return*100:.2f}%")
print(f"年率リスク: {min_risk_std*100:.2f}%")

分散投資の効果

等ウェイト vs 個別銘柄

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

print("=== 個別銘柄のリスク vs 等ウェイトポートフォリオ ===\n")

# 個別銘柄のリスク
individual_risks = np.sqrt(np.diag(annual_cov_matrix))

for ticker, risk in zip(tickers, individual_risks):
    print(f"{ticker}: {risk*100:.2f}%")

print(f"\n等ウェイトポートフォリオのリスク: {portfolio_std*100:.2f}%")
print(f"\n平均的な個別銘柄のリスク: {individual_risks.mean()*100:.2f}%")
print(f"リスク低減効果: {(1 - portfolio_std/individual_risks.mean())*100:.1f}%")

まとめ

この記事では、ポートフォリオのリターンとリスク計算を学びました。

read more