Create

train.py

@@ -0,0 +1,205 @@
+import tensorflow as tf
+from tensorflow.keras import layers
+import pandas as pd
+import numpy as np
+from typing import Tuple, List
+import logging
+from datetime import datetime
+from pathlib import Path
+import json
+from sklearn.preprocessing import MinMaxScaler
+from ta.trend import SMAIndicator, EMAIndicator, MACD
+from ta.momentum import RSIIndicator
+from ta.volatility import BollingerBands
+
+# Set up logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+class DataPreprocessor:
+    """Handles data loading and preprocessing"""
+    
+    def __init__(self, config_path: str = 'training_config/hyperparameters.json'):
+        with open(config_path) as f:
+            self.config = json.load(f)
+        self.scalers = {}
+        
+    def load_data(self, data_path: str) -> pd.DataFrame:
+        """Load data from CSV and add technical indicators"""
+        df = pd.read_csv(data_path)
+        df['timestamp'] = pd.to_datetime(df['timestamp'])
+        df = df.sort_values('timestamp')
+        
+        # Add technical indicators
+        df = self.add_technical_indicators(df)
+        
+        return df
+        
+    def add_technical_indicators(self, df: pd.DataFrame) -> pd.DataFrame:
+        """Add technical analysis indicators"""
+        # SMA
+        df['sma_20'] = SMAIndicator(close=df['price'], window=20).sma_indicator()
+        df['sma_50'] = SMAIndicator(close=df['price'], window=50).sma_indicator()
+        
+        # EMA
+        df['ema_20'] = EMAIndicator(close=df['price'], window=20).ema_indicator()
+        
+        # MACD
+        macd = MACD(close=df['price'])
+        df['macd'] = macd.macd()
+        df['macd_signal'] = macd.macd_signal()
+        
+        # RSI
+        df['rsi'] = RSIIndicator(close=df['price']).rsi()
+        
+        # Bollinger Bands
+        bb = BollingerBands(close=df['price'])
+        df['bb_high'] = bb.bollinger_hband()
+        df['bb_low'] = bb.bollinger_lband()
+        
+        return df
+        
+    def prepare_sequences(self, df: pd.DataFrame) -> Tuple[np.ndarray, np.ndarray]:
+        """Create sequences for training"""
+        sequence_length = self.config['data']['sequence_length']
+        
+        # Scale features
+        for column in df.select_dtypes(include=[np.number]).columns:
+            if column not in self.scalers:
+                self.scalers[column] = MinMaxScaler()
+            df[column] = self.scalers[column].fit_transform(df[[column]])
+        
+        # Create sequences
+        sequences = []
+        targets = []
+        
+        for i in range(len(df) - sequence_length):
+            sequence = df.iloc[i:i + sequence_length]
+            target = df.iloc[i + sequence_length]['price']
+            sequences.append(sequence)
+            targets.append(target)
+            
+        return np.array(sequences), np.array(targets)
+
+class TransformerBlock(layers.Layer):
+    """Transformer block with multi-head attention"""
+    
+    def __init__(self, embed_dim, num_heads, ff_dim, rate=0.1):
+        super().__init__()
+        self.att = layers.MultiHeadAttention(num_heads=num_heads, key_dim=embed_dim)
+        self.ffn = tf.keras.Sequential([
+            layers.Dense(ff_dim, activation="relu"),
+            layers.Dense(embed_dim),
+        ])
+        self.layernorm1 = layers.LayerNormalization(epsilon=1e-6)
+        self.layernorm2 = layers.LayerNormalization(epsilon=1e-6)
+        self.dropout1 = layers.Dropout(rate)
+        self.dropout2 = layers.Dropout(rate)
+
+    def call(self, inputs, training):
+        attn_output = self.att(inputs, inputs)
+        attn_output = self.dropout1(attn_output, training=training)
+        out1 = self.layernorm1(inputs + attn_output)
+        ffn_output = self.ffn(out1)
+        ffn_output = self.dropout2(ffn_output, training=training)
+        return self.layernorm2(out1 + ffn_output)
+
+class CryptoTransformer(tf.keras.Model):
+    """Main transformer model for cryptocurrency prediction"""
+    
+    def __init__(self, config_path: str = 'training_config/hyperparameters.json'):
+        super().__init__()
+        
+        with open(config_path) as f:
+            self.config = json.load(f)
+        
+        # Model parameters
+        self.num_layers = self.config['model']['n_layers']
+        self.d_model = self.config['model']['d_model']
+        self.num_heads = self.config['model']['n_heads']
+        self.ff_dim = self.config['model']['d_ff']
+        self.dropout = self.config['model']['dropout']
+        
+        # Layers
+        self.transformer_blocks = [
+            TransformerBlock(self.d_model, self.num_heads, self.ff_dim, self.dropout)
+            for _ in range(self.num_layers)
+        ]
+        self.dropout = layers.Dropout(self.dropout)
+        self.dense = layers.Dense(1)  # Final prediction layer
+        
+    def call(self, inputs):
+        x = inputs
+        for transformer_block in self.transformer_blocks:
+            x = transformer_block(x)
+        x = layers.GlobalAveragePooling1D()(x)
+        x = self.dropout(x)
+        return self.dense(x)
+
+def train_model():
+    """Main training function"""
+    logger.info("Starting model training")
+    
+    # Initialize preprocessor and load data
+    preprocessor = DataPreprocessor()
+    df = preprocessor.load_data('data/training/kraken_trades.csv')
+    
+    # Prepare sequences
+    X, y = preprocessor.prepare_sequences(df)
+    
+    # Split data
+    train_size = int(0.8 * len(X))
+    X_train, X_test = X[:train_size], X[train_size:]
+    y_train, y_test = y[:train_size], y[train_size:]
+    
+    # Initialize model
+    model = CryptoTransformer()
+    
+    # Compile model
+    optimizer = tf.keras.optimizers.Adam(learning_rate=1e-4)
+    model.compile(
+        optimizer=optimizer,
+        loss='mse',
+        metrics=['mae']
+    )
+    
+    # Train model
+    history = model.fit(
+        X_train, y_train,
+        epochs=100,
+        batch_size=32,
+        validation_data=(X_test, y_test),
+        callbacks=[
+            tf.keras.callbacks.EarlyStopping(
+                monitor='val_loss',
+                patience=10,
+                restore_best_weights=True
+            ),
+            tf.keras.callbacks.ModelCheckpoint(
+                'models/crypto_transformer_{epoch}.h5',
+                save_best_only=True,
+                monitor='val_loss'
+            ),
+            tf.keras.callbacks.TensorBoard(log_dir='logs')
+        ]
+    )
+    
+    # Save final model
+    model.save('models/crypto_transformer_final')
+    
+    # Save training history
+    pd.DataFrame(history.history).to_csv('models/training_history.csv')
+    
+    logger.info("Training completed")
+    return model, history
+
+if __name__ == "__main__":
+    # Create necessary directories
+    Path('models').mkdir(exist_ok=True)
+    Path('logs').mkdir(exist_ok=True)
+    
+    # Train model
+    model, history = train_model()