Update app.py

app.py

@@ -8,27 +8,6 @@ from sklearn.preprocessing import StandardScaler
 from sklearn.model_selection import train_test_split
 import gradio as gr
 import os
-import time
-from fastapi import FastAPI, BackgroundTasks
-from fastapi.middleware.cors import CORSMiddleware
-import asyncio
-
-# FastAPI app
-app = FastAPI()
-
-# Add CORS middleware
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-# Global variables
-model = None
-scaler = None
-latest_report = "Initializing..."
 
 # Define the Dataset class
 class BankNiftyDataset(Dataset):
@@ -64,11 +43,13 @@ class LSTMModel(nn.Module):
         return out
 
 # Function to train the model
-def train_model(train_loader, val_loader, num_epochs=10):
-    global model
+def train_model(model, train_loader, val_loader, num_epochs=10):
     criterion = nn.MSELoss()
     optimizer = optim.Adam(model.parameters(), lr=0.001)
     
+    best_val_loss = float('inf')
+    best_model = None
+    
     for epoch in range(num_epochs):
         model.train()
         for features, labels in train_loader:
@@ -87,6 +68,13 @@ def train_model(train_loader, val_loader, num_epochs=10):
         val_loss /= len(val_loader)
         
         print(f"Epoch {epoch+1}/{num_epochs}, Validation Loss: {val_loss:.4f}")
+        
+        if val_loss < best_val_loss:
+            best_val_loss = val_loss
+            best_model = model.state_dict().copy()
+    
+    model.load_state_dict(best_model)
+    return model, best_val_loss
 
 # Function to generate trading signals
 def generate_signals(predictions, actual_values, stop_loss_threshold=0.05):
@@ -101,7 +89,7 @@ def generate_signals(predictions, actual_values, stop_loss_threshold=0.05):
     return signals
 
 # Function to generate a report
-def generate_report(predictions, actual_values, signals):
+def generate_report(predictions, actual_values, signals, val_loss):
     report = []
     cumulative_profit = 0
     for i in range(len(signals)):
@@ -115,12 +103,17 @@ def generate_report(predictions, actual_values, signals):
     
     total_profit = cumulative_profit
     report.append(f"Total Profit: {total_profit:.2f}")
+    report.append(f"Model Validation Loss: {val_loss:.4f}")
     return "\n".join(report)
 
+# Global variables to store the model and scaler
+global_model = None
+global_scaler = None
+
 # Function to process data and make predictions
 def predict():
-    global model, scaler, latest_report
-
+    global global_model, global_scaler
+    
     # Load the pre-existing CSV file
     csv_path = 'BANKNIFTY_OPTION_CHAIN_data.csv'
     if not os.path.exists(csv_path):
@@ -128,11 +121,13 @@ def predict():
 
     # Load and preprocess data
     data = pd.read_csv(csv_path)
-    if scaler is None:
-        scaler = StandardScaler()
-        scaled_data = scaler.fit_transform(data[['open', 'high', 'low', 'close', 'volume', 'oi']])
+    
+    if global_scaler is None:
+        global_scaler = StandardScaler()
+        scaled_data = global_scaler.fit_transform(data[['open', 'high', 'low', 'close', 'volume', 'oi']])
     else:
-        scaled_data = scaler.transform(data[['open', 'high', 'low', 'close', 'volume', 'oi']])
+        scaled_data = global_scaler.transform(data[['open', 'high', 'low', 'close', 'volume', 'oi']])
+    
     data[['open', 'high', 'low', 'close', 'volume', 'oi']] = scaled_data
 
     # Split data
@@ -147,60 +142,39 @@ def predict():
     val_loader = DataLoader(val_dataset, batch_size=32, shuffle=False)
 
     # Initialize and train the model
-    if model is None:
-        input_dim = 6
-        hidden_dim = 64
-        output_dim = len(target_cols)
-        model = LSTMModel(input_dim, hidden_dim, output_dim)
-
-    train_model(train_loader, val_loader)
+    input_dim = 6
+    hidden_dim = 64
+    output_dim = len(target_cols)
+    
+    if global_model is None:
+        global_model = LSTMModel(input_dim, hidden_dim, output_dim)
+    
+    global_model, val_loss = train_model(global_model, train_loader, val_loader)
 
     # Make predictions
-    model.eval()
+    global_model.eval()
     predictions = []
     actual_values = val_data['close'].values[seq_len-1:]
     with torch.no_grad():
         for i in range(len(val_dataset)):
             features, _ = val_dataset[i]
-            pred = model(features.unsqueeze(0)).item()
+            pred = global_model(features.unsqueeze(0)).item()
             predictions.append(pred)
 
     # Generate signals and report
     signals = generate_signals(predictions, actual_values)
-    latest_report = generate_report(predictions, actual_values, signals)
+    report = generate_report(predictions, actual_values, signals, val_loss)
 
-    return latest_report
-
-# Background task to update the model and report
-async def update_model_and_report():
-    global latest_report
-    while True:
-        latest_report = predict()
-        await asyncio.sleep(3600)  # Update every hour
-
-# Startup event to begin the background task
-@app.on_event("startup")
-async def startup_event():
-    background_tasks = BackgroundTasks()
-    background_tasks.add_task(update_model_and_report)
-    await background_tasks()
-
-# Gradio interface
-def gradio_interface():
-    return latest_report
+    return report
 
+# Set up the Gradio interface
 iface = gr.Interface(
-    fn=gradio_interface,
+    fn=predict,
     inputs=None,
-    outputs=gr.Textbox(label="Latest Prediction Report"),
+    outputs=gr.Textbox(label="Prediction Report"),
     title="BankNifty Option Chain Predictor",
-    description="This app automatically generates and updates predictions and trading signals based on the latest BankNifty option chain data."
+    description="Click 'Submit' to generate predictions and trading signals based on the latest BankNifty option chain data. The model is automatically trained and improved with each run."
 )
 
-# Combine FastAPI and Gradio
-app = gr.mount_gradio_app(app, iface, path="/")
-
-# Run the FastAPI app
-if __name__ == "__main__":
-    import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=7860)
+# Launch the app
+iface.launch()