AI in Market Predictions: Revolutionizing Capital Markets Intelligence

import numpy as np
import pandas as pd
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense, Dropout
from sklearn.preprocessing import MinMaxScaler
from sklearn.metrics import mean_squared_error, mean_absolute_error

class StockPriceLSTM:
    def __init__(self, lookback_window=60, lstm_units=50):
        self.lookback_window = lookback_window
        self.lstm_units = lstm_units
        self.scaler = MinMaxScaler(feature_range=(0, 1))
        self.model = None
        
    def prepare_data(self, data, target_column='Close'):
        """Prepare time series data for LSTM training"""
        # Scale the data
        scaled_data = self.scaler.fit_transform(data[[target_column]])
        
        # Create sequences
        X, y = [], []
        for i in range(self.lookback_window, len(scaled_data)):
            X.append(scaled_data[i-self.lookback_window:i, 0])
            y.append(scaled_data[i, 0])
            
        return np.array(X), np.array(y)
    
    def build_model(self, input_shape):
        """Build LSTM model architecture"""
        model = Sequential([
            LSTM(self.lstm_units, return_sequences=True, input_shape=input_shape),
            Dropout(0.2),
            LSTM(self.lstm_units, return_sequences=True),
            Dropout(0.2),
            LSTM(self.lstm_units),
            Dropout(0.2),
            Dense(1)
        ])
        
        model.compile(optimizer='adam', loss='mean_squared_error')
        self.model = model
        return model
    
    def train(self, X_train, y_train, epochs=100, batch_size=32, validation_split=0.2):
        """Train the LSTM model"""
        if self.model is None:
            self.build_model((X_train.shape 1))
            
        # Reshape input for LSTM
        X_train = X_train.reshape((X_train.shape[0], X_train.shape 1))
        
        history = self.model.fit(
            X_train, y_train,
            epochs=epochs,
            batch_size=batch_size,
            validation_split=validation_split,
            verbose=1
        )
        
        return history
    
    def predict(self, X_test):
        """Make predictions using trained model"""
        X_test = X_test.reshape((X_test.shape[0], X_test.shape 1))
        predictions = self.model.predict(X_test)
        
        # Inverse transform to get actual prices
        predictions = self.scaler.inverse_transform(predictions)
        return predictions
    
    def evaluate_model(self, y_true, y_pred):
        """Evaluate model performance"""
        mse = mean_squared_error(y_true, y_pred)
        mae = mean_absolute_error(y_true, y_pred)
        rmse = np.sqrt(mse)
        
        # Calculate directional accuracy
        direction_true = np.diff(y_true.flatten()) > 0
        direction_pred = np.diff(y_pred.flatten()) > 0
        directional_accuracy = np.mean(direction_true == direction_pred)
        
        return {
            'mse': mse,
            'mae': mae,
            'rmse': rmse,
            'directional_accuracy': directional_accuracy
        }

# Example usage
# model = StockPriceLSTM(lookback_window=60, lstm_units=50)
# X_train, y_train = model.prepare_data(train_data)
# model.train(X_train, y_train, epochs=50)
# predictions = model.predict(X_test)

import tensorflow as tf
from tensorflow.keras.models import Model
from tensorflow.keras.layers import Input, Dense, LSTM, Conv1D, Concatenate, Dropout
from tensorflow.keras.layers import MultiHeadAttention, LayerNormalization

class MultiModalMarketPredictor:
    def __init__(self, price_sequence_length=60, news_embedding_dim=768):
        self.price_sequence_length = price_sequence_length
        self.news_embedding_dim = news_embedding_dim
        self.model = None
        
    def build_price_branch(self, price_input):
        """Build neural network branch for price data"""
        # CNN for pattern recognition
        conv1 = Conv1D(filters=64, kernel_size=3, activation='relu')(price_input)
        conv2 = Conv1D(filters=32, kernel_size=3, activation='relu')(conv1)
        
        # LSTM for temporal dependencies
        lstm1 = LSTM(50, return_sequences=True)(conv2)
        lstm2 = LSTM(25)(lstm1)
        
        return lstm2
    
    def build_news_branch(self, news_input):
        """Build neural network branch for news sentiment"""
        # Dense layers for news embedding processing
        dense1 = Dense(512, activation='relu')(news_input)
        dropout1 = Dropout(0.3)(dense1)
        dense2 = Dense(256, activation='relu')(dropout1)
        dropout2 = Dropout(0.3)(dense2)
        dense3 = Dense(128, activation='relu')(dropout2)
        
        return dense3
    
    def build_attention_mechanism(self, price_features, news_features):
        """Build attention mechanism to focus on relevant features"""
        # Reshape for attention
        price_expanded = tf.expand_dims(price_features, axis=1)
        news_expanded = tf.expand_dims(news_features, axis=1)
        
        # Concatenate features
        combined = Concatenate(axis=1)([price_expanded, news_expanded])
        
        # Multi-head attention
        attention = MultiHeadAttention(
            num_heads=4, 
            key_dim=64
        )(combined, combined)
        
        # Layer normalization
        attention_norm = LayerNormalization()(attention + combined)
        
        # Global average pooling
        attention_pooled = tf.reduce_mean(attention_norm, axis=1)
        
        return attention_pooled
    
    def build_model(self):
        """Build complete multi-modal model"""
        # Input layers
        price_input = Input(shape=(self.price_sequence_length, 5), name='price_input')
        news_input = Input(shape=(self.news_embedding_dim,), name='news_input')
        
        # Feature extraction branches
        price_features = self.build_price_branch(price_input)
        news_features = self.build_news_branch(news_input)
        
        # Attention mechanism
        attention_features = self.build_attention_mechanism(price_features, news_features)
        
        # Final prediction layers
        dense1 = Dense(128, activation='relu')(attention_features)
        dropout1 = Dropout(0.4)(dense1)
        dense2 = Dense(64, activation='relu')(dropout1)
        dropout2 = Dropout(0.3)(dense2)
        
        # Multiple outputs for different prediction horizons
        price_1d = Dense(1, activation='linear', name='price_1d')(dropout2)
        price_5d = Dense(1, activation='linear', name='price_5d')(dropout2)
        direction = Dense(1, activation='sigmoid', name='direction')(dropout2)
        
        # Create model
        self.model = Model(
            inputs=[price_input, news_input],
            outputs=[price_1d, price_5d, direction]
        )
        
        # Compile with multiple loss functions
        self.model.compile(
            optimizer='adam',
            loss={
                'price_1d': 'mse',
                'price_5d': 'mse',
                'direction': 'binary_crossentropy'
            },
            loss_weights={'price_1d': 1.0, 'price_5d': 0.8, 'direction': 0.5},
            metrics={'direction': 'accuracy'}
        )
        
        return self.model
    
    def train_model(self, price_data, news_data, targets, epochs=100, batch_size=32):
        """Train the multi-modal model"""
        if self.model is None:
            self.build_model()
            
        history = self.model.fit(
            [price_data, news_data],
            targets,
            epochs=epochs,
            batch_size=batch_size,
            validation_split=0.2,
            verbose=1
        )
        
        return history