BullnexAI

# BullnexAI LSTM Stock Prediction Model
# Architecture: 3-layer LSTM with Dropout Regularization

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

class BullnexLSTMModel:
    """Core LSTM model for stock price prediction"""
    
    def __init__(self, lookback_days=60):
        self.lookback = lookback_days
        self.model = self.build_model()
        self.scaler = MinMaxScaler(feature_range=(0, 1))
        
    def build_model(self):
        """Construct the LSTM neural network"""
        model = Sequential([
            # Layer 1: 100-unit LSTM with Dropout
            LSTM(units=100, 
                 return_sequences=True, 
                 input_shape=(self.lookback, 5),
                 recurrent_dropout=0.2),
            Dropout(0.2),
            
            # Layer 2: 100-unit LSTM with Dropout
            LSTM(units=100, 
                 return_sequences=True,
                 recurrent_dropout=0.2),
            Dropout(0.2),
            
            # Layer 3: 50-unit LSTM
            LSTM(units=50, 
                 return_sequences=False,
                 recurrent_dropout=0.2),
            Dropout(0.2),
            
            # Dense Layers
            Dense(units=25, activation='relu'),
            Dense(units=1)  # Single output: next day's close
        ])
        
        # Compile with Adam optimizer
        model.compile(
            optimizer='adam',
            loss='mean_squared_error',
            metrics=['mae', 'accuracy']
        )
        
        return model
    
    def prepare_sequences(self, data):
        """Create time-series sequences for LSTM"""
        X, y = [], []
        for i in range(self.lookback, len(data)):
            X.append(data[i-self.lookback:i])
            y.append(data[i, 1])  # Close price at position 1
        return np.array(X), np.array(y)
    
    def train(self, X_train, y_train, epochs=50, batch_size=32):
        """Train the LSTM model"""
        history = self.model.fit(
            X_train, y_train,
            epochs=epochs,
            batch_size=batch_size,
            validation_split=0.2,
            verbose=1
        )
        return history
    
    def predict(self, sequence):
        """Generate predictions"""
        return self.model.predict(sequence, verbose=0)

# Example usage
if __name__ == "__main__":
    # Initialize model
    predictor = BullnexLSTMModel(lookback_days=60)
    
    # Load and preprocess data
    data = pd.read_csv('stock_data.csv')
    scaled_data = predictor.scaler.fit_transform(data[['Open', 'Close', 'High', 'Low', 'Volume']])
    
    # Prepare sequences
    X, y = predictor.prepare_sequences(scaled_data)
    
    # Train model
    predictor.train(X, y)
    
    # Make prediction
    latest_sequence = X[-1].reshape(1, 60, 5)
    prediction = predictor.predict(latest_sequence)
    
    print(f"Predicted next close: {prediction[0][0]}")