import ccxt
import pandas as pd
import numpy as np
from datetime import datetime, timedelta

def fetch_ohlcv_data(exchange_id='binance', symbol='BTC/USDT', timeframe='1h', limit=2000):
    """
    仮想通貨の価格データを取得する関数
    """
    exchange = ccxt.__dict__[exchange_id]()
    ohlcv = exchange.fetch_ohlcv(symbol, timeframe=timeframe, limit=limit)
    
    df = pd.DataFrame(ohlcv, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
    df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms')
    df.set_index('timestamp', inplace=True)
    
    return df

# データ取得
df = fetch_ohlcv_data()
print(f"取得したデータ件数: {len(df)}")
print(df.tail())

import ta  # Technical Analysis library

def add_technical_indicators(df):
    """
    テクニカル指標を特徴量として追加する
    """
    # 移動平均
    df['sma_5'] = ta.trend.sma_indicator(df['close'], window=5)
    df['sma_20'] = ta.trend.sma_indicator(df['close'], window=20)
    df['sma_50'] = ta.trend.sma_indicator(df['close'], window=50)
    df['ema_12'] = ta.trend.ema_indicator(df['close'], window=12)
    df['ema_26'] = ta.trend.ema_indicator(df['close'], window=26)
    
    # RSI
    df['rsi'] = ta.momentum.rsi(df['close'], window=14)
    
    # MACD
    macd = ta.trend.MACD(df['close'])
    df['macd'] = macd.macd()
    df['macd_signal'] = macd.macd_signal()
    df['macd_diff'] = macd.macd_diff()
    
    # ボリンジャーバンド
    bb = ta.volatility.BollingerBands(df['close'], window=20, window_dev=2)
    df['bb_upper'] = bb.bollinger_hband()
    df['bb_lower'] = bb.bollinger_lband()
    df['bb_width'] = (df['bb_upper'] - df['bb_lower']) / bb.bollinger_mavg()
    
    # ATR
    df['atr'] = ta.volatility.average_true_range(df['high'], df['low'], df['close'], window=14)
    
    # リターン特徴量
    df['return_1'] = df['close'].pct_change(1)
    df['return_3'] = df['close'].pct_change(3)
    df['return_6'] = df['close'].pct_change(6)
    
    # 時間特徴量
    df['hour'] = df.index.hour
    df['day_of_week'] = df.index.dayofweek
    df['month'] = df.index.month
    
    # NaNを除去
    df.dropna(inplace=True)
    
    return df

df = add_technical_indicators(df)
print(f"特徴量数: {df.shape[1]}")

from sklearn.preprocessing import MinMaxScaler
import numpy as np

def create_sequences(data, seq_length=48, target_col='return_1'):
    """
    LSTMに入力するシーケンスデータを生成する
    """
    scaler = MinMaxScaler()
    feature_cols = [col for col in data.columns if col != target_col]
    
    X_scaled = scaler.fit_transform(data[feature_cols])
    y = data[target_col].values
    
    X_seq, y_seq = [], []
    for i in range(seq_length, len(X_scaled)):
        X_seq.append(X_scaled[i - seq_length:i])
        y_seq.append(y[i])
    
    return np.array(X_seq), np.array(y_seq), scaler

SEQ_LENGTH = 48
X, y, scaler = create_sequences(df, seq_length=SEQ_LENGTH)

# 訓練・検証・テスト分割（時系列なので末尾をテストに）
train_size = int(len(X) * 0.7)
val_size = int(len(X) * 0.15)

X_train, y_train = X[:train_size], y[:train_size]
X_val, y_val = X[train_size:train_size+val_size], y[train_size:train_size+val_size]
X_test, y_test = X[train_size+val_size:], y[train_size+val_size:]

print(f"訓練データ形状: {X_train.shape}")
print(f"検証データ形状: {X_val.shape}")
print(f"テストデータ形状: {X_test.shape}")

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense, Dropout, BatchNormalization
from tensorflow.keras.callbacks import EarlyStopping, ReduceLROnPlateau

def build_lstm_model(input_shape, units=[128, 64], dropout_rate=0.3):
    """
    LSTMモデルを構築する
    """
    model = Sequential([
        LSTM(units[0], return_sequences=True, input_shape=input_shape),
        BatchNormalization(),
        Dropout(dropout_rate),
        
        LSTM(units[1], return_sequences=False),
        BatchNormalization(),
        Dropout(dropout_rate),
        
        Dense(32, activation='relu'),
        Dropout(0.2),
        Dense(1, activation='linear')
    ])
    
    model.compile(
        optimizer=tf.keras.optimizers.Adam(learning_rate=0.001),
        loss='huber',
        metrics=['mae']
    )
    return model

input_shape = (X_train.shape[1], X_train.shape[2])
lstm_model = build_lstm_model(input_shape)

callbacks = [
    EarlyStopping(monitor='val_loss', patience=15, restore_best_weights=True),
    ReduceLROnPlateau(monitor='val_loss', factor=0.5, patience=7, min_lr=1e-6)
]

history = lstm_model.fit(
    X_train, y_train,
    validation_data=(X_val, y_val),
    epochs=100,
    batch_size=64,
    callbacks=callbacks,
    verbose=1
)

import torch
import torch.nn as nn
import math

class PositionalEncoding(nn.Module):
    """位置エンコーディング"""
    def __init__(self, d_model, max_len=500, dropout=0.1):
        super().__init__()
        self.dropout = nn.Dropout(p=dropout)
        
        pe = torch.zeros(max_len, d_model)
        position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)
        div_term = torch.exp(torch.arange(0, d_model, 2).float() * 
                             (-math.log(10000.0) / d_model))
        pe[:, 0::2] = torch.sin(position * div_term)
        pe[:, 1::2] = torch.cos(position * div_term)
        pe = pe.unsqueeze(0)
        self.register_buffer('pe', pe)
    
    def forward(self, x):
        x = x + self.pe[:, :x.size(1), :]
        return self.dropout(x)


class CryptoTransformer(nn.Module):
    """仮想通貨価格予測用Transformerモデル"""
    def __init__(self, input_dim, d_model=128, nhead=8, num_layers=3, 
                 dim_feedforward=512, dropout=0.1):
        super().__init__()
        
        self.input_projection = nn.Linear(input_dim, d_model)
        self.pos_encoding = PositionalEncoding(d_model, dropout=dropout)
        
        encoder_layer = nn.TransformerEncoderLayer(
            d_model=d_model,
            nhead=nhead,
            dim_feedforward=dim_feedforward,
            dropout=dropout,
            batch_first=True
        )
        self.transformer_encoder = nn.TransformerEncoder(encoder_layer, num_layers=num_layers)
        
        self.output_layer = nn.Sequential(
            nn.Linear(d_model, 64),
            nn.ReLU(),
            nn.Dropout(dropout),
            nn.Linear(64, 1)
        )
    
    def forward(self, x):
        x = self.input_projection(x)
        x = self.pos_encoding(x)
        x = self.transformer_encoder(x)
        x = x[:, -1, :]  # 最後のタイムステップを使用
        return self.output_layer(x).squeeze(-1)


# モデルの初期化
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
transformer_model = CryptoTransformer(
    input_dim=X_train.shape[2],
    d_model=128,
    nhead=8,
    num_layers=3
).to(device)

print(f"パラメータ数: {sum(p.numel() for p in transformer_model.parameters()):,}")

import xgboost as xgb
from sklearn.metrics import mean_absolute_error, mean_squared_error
import matplotlib.pyplot as plt

# XGBoostはシーケンスではなく、特徴量の行列として入力
X_xgb = df.drop(columns=['return_1']).values
y_xgb = df['return_1'].values

X_train_xgb = X_xgb[:train_size]
X_val_xgb = X_xgb[train_size:train_size+val_size]
X_test_xgb = X_xgb[train_size+val_size:]
y_train_xgb = y_xgb[:train_size]
y_val_xgb = y_xgb[train_size:train_size+val_size]
y_test_xgb = y_xgb[train_size+val_size:]

xgb_model = xgb.XGBRegressor(
    n_estimators=1000,
    learning_rate=0.01,
    max_depth=6,
    subsample=0.8,
    colsample_bytree=0.8,
    reg_alpha=0.1,
    reg_lambda=1.0,
    eval_metric='mae',
    early_stopping_rounds=50,
    random_state=42
)

xgb_model.fit(
    X_train_xgb, y_train_xgb,
    eval_set=[(X_val_xgb, y_val_xgb)],
    verbose=100
)

# 特徴量重要度の確認
feature_importance = pd.Series(
    xgb_model.feature_importances_,
    index=df.drop(columns=['return_1']).columns
).sort_values(ascending=False)

print("上位10特徴量:")
print(feature_importance.head(10))

def evaluate_model(y_true, y_pred, model_name):
    """
    モデルの評価指標を計算する
    """
    mae = mean_absolute_error(y_true, y_pred)
    rmse = np.sqrt(mean_squared_error(y_true, y_pred))
    
    # 方向的正解率（上がる・下がるの予測が合っているか）
    direction_accuracy = np.mean(np.sign(y_true) == np.sign(y_pred))
    
    print(f"\n{model_name}の評価結果:")
    print(f"  MAE:  {mae:.6f}")
    print(f"  RMSE: {rmse:.6f}")
    print(f"  方向正解率: {direction_accuracy:.2%}")
    
    return {'mae': mae, 'rmse': rmse, 'direction_acc': direction_accuracy}

# テストデータで予測
lstm_pred = lstm_model.predict(X_test).flatten()
transformer_pred = transformer_model(torch.FloatTensor(X_test).to(device)).detach().cpu().numpy()
xgb_pred = xgb_model.predict(X_test_xgb)

results = {}
results['LSTM'] = evaluate_model(y_test, lstm_pred, 'LSTM')
results['Transformer'] = evaluate_model(y_test, transformer_pred, 'Transformer')
results['XGBoost'] = evaluate_model(y_test_xgb, xgb_pred, 'XGBoost')