Posts

Pythonで株価予測 - 線形回帰とランダムフォレストで未来を予測

はじめに

株価は予測できるのか？

この問いには明確な答えはありませんが、機械学習を使って統計的な予測は可能です。

この記事では、Pythonのscikit-learnを使って、基本的な株価予測モデルを構築します。

注意：予測の限界

⚠️ 重要な免責事項

過去のパターンが未来を保証しない
ブラックスワン（予測不可能なイベント）がある
このモデルは学習目的であり、実際の取引には使用しないこと

準備

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
import yfinance as yf
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import mean_squared_error, r2_score
from sklearn.preprocessing import StandardScaler

# データ取得
ticker = "AAPL"
df = yf.download(ticker, period="5y")

print(f"データ期間: {df.index[0]} ～ {df.index[-1]}")
print(f"データ数: {len(df)}")

特徴量エンジニアリング

テクニカル指標を特徴量として作成

 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
56
def create_features(df):
    """
    特徴量を作成する関数
    """
    data = df.copy()
    
    # 終値の変化率（リターン）
    data['Return'] = data['Close'].pct_change()
    
    # 移動平均
    data['MA5'] = data['Close'].rolling(window=5).mean()
    data['MA20'] = data['Close'].rolling(window=20).mean()
    data['MA50'] = data['Close'].rolling(window=50).mean()
    
    # 移動平均との差
    data['Close_MA5'] = data['Close'] - data['MA5']
    data['Close_MA20'] = data['Close'] - data['MA20']
    
    # RSI
    delta = data['Close'].diff()
    gain = (delta.where(delta > 0, 0)).rolling(window=14).mean()
    loss = (-delta.where(delta < 0, 0)).rolling(window=14).mean()
    rs = gain / loss
    data['RSI'] = 100 - (100 / (1 + rs))
    
    # MACD
    ema12 = data['Close'].ewm(span=12, adjust=False).mean()
    ema26 = data['Close'].ewm(span=26, adjust=False).mean()
    data['MACD'] = ema12 - ema26
    data['MACD_Signal'] = data['MACD'].ewm(span=9, adjust=False).mean()
    
    # ボラティリティ（過去20日の標準偏差）
    data['Volatility'] = data['Return'].rolling(window=20).std()
    
    # 出来高の変化
    data['Volume_Change'] = data['Volume'].pct_change()
    data['Volume_MA20'] = data['Volume'].rolling(window=20).mean()
    
    # 高値・安値との位置
    data['High_Low_Range'] = (data['Close'] - data['Low']) / (data['High'] - data['Low'])
    
    # 翌日の終値（予測対象）
    data['Target'] = data['Close'].shift(-1)
    
    return data

# 特徴量作成
df_features = create_features(df)

# 最初の50日と最後の1日は削除（NaNがあるため）
df_features = df_features.iloc[50:-1]

print("作成された特徴量:")
print(df_features.columns.tolist())
print(f"\n特徴量の統計:")
print(df_features.describe())

線形回帰モデル

 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
# 特徴量とターゲットを分離
feature_cols = ['Return', 'Close_MA5', 'Close_MA20', 'RSI', 'MACD', 
                'Volatility', 'Volume_Change', 'High_Low_Range']

X = df_features[feature_cols]
y = df_features['Target']

# 訓練データとテストデータに分割（時系列なのでシャッフルしない）
split_point = int(len(X) * 0.8)
X_train, X_test = X.iloc[:split_point], X.iloc[split_point:]
y_train, y_test = y.iloc[:split_point], y.iloc[split_point:]

# スケーリング
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# 線形回帰モデル
lr_model = LinearRegression()
lr_model.fit(X_train_scaled, y_train)

# 予測
lr_pred = lr_model.predict(X_test_scaled)

# 評価
lr_rmse = np.sqrt(mean_squared_error(y_test, lr_pred))
lr_r2 = r2_score(y_test, lr_pred)

print("=== 線形回帰モデル ===")
print(f"RMSE: ${lr_rmse:.2f}")
print(f"R²: {lr_r2:.4f}")

# 特徴量の重要度
feature_importance = pd.DataFrame({
    'feature': feature_cols,
    'coefficient': lr_model.coef_
}).sort_values('coefficient', key=abs, ascending=False)

print("\n特徴量の係数:")
print(feature_importance)

ランダムフォレストモデル

 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
# ランダムフォレストモデル
rf_model = RandomForestRegressor(
    n_estimators=100,
    max_depth=10,
    min_samples_split=5,
    random_state=42
)

rf_model.fit(X_train_scaled, y_train)

# 予測
rf_pred = rf_model.predict(X_test_scaled)

# 評価
rf_rmse = np.sqrt(mean_squared_error(y_test, rf_pred))
rf_r2 = r2_score(y_test, rf_pred)

print("\n=== ランダムフォレストモデル ===")
print(f"RMSE: ${rf_rmse:.2f}")
print(f"R²: {rf_r2:.4f}")

# 特徴量の重要度
rf_importance = pd.DataFrame({
    'feature': feature_cols,
    'importance': rf_model.feature_importances_
}).sort_values('importance', ascending=False)

print("\n特徴量の重要度:")
print(rf_importance)

予測結果の可視化

 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
fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(14, 10))

# 実際の価格と予測価格
dates = y_test.index

ax1.plot(dates, y_test.values, label='Actual', color='black', linewidth=2)
ax1.plot(dates, lr_pred, label='Linear Regression', color='blue', alpha=0.7)
ax1.plot(dates, rf_pred, label='Random Forest', color='green', alpha=0.7)
ax1.set_title('Stock Price Prediction')
ax1.set_ylabel('Price (USD)')
ax1.legend()
ax1.grid(True, alpha=0.3)

# 予測誤差
lr_error = y_test.values - lr_pred
rf_error = y_test.values - rf_pred

ax2.plot(dates, lr_error, label='Linear Regression Error', color='blue', alpha=0.5)
ax2.plot(dates, rf_error, label='Random Forest Error', color='green', alpha=0.5)
ax2.axhline(y=0, color='red', linestyle='--', alpha=0.5)
ax2.fill_between(dates, lr_error, alpha=0.2, color='blue')
ax2.set_title('Prediction Error')
ax2.set_ylabel('Error (USD)')
ax2.set_xlabel('Date')
ax2.legend()
ax2.grid(True, alpha=0.3)

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

翌日の価格予測

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
# 最新のデータで翌日を予測
latest_features = X.iloc[-1:].values
latest_features_scaled = scaler.transform(latest_features)

lr_next_day = lr_model.predict(latest_features_scaled)[0]
rf_next_day = rf_model.predict(latest_features_scaled)[0]
actual_latest = df['Close'].iloc[-1]

print("=== 翌日の価格予測 ===")
print(f"現在の終値: ${actual_latest:.2f}")
print(f"線形回帰予測: ${lr_next_day:.2f} ({(lr_next_day/actual_latest-1)*100:+.2f}%)")
print(f"ランダムフォレスト予測: ${rf_next_day:.2f} ({(rf_next_day/actual_latest-1)*100:+.2f}%)")

モデルの評価と注意点

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
# 方向性の正解率（上がるか下がるか）
actual_direction = np.diff(y_test.values) > 0
lr_direction = np.diff(lr_pred) > 0
rf_direction = np.diff(rf_pred) > 0

lr_accuracy = np.mean(actual_direction == lr_direction)
rf_accuracy = np.mean(actual_direction == rf_direction)

print("\n=== 方向性予測の精度 ===")
print(f"ランダム（ベースライン）: 50.00%")
print(f"線形回帰: {lr_accuracy*100:.2f}%")
print(f"ランダムフォレスト: {rf_accuracy*100:.2f}%")

まとめ

モデルのポイント:

Posts

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

はじめに

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

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

シャープレシオとは？

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

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

ここで：

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

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

最適化の定式化

制約条件

ウェイトの合計 = 1: $\sum w_i = 1$
各銘柄のウェイト ≥ 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()

まとめ

最適化のポイント:

Posts

MACD（マックディー）の計算とトレーディング戦略

はじめに

MACD（Moving Average Convergence Divergence）は、トレンドの強さと方向を捉える最も人気のあるテクニカル指標の一つです。

移動平均線の収束と発散を捉えることで、買い・売りのタイミングを判断します。

MACDとは？

計算式

MACDは3つの要素から構成されます：

1. MACDライン

$$MACD = EMA_{12} - EMA_{26}$$

12日指数移動平均（短期）から
26日指数移動平均（長期）を引いた値

2. シグナルライン

$$Signal = EMA_9(MACD)$$

MACDラインの9日指数移動平均

3. ヒストグラム（オシレーター）

$$Histogram = MACD - Signal$$

解釈の仕方

状態	意味	トレードシグナル
MACD > シグナル	上昇トレンド	買い
MACD < シグナル	下降トレンド	売り
ヒストグラム > 0	買い圧力	強気
ヒストグラム < 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
24
25
26
27
28
29
30
31
32
33
34
35
import yfinance as yf
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

# データ取得
ticker = "AAPL"
df = yf.download(ticker, period="2y")

# EMAの計算
def calculate_ema(prices, span):
    return prices.ewm(span=span, adjust=False).mean()

# MACD計算
def calculate_macd(prices, fast=12, slow=26, signal=9):
    # MACDライン
    ema_fast = calculate_ema(prices, fast)
    ema_slow = calculate_ema(prices, slow)
    macd_line = ema_fast - ema_slow
    
    # シグナルライン
    signal_line = calculate_ema(macd_line, signal)
    
    # ヒストグラム
    histogram = macd_line - signal_line
    
    return macd_line, signal_line, histogram

# 計算実行
df['MACD'], df['Signal'], df['Histogram'] = calculate_macd(df['Close'])

# 最初の26日は削除（データが不安定）
df = df.iloc[26:]

print(df[['Close', 'MACD', 'Signal', 'Histogram']].tail())

可視化

 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
fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(14, 10), 
                                gridspec_kw={'height_ratios': [2, 1]})

# 価格チャート
ax1.plot(df.index, df['Close'], label='Close Price', color='black', alpha=0.7)
ax1.set_ylabel('Price (USD)')
ax1.set_title(f'{ticker} - Price & MACD')
ax1.legend()
ax1.grid(True, alpha=0.3)

# MACDチャート
ax2.plot(df.index, df['MACD'], label='MACD', color='blue', linewidth=2)
ax2.plot(df.index, df['Signal'], label='Signal', color='red', linewidth=2)

# ヒストグラム（バー）
colors = ['green' if h >= 0 else 'red' for h in df['Histogram']]
ax2.bar(df.index, df['Histogram'], label='Histogram', color=colors, alpha=0.6, width=1)

# ゼロライン
ax2.axhline(y=0, color='black', linestyle='-', alpha=0.3)

ax2.set_ylabel('MACD')
ax2.set_xlabel('Date')
ax2.legend()
ax2.grid(True, alpha=0.3)

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

トレーディングシグナル

ゴールデンクロス / デッドクロス

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
# シグナル生成
df['Position'] = 0
df.loc[df['MACD'] > df['Signal'], 'Position'] = 1  # 買い
df.loc[df['MACD'] < df['Signal'], 'Position'] = -1  # 売り

# クロスポイントの検出
df['Signal_Change'] = df['Position'].diff()

buy_signals = df[df['Signal_Change'] == 2].index
death_signals = df[df['Signal_Change'] == -2].index

print(f"ゴールデンクロス: {len(buy_signals)}回")
print(f"デッドクロス: {len(death_signals)}回")

シグナルの可視化

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
fig, ax = plt.subplots(figsize=(14, 7))

# 価格
ax.plot(df.index, df['Close'], label='Close Price', color='black', alpha=0.7)

# シグナル
ax.scatter(buy_signals, df.loc[buy_signals, 'Close'], 
          color='green', marker='^', s=100, label='Golden Cross', zorder=5)
ax.scatter(death_signals, df.loc[death_signals, 'Close'], 
          color='red', marker='v', s=100, label='Death Cross', zorder=5)

ax.set_ylabel('Price (USD)')
ax.set_title(f'{ticker} - MACD Trading Signals')
ax.legend()
ax.grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

MACDダイバージェンス

ダイバージェンスの検出

 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
def find_divergence(prices, macd, lookback=20):
    """
    MACDダイバージェンスを検出
    """
    divergences = []
    
    for i in range(lookback, len(prices) - lookback):
        # 価格の高値/安値
        price_window = prices.iloc[i-lookback:i+lookback]
        price_high = price_window.max()
        price_low = price_window.min()
        
        # MACDの高値/安値
        macd_window = macd.iloc[i-lookback:i+lookback]
        macd_high = macd_window.max()
        macd_low = macd_window.min()
        
        current_price = prices.iloc[i]
        current_macd = macd.iloc[i]
        
        # ベアリッシュダイバージェンス
        if current_price >= price_high * 0.98 and current_macd <= macd_high * 0.95:
            divergences.append((prices.index[i], 'Bearish', current_price))
        
        # ブルリッシュダイバージェンス
        elif current_price <= price_low * 1.02 and current_macd >= macd_low * 0.95:
            divergences.append((prices.index[i], 'Bullish', current_price))
    
    return divergences

# 検出実行
divs = find_divergence(df['Close'], df['MACD'])

print(f"検出されたダイバージェンス: {len(divs)}個")
for date, type_, price in divs[:5]:
    print(f"  {date.strftime('%Y-%m-%d')}: {type_} at ${price:.2f}")

バックテスト

MACDクロスオーバー戦略の検証

 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
# ポジションの計算（シグナルラインクロス）
df['Signal_Line'] = np.where(df['MACD'] > df['Signal'], 1, -1)
df['Position'] = df['Signal_Line'].shift(1)  # 翌日オープンでエントリー

# リターン計算
df['Market_Return'] = df['Close'].pct_change()
df['Strategy_Return'] = df['Position'] * df['Market_Return']

# 累積リターン
df['Cumulative_Market'] = (1 + df['Market_Return']).cumprod()
df['Cumulative_Strategy'] = (1 + df['Strategy_Return']).cumprod()

# パフォーマンス比較
print("=== MACD戦略 vs Buy & Hold ===")
print(f"Buy & Hold リターン: {(df['Cumulative_Market'].iloc[-1] - 1) * 100:.2f}%")
print(f"MACD戦略 リターン: {(df['Cumulative_Strategy'].iloc[-1] - 1) * 100:.2f}%")

# 可視化
plt.figure(figsize=(12, 6))
plt.plot(df.index, df['Cumulative_Market'], label='Buy & Hold', color='gray', alpha=0.7)
plt.plot(df.index, df['Cumulative_Strategy'], label='MACD Strategy', color='blue')
plt.title('MACD Strategy Backtest')
plt.ylabel('Cumulative Return')
plt.legend()
plt.grid(True, alpha=0.3)
plt.show()

まとめ

MACDのポイント:

Posts

Pythonで株価を可視化する - matplotlibとPlotlyで美しいチャート作成

はじめに

取得した株価データを分かりやすく可視化することは、分析の第一歩です。

この記事では、Pythonの代表的な可視化ライブラリ matplotlib と Plotly を使って、株価チャートを作成する方法を解説します。

使用するライブラリ

ライブラリ	特徴	用途
matplotlib	静的なチャート	論文、レポート
Plotly	インタラクティブ	Webアプリ、ダッシュボード
mplfinance	金融特化	ローソク足チャート

準備

1
pip install matplotlib plotly mplfinance pandas yfinance

matplotlibでの基本チャート

株価の推移をラインチャートで表示

 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
import yfinance as yf
import matplotlib.pyplot as plt
import pandas as pd

# データ取得
ticker = "AAPL"
stock = yf.Ticker(ticker)
df = stock.history(period="1y")

# チャート作成
plt.figure(figsize=(12, 6))
plt.plot(df.index, df['Close'], label='Close Price', linewidth=2, color='#1a5f2a')

# 移動平均線を追加
df['MA20'] = df['Close'].rolling(window=20).mean()
df['MA50'] = df['Close'].rolling(window=50).mean()
plt.plot(df.index, df['MA20'], label='MA20', alpha=0.7, color='orange')
plt.plot(df.index, df['MA50'], label='MA50', alpha=0.7, color='red')

# チャートの装飾
plt.title(f'{ticker} Stock Price with Moving Averages', fontsize=16, fontweight='bold')
plt.xlabel('Date', fontsize=12)
plt.ylabel('Price (USD)', fontsize=12)
plt.legend(loc='upper left')
plt.grid(True, alpha=0.3)
plt.tight_layout()

# 保存と表示
plt.savefig(f'{ticker}_chart.png', dpi=150, bbox_inches='tight')
plt.show()

複数銘柄の比較チャート

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
# 複数銘柄を取得
tickers = ['AAPL', 'MSFT', 'GOOGL', 'AMZN']
data = yf.download(tickers, period='1y')['Close']

# 正規化（年初を100とする）
normalized = data / data.iloc[0] * 100

# チャート作成
plt.figure(figsize=(12, 6))
for ticker in tickers:
    plt.plot(normalized.index, normalized[ticker], label=ticker, linewidth=2)

plt.title('Stock Price Comparison (Normalized)', fontsize=16, fontweight='bold')
plt.xlabel('Date')
plt.ylabel('Normalized Price (Base=100)')
plt.legend()
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

mplfinanceでローソク足チャート

 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
import mplfinance as mpf

# データ取得（3ヶ月分）
df = yf.download('AAPL', period='3mo')

# カラースタイルの設定
mc = mpf.make_marketcolors(
    up='green',    # 陽線
    down='red',    # 陰線
    edge='inherit',
    wick='inherit'
)

s = mpf.make_mpf_style(
    marketcolors=mc,
    figsize=(12, 6),
    gridstyle='-',
    gridcolor='gray',
    gridalpha=0.3
)

# ローソク足チャート作成
mpf.plot(
    df,
    type='candle',
    style=s,
    title='AAPL Candlestick Chart',
    ylabel='Price (USD)',
    volume=True,           # 出来高も表示
    mav=(20, 50),          # 移動平均線
    tight_layout=True,
    savefig='candlestick.png'
)

Plotlyでインタラクティブチャート

基本のラインチャート

 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
import plotly.graph_objects as go
from plotly.subplots import make_subplots

# データ取得
df = yf.download('AAPL', period='1y')

# チャート作成
fig = go.Figure()

# 終値のライン
fig.add_trace(go.Scatter(
    x=df.index,
    y=df['Close'],
    mode='lines',
    name='Close Price',
    line=dict(color='#1a5f2a', width=2)
))

# 高値・安値のレンジ
fig.add_trace(go.Scatter(
    x=df.index,
    y=df['High'],
    mode='lines',
    name='High',
    line=dict(color='green', width=1, dash='dash'),
    opacity=0.5
))

fig.add_trace(go.Scatter(
    x=df.index,
    y=df['Low'],
    mode='lines',
    name='Low',
    line=dict(color='red', width=1, dash='dash'),
    opacity=0.5
))

# レイアウト設定
fig.update_layout(
    title='AAPL Stock Price (Interactive)',
    xaxis_title='Date',
    yaxis_title='Price (USD)',
    hovermode='x unified',
    template='plotly_white'
)

# 表示（HTMLとして保存も可能）
fig.show()
fig.write_html('interactive_chart.html')

ローソク足＋出来高

 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
# サブプロット作成（2行1列）
fig = make_subplots(
    rows=2, cols=1,
    shared_xaxes=True,
    vertical_spacing=0.03,
    row_heights=[0.7, 0.3],
    subplot_titles=('AAPL Price', 'Volume')
)

# ローソク足
fig.add_trace(
    go.Candlestick(
        x=df.index,
        open=df['Open'],
        high=df['High'],
        low=df['Low'],
        close=df['Close'],
        name='Price'
    ),
    row=1, col=1
)

# 出来高
fig.add_trace(
    go.Bar(
        x=df.index,
        y=df['Volume'],
        name='Volume',
        marker_color='blue'
    ),
    row=2, col=1
)

# レイアウト
fig.update_layout(
    title='AAPL Stock Price with Volume',
    xaxis_rangeslider_visible=False,
    height=600
)

fig.show()

リターン分布の可視化

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# 日次リターンの計算
returns = df['Close'].pct_change().dropna()

# ヒストグラム
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 5))

# ヒストグラム
ax1.hist(returns, bins=50, edgecolor='black', alpha=0.7, color='#1a5f2a')
ax1.axvline(returns.mean(), color='red', linestyle='--', label=f'Mean: {returns.mean():.4f}')
ax1.axvline(returns.median(), color='orange', linestyle='--', label=f'Median: {returns.median():.4f}')
ax1.set_xlabel('Daily Return')
ax1.set_ylabel('Frequency')
ax1.set_title('Distribution of Daily Returns')
ax1.legend()
ax1.grid(True, alpha=0.3)

# Q-Qプロット（正規性の確認）
from scipy import stats
stats.probplot(returns, dist="norm", plot=ax2)
ax2.set_title('Q-Q Plot (Normality Check)')
ax2.grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

まとめ

ライブラリ	おすすめ用途
matplotlib	論文、静的レポート
mplfinance	ローソク足、金融特化
Plotly	Webダッシュボード、インタラクティブな分析

次のステップ:

Posts

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

はじめに

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

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

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

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

モンテカルロ法とは？

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

投資への応用

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

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

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

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}%")

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

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

Posts

Pythonで株価のボラティリティを予測する - GARCHモデル入門

はじめに

株価の**ボラティリティ（変動性）**は、リスク管理やオプション価格の決定に重要です。

「ボラティリティは常に変化する」という特徴を捉えるために、GARCHモデルが広く使われています。

この記事では、GARCHモデルの基礎とPython実装を解説します。

GARCHモデルとは？

ボラティリティの特徴

株価のボラティリティには以下の特徴があります：

クラスタリング: 高いボラティリティの後に高いボラティリティが続きやすい
平均回帰: 長期的には平均レベルに戻る
レバレッジ効果: 下落時の方がボラティリティが上がりやすい

GARCH(1,1)モデル

GARCH（Generalized Autoregressive Conditional Heteroskedasticity）モデルは、条件付き分散（ボラティリティ）を以下の式でモデル化します：

$$\sigma_t^2 = \omega + \alpha r_{t-1}^2 + \beta \sigma_{t-1}^2$$

ここで：

$\sigma_t^2$ = 時点$t$での条件付き分散
$\omega$ = 定数項
$\alpha$ = ARCH項の係数（前日のリターンの影響）
$\beta$ = GARCH項の係数（前日のボラティリティの影響）
$r_{t-1}$ = 前日のリターン

制約条件:

$\omega > 0$
$\alpha \geq 0, \beta \geq 0$
$\alpha + \beta < 1$（安定性条件）

Pythonでの実装

ライブラリのインストール

1
pip install arch yfinance pandas numpy matplotlib

Step 1: データ取得と前処理

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
import yfinance as yf
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from arch import arch_model

# S&P500のデータを取得
ticker = "^GSPC"
data = yf.download(ticker, start="2020-01-01", end="2024-12-31")['Close']

# 日次リターンを計算
returns = 100 * data.pct_change().dropna()  # パーセンテージ表記

print(f"データ期間: {returns.index[0]} ～ {returns.index[-1]}")
print(f"観測数: {len(returns)}")
print(f"平均リターン: {returns.mean():.4f}%")
print(f"リターンの標準偏差: {returns.std():.4f}%")

Step 2: リターンの可視化

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
fig, axes = plt.subplots(2, 1, figsize=(12, 8))

# 株価
axes[0].plot(data.index, data, label='S&P 500')
axes[0].set_title('S&P 500 Index')
axes[0].set_ylabel('Price')
axes[0].legend()
axes[0].grid(True, alpha=0.3)

# リターン
axes[1].plot(returns.index, returns, label='Daily Returns', alpha=0.7)
axes[1].axhline(y=0, color='red', linestyle='--', alpha=0.5)
axes[1].set_title('Daily Returns (%)')
axes[1].set_ylabel('Return (%)')
axes[1].legend()
axes[1].grid(True, alpha=0.3)

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

Step 3: GARCH(1,1)モデルの推定

1
2
3
4
5
6
7
# GARCH(1,1)モデルを構築
model = arch_model(returns, vol='Garch', p=1, q=1, dist='normal')

# モデルをフィット
result = model.fit(update_freq=5)

print(result.summary())

Step 4: 結果の解釈

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
# 推定されたパラメータ
params = result.params
omega = params['omega']
alpha = params['alpha[1]']
beta = params['beta[1]']

print(f"\n=== 推定パラメータ ===")
print(f"ω (定数項): {omega:.6f}")
print(f"α (ARCH項): {alpha:.4f}")
print(f"β (GARCH項): {beta:.4f}")
print(f"α + β (持続性): {alpha + beta:.4f}")
print(f"長期分散: {omega / (1 - alpha - beta):.4f}")

# 持続性の解釈
persistence = alpha + beta
if persistence > 0.95:
    print("\n高い持続性: ショックは長期間影響を残します")
elif persistence > 0.9:
    print("\n中程度の持続性: ショックは中期的に影響を残します")
else:
    print("\n低い持続性: ショックは短期間で消散します")

Step 5: 条件付きボラティリティの可視化

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
# 条件付きボラティリティを取得
conditional_volatility = result.conditional_volatility

fig, ax = plt.subplots(figsize=(12, 6))

ax.plot(returns.index, conditional_volatility, label='Conditional Volatility', color='red')
ax.set_ylabel('Volatility (%)')
ax.set_xlabel('Date')
ax.set_title('GARCH(1,1) Estimated Volatility')
ax.legend()
ax.grid(True, alpha=0.3)

# ボラティリティが高かった時期を強調
high_vol_periods = conditional_volatility[conditional_volatility > conditional_volatility.quantile(0.95)]
ax.scatter(high_vol_periods.index, high_vol_periods.values, color='orange', s=20, zorder=5)

plt.tight_layout()
plt.savefig('garch_volatility.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
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
# 将来のボラティリティを予測
forecast = result.forecast(horizon=30)

# 予測された分散
forecast_variance = forecast.variance.values[-1, :]
forecast_volatility = np.sqrt(forecast_variance)

# 予測期間の日付を生成
last_date = returns.index[-1]
forecast_dates = pd.date_range(start=last_date, periods=31, freq='B')[1:]

# プロット
fig, ax = plt.subplots(figsize=(12, 6))

# 過去のボラティリティ
ax.plot(returns.index[-60:], conditional_volatility[-60:], 
       label='Historical Volatility', color='blue')

# 予測ボラティリティ
ax.plot(forecast_dates, forecast_volatility, 
       label='Forecasted Volatility', color='red', linestyle='--')

# 信頼区間（仮に±2標準偏差）
ax.fill_between(forecast_dates, 
               forecast_volatility * 0.8, 
               forecast_volatility * 1.2,
               alpha=0.2, color='red', label='Confidence Interval')

ax.set_ylabel('Volatility (%)')
ax.set_xlabel('Date')
ax.set_title('Volatility Forecast (Next 30 Days)')
ax.legend()
ax.grid(True, alpha=0.3)

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

print(f"\n=== 30日先のボラティリティ予測 ===")
print(f"現在のボラティリティ: {conditional_volatility.iloc[-1]:.2f}%")
print(f"30日後の予測: {forecast_volatility[-1]:.2f}%")

モデルの診断

残差の検定

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
# 標準化残差
std_residuals = result.resid / conditional_volatility

# 残差の自己相関を検定
from statsmodels.stats.diagnostic import acorr_ljungbox

ljung_box = acorr_ljungbox(std_residuals**2, lags=10, return_df=True)
print("\n=== 残差のLjung-Box検定（ボラティリティの残差）===")
print(ljung_box)

# p値が0.05以上なら、残差に自己相関なし（モデルは適切）

他のモデルとの比較

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
# EGARCHモデル（非対称性を考慮）
egarch_model = arch_model(returns, vol='EGarch', p=1, q=1)
egarch_result = egarch_model.fit(disp='off')

# モデル比較
print("\n=== モデル比較 ===")
print(f"GARCH(1,1) AIC: {result.aic:.2f}")
print(f"EGARCH(1,1) AIC: {egarch_result.aic:.2f}")

if result.aic < egarch_result.aic:
    print("GARCH(1,1)がより良いフィット")
else:
    print("EGARCH(1,1)がより良いフィット（レバレッジ効果あり）")

よくあるエラーと解決法

エラー1: “ConvergenceWarning”

原因: モデルが収束しない

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}%")

まとめ

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

Posts

RSI（相対力指数）の計算と可視化 - Python実装

はじめに

RSI（Relative Strength Index、相対力指数）は、価格の変動の強さを測るオシレーターです。

「株価が上がりすぎたか、下がりすぎたか」を数値化し、**30以下（過売い）や70以上（過買い）**を売買のタイミングとして使います。

この記事では、RSIの計算式を理解し、Pythonでゼロから実装します。

RSIとは？

基本的な考え方

RSIは、過去n日間の値上がり幅と値下がり幅の比率を表します。

$$RSI = 100 - \frac{100}{1 + RS}$$

ここで、$RS$（Relative Strength）は：

$$RS = \frac{過去n日間の平均値上がり幅}{過去n日間の平均値下がり幅}$$

解釈の仕方

RSI値	状態	トレーディングの意味
70以上	過買い（Overbought）	売りのサイン
50	中立	トレンドの転換点
30以下	過売い（Oversold）	買いのサイン

計算ステップ

前日比の変化を計算
値上がり/値下がりに分類
平均値上がり幅・平均値下がり幅を計算（通常は14日）
RSを計算
RSIを計算

Pythonでの実装

Step 1: データ取得

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
import yfinance as yf
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

# Appleのデータを取得
ticker = "AAPL"
df = yf.download(ticker, period="2y")
df = df['Close'].to_frame()

print(df.head())

Step 2: RSIの計算

 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
def calculate_rsi(prices, period=14):
    """
    RSIを計算する関数
    
    Parameters:
        prices: 株価データ（ pandas Series）
        period: RSIの期間（デフォルト14）
    
    Returns:
        RSI値のSeries
    """
    # 前日比の変化
    delta = prices.diff()
    
    # 値上がりと値下がりに分ける
    gain = (delta.where(delta > 0, 0)).rolling(window=period).mean()
    loss = (-delta.where(delta < 0, 0)).rolling(window=period).mean()
    
    # RSを計算
    rs = gain / loss
    
    # RSIを計算
    rsi = 100 - (100 / (1 + rs))
    
    return rsi

# RSIを計算（14日）
df['RSI'] = calculate_rsi(df['Close'], period=14)

# 最初の14日はNaNになるので削除
df = df.dropna()

print(df.head(20))

精度向上版：指数移動平均を使用

上記の単純移動平均（SMA）版RSIは簡単ですが、**指数移動平均（EMA）**を使う方が一般的です。

Posts

Pythonで株価データを取得する完全ガイド - yfinance入門

はじめに

投資の自動化や分析を始めたいけど、株価データの取得方法がわからない…そんな悩みありませんか？

この記事では、yfinanceという無料のPythonライブラリを使って、Yahoo Financeから株価データを取得する方法を徹底解説します。

yfinanceとは？

yfinanceは、Yahoo Financeの株価データを簡単に取得できるPythonライブラリです。

メリット:

✅ 無料で使える
✅ APIキー不要
✅ コード数行でデータ取得可能
✅ 日本株（東証上場企業）にも対応

この記事で学べること

yfinanceのインストール方法
株価データ（終値、始値、高値、安値、出来高）の取得
期間指定や複数銘柄の一括取得
データのCSV保存方法

前提条件

Python 3.8以上がインストールされていること
pipまたはcondaが使えること

環境構築

Step 1: yfinanceのインストール

ターミナル（コマンドプロンプト）で以下を実行します：

1
pip install yfinance pandas

または、Anacondaを使っている場合：

1
conda install -c conda-forge yfinance pandas

インストール確認：

1
2
import yfinance as yf
print(yf.__version__)

バージョン番号が表示されればOKです。

実装

基本的な株価データ取得

まずは、米国株の代表であるApple（AAPL）の株価を取得してみましょう。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
import yfinance as yf
import pandas as pd

# Appleの株価データを取得
 ticker = "AAPL"
stock = yf.Ticker(ticker)

# 過去1年間の日次データを取得
df = stock.history(period="1y")

# 先頭5行を表示
print(df.head())

実行結果：