Update app.py

app.py

@@ -3,161 +3,154 @@ import torch
 import torch.nn as nn
 import torch.optim as optim
 from torch.utils.data import Dataset, DataLoader
-from sklearn.model_selection import TimeSeriesSplit
+from sklearn.model_selection import train_test_split
 from sklearn.preprocessing import StandardScaler
-from sklearn.metrics import mean_squared_error
-import numpy as np
-import os
-import gradio as gr
-import time
 import joblib
+import gradio as gr
+from apscheduler.schedulers.background import BackgroundScheduler
 
-# Load and preprocess data (updated every retrain)
-def load_data():
-    # Load the latest CSV data (assume it's updated periodically)
-    data = pd.read_csv('BANKNIFTY_OPTION_CHAIN_data.csv')
+# Load the data
+data = pd.read_csv('BANKNIFTY_OPTION_CHAIN_data.csv')
 
-    # Feature engineering: Create technical indicators, lag features, etc.
-    data['SMA_20'] = data['close'].rolling(window=20).mean()
-    data['SMA_50'] = data['close'].rolling(window=50).mean()
-    data['RSI'] = 100 - (100 / (1 + (data['close'].diff(1).clip(lower=0).mean() /
-                                     data['close'].diff(1).clip(upper=0).mean())))
-    data.fillna(0, inplace=True)
-    return data
+# Preprocess the data
+scaler = StandardScaler()
+scaled_data = scaler.fit_transform(data[['open', 'high', 'low', 'close', 'volume', 'oi']])
+data[['open', 'high', 'low', 'close', 'volume', 'oi']] = scaled_data
 
-# Define dataset class
+# Save the scaler for later use
+joblib.dump(scaler, 'scaler.gz')
+
+# Create a custom dataset class
 class BankNiftyDataset(Dataset):
-    def __init__(self, data, seq_len, features):
+    def __init__(self, data, seq_len):
         self.data = data
         self.seq_len = seq_len
-        self.features = features
 
     def __len__(self):
         return len(self.data) - self.seq_len
 
     def __getitem__(self, idx):
-        seq_data = self.data.iloc[idx:idx + self.seq_len][self.features].values
-        label = self.data['close'].iloc[idx + self.seq_len]
-        return {
-            'features': torch.tensor(seq_data, dtype=torch.float32),
-            'label': torch.tensor(label, dtype=torch.float32)
-        }
-
-# Transformer model with LSTM
-class TransformerLSTMModel(nn.Module):
-    def __init__(self, input_dim, hidden_dim, output_dim, nhead=4, num_encoder_layers=2):
-        super(TransformerLSTMModel, self).__init__()
+        seq_data = self.data.iloc[idx:idx+self.seq_len]
+        features = torch.tensor(seq_data[['open', 'high', 'low', 'close', 'volume', 'oi']].values, dtype=torch.float32)
+        label = torch.tensor(seq_data['close'].iloc[-1], dtype=torch.float32)
+        return features, label
+
+# Define the LSTM-RNN model
+class LSTMModel(nn.Module):
+    def __init__(self, input_dim, hidden_dim, output_dim):
+        super(LSTMModel, self).__init__()
         self.lstm = nn.LSTM(input_dim, hidden_dim, num_layers=1, batch_first=True)
-        self.transformer_encoder = nn.TransformerEncoder(
-            nn.TransformerEncoderLayer(d_model=hidden_dim, nhead=nhead), num_layers=num_encoder_layers
-        )
         self.fc = nn.Linear(hidden_dim, output_dim)
 
     def forward(self, x):
-        h0 = torch.zeros(1, x.size(0), 128).to(x.device)
-        c0 = torch.zeros(1, x.size(0), 128).to(x.device)
+        h0 = torch.zeros(1, x.size(0), self.lstm.hidden_size).to(x.device)
+        c0 = torch.zeros(1, x.size(0), self.lstm.hidden_size).to(x.device)
+
         out, _ = self.lstm(x, (h0, c0))
-        out = self.transformer_encoder(out)
         out = self.fc(out[:, -1, :])
         return out
 
-# Function to train the model and update it periodically
-def retrain_model(data, seq_len=10, batch_size=32, n_splits=5):
-    input_dim = len(features)
-    model = TransformerLSTMModel(input_dim=input_dim, hidden_dim=128, output_dim=1)
-    optimizer = optim.Adam(model.parameters(), lr=0.001)
-    criterion = nn.MSELoss()
-
-    tscv = TimeSeriesSplit(n_splits=n_splits)
-    best_loss = float('inf')
-
-    for fold, (train_idx, val_idx) in enumerate(tscv.split(data)):
-        train_data, val_data = data.iloc[train_idx], data.iloc[val_idx]
-        train_dataset = BankNiftyDataset(train_data, seq_len, features)
-        val_dataset = BankNiftyDataset(val_data, seq_len, features)
-
-        train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
-        val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=False)
-
-        for epoch in range(10):  # Train for 10 epochs per fold
-            model.train()
-            for batch in train_loader:
-                features = batch['features']
-                labels = batch['label'].unsqueeze(1)
-
-                optimizer.zero_grad()
-                outputs = model(features)
-                loss = criterion(outputs, labels)
-                loss.backward()
-                optimizer.step()
-
-            # Validation
-            model.eval()
-            val_loss = 0
-            with torch.no_grad():
-                for batch in val_loader:
-                    features = batch['features']
-                    labels = batch['label'].unsqueeze(1)
-                    outputs = model(features)
-                    val_loss += criterion(outputs, labels).item()
-
-            val_loss /= len(val_loader)
-            print(f'Fold {fold + 1}, Epoch {epoch + 1}, Val Loss: {val_loss}')
-
-            # Save the best model
-            if val_loss < best_loss:
-                best_loss = val_loss
-                torch.save(model.state_dict(), 'best_model.pth')
-                print("Model updated with new best performance.")
-
-# Periodically check for new data and retrain
-def schedule_retraining(interval_hours=24):
-    while True:
-        print("Retraining model...")
-        data = load_data()  # Load the latest data
-        retrain_model(data)  # Retrain the model
-        print(f"Next retraining scheduled in {interval_hours} hours.")
-        time.sleep(interval_hours * 3600)  # Sleep for the specified interval
-
-# Gradio interface for user prediction after automatic retraining
-def generate_strategy(open_, high, low, close, volume, oi, sma20, sma50, rsi):
-    # Prepare new data
-    new_data = pd.DataFrame({
-        'open': [open_], 'high': [high], 'low': [low], 'close': [close],
-        'volume': [volume], 'oi': [oi], 'SMA_20': [sma20], 'SMA_50': [sma50], 'RSI': [rsi]
-    })
-    new_data[features] = scaler.transform(new_data[features])
-    seq_data = new_data[features].values
-
-    # Load best model
-    model = TransformerLSTMModel(input_dim=len(features), hidden_dim=128, output_dim=1)
-    model.load_state_dict(torch.load('best_model.pth'))
-    model.eval()
+# Initialize model, optimizer, and loss function
+input_dim = 6
+hidden_dim = 128
+output_dim = 1
+seq_len = 10
 
-    # Make prediction
-    with torch.no_grad():
-        features = torch.tensor(seq_data, dtype=torch.float32).unsqueeze(0).unsqueeze(0)
+model = LSTMModel(input_dim=input_dim, hidden_dim=hidden_dim, output_dim=output_dim)
+optimizer = optim.Adam(model.parameters(), lr=0.001)
+criterion = nn.MSELoss()
+
+# Split the data into training and validation sets
+train_data, val_data = train_test_split(data, test_size=0.2, random_state=42)
+
+train_dataset = BankNiftyDataset(train_data, seq_len)
+val_dataset = BankNiftyDataset(val_data, seq_len)
+
+train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)
+val_loader = DataLoader(val_dataset, batch_size=32, shuffle=False)
+
+# Function to train the model
+def train_model():
+    model.train()
+    for batch in train_loader:
+        features, label = batch
+        optimizer.zero_grad()
         output = model(features)
-    return output.item()
+        loss = criterion(output, label)
+        loss.backward()
+        optimizer.step()
 
-# Gradio interface for real-time predictions
+# Function to evaluate the model on the validation set
+def evaluate_model():
+    model.eval()
+    total_loss = 0
+    with torch.no_grad():
+        for batch in val_loader:
+            features, label = batch
+            output = model(features)
+            loss = criterion(output, label)
+            total_loss += loss.item()
+    return total_loss / len(val_loader)
+
+# Function to generate a strategy based on user input
+def generate_strategy(open_price, high_price, low_price, close_price, volume, oi, sma_20, sma_50, rsi):
+    model.eval()
+    
+    input_data = torch.tensor([[open_price, high_price, low_price, close_price, volume, oi]], dtype=torch.float32)
+    
+    with torch.no_grad():
+        output = model(input_data)
+        strategy = f"Predicted Close Price: {output.item():.2f}"
+        return strategy
+
+# Retrain the model every week or month (depending on schedule)
+def retrain_model():
+    # Load fresh data, scale it, and retrain the model
+    new_data = pd.read_csv('BANKNIFTY_OPTION_CHAIN_data.csv')
+    new_scaled_data = scaler.transform(new_data[['open', 'high', 'low', 'close', 'volume', 'oi']])
+    new_data[['open', 'high', 'low', 'close', 'volume', 'oi']] = new_scaled_data
+
+    new_train_data, new_val_data = train_test_split(new_data, test_size=0.2, random_state=42)
+    new_train_dataset = BankNiftyDataset(new_train_data, seq_len)
+    new_val_dataset = BankNiftyDataset(new_val_data, seq_len)
+
+    new_train_loader = DataLoader(new_train_dataset, batch_size=32, shuffle=True)
+    new_val_loader = DataLoader(new_val_dataset, batch_size=32, shuffle=False)
+
+    # Training on new data
+    model.train()
+    for epoch in range(5):  # Train for 5 epochs
+        for batch in new_train_loader:
+            features, label = batch
+            optimizer.zero_grad()
+            output = model(features)
+            loss = criterion(output, label)
+            loss.backward()
+            optimizer.step()
+
+    # Save the retrained model
+    torch.save(model.state_dict(), 'retrained_model.pth')
+
+# Scheduler for automatic retraining
+scheduler = BackgroundScheduler()
+scheduler.add_job(retrain_model, 'interval', weeks=1)  # Schedule weekly retraining
+scheduler.start()
+
+# Gradio interface
 inputs = [
-    gr.inputs.Number(label="Open Price"),
-    gr.inputs.Number(label="High Price"),
-    gr.inputs.Number(label="Low Price"),
-    gr.inputs.Number(label="Close Price"),
-    gr.inputs.Number(label="Volume"),
-    gr.inputs.Number(label="Open Interest"),
-    gr.inputs.Number(label="SMA_20"),
-    gr.inputs.Number(label="SMA_50"),
-    gr.inputs.Number(label="RSI")
+    gr.components.Number(label="Open Price"),
+    gr.components.Number(label="High Price"),
+    gr.components.Number(label="Low Price"),
+    gr.components.Number(label="Close Price"),
+    gr.components.Number(label="Volume"),
+    gr.components.Number(label="Open Interest"),
+    gr.components.Number(label="SMA 20"),
+    gr.components.Number(label="SMA 50"),
+    gr.components.Number(label="RSI")
 ]
 
-outputs = gr.outputs.Textbox(label="Predicted Strategy")
+outputs = gr.components.Textbox(label="Predicted Strategy")
 
-# Launch Gradio interface for strategy prediction
+# Launch Gradio interface
 gr.Interface(fn=generate_strategy, inputs=inputs, outputs=outputs, title="BankNifty Strategy Generator").launch()
 
-# Start automatic retraining (optional, can be run separately)
-if __name__ == "__main__":
-    schedule_retraining(interval_hours=24)  # Retrain every 24 hours