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

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

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

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

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