Update app.py

app.py

@@ -1,50 +1,101 @@
 import pandas as pd
-from transformers import LLaMAForSequenceClassification, LLaMATokenizer
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torch.utils.data import Dataset, DataLoader
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import StandardScaler
 
 # Load the data
 data = pd.read_csv('BANKNIFTY_OPTION_CHAIN_data.csv')
 
-# Preprocess the data
-tokenizer = LLaMATokenizer.from_pretrained('llama-2-7b')
-model = LLaMAForSequenceClassification.from_pretrained('llama-2-7b', num_labels=2)
+# Select the numerical features for LSTM
+numerical_features = ['open', 'high', 'low', 'close', 'volume', 'oi']
 
-# Fine-tune the model on the dataset
-train_texts, val_texts, train_labels, val_labels = train_test_split(data['text'], data['label'], test_size=0.2, random_state=42)
+# Standardize the features
+scaler = StandardScaler()
+data[numerical_features] = scaler.fit_transform(data[numerical_features])
 
-train_encodings = tokenizer(train_texts, truncation=True, padding=True)
-val_encodings = tokenizer(val_texts, truncation=True, padding=True)
+# Create a custom dataset class for our data
+class BankNiftyDataset(Dataset):
+    def __init__(self, data, seq_len, numerical_features):
+        self.data = data
+        self.seq_len = seq_len
+        self.numerical_features = numerical_features
 
-train_dataset = Dataset(train_encodings, train_labels)
-val_dataset = Dataset(val_encodings, val_labels)
+    def __len__(self):
+        return len(self.data) - self.seq_len
 
-training_args = TrainingArguments(
-    output_dir='./results',          # output directory
-    num_train_epochs=3,              # total # of training epochs
-    per_device_train_batch_size=16,  # batch size per device during training
-    per_device_eval_batch_size=64,   # batch size for evaluation
-    warmup_steps=500,                # number of warmup steps for learning rate scheduler
-    weight_decay=0.01,               # strength of weight decay
-    logging_dir='./logs',            # directory for storing logs
-)
+    def __getitem__(self, idx):
+        seq_data = self.data.iloc[idx:idx+self.seq_len][self.numerical_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)
+        }
 
-trainer = Trainer(
-    model=model,                         # the instantiated model
-    args=training_args,                  # training arguments
-    train_dataset=train_dataset,         # training dataset
-    eval_dataset=val_dataset             # evaluation dataset
-)
+# Create data loaders for training and testing
+seq_len = 10
+batch_size = 32
+train_data, val_data = train_test_split(data, test_size=0.2, random_state=42)
+train_dataset = BankNiftyDataset(train_data, seq_len, numerical_features)
+val_dataset = BankNiftyDataset(val_data, seq_len, numerical_features)
+train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
+val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=False)
 
-trainer.train()
+# Define the LSTM-RNN model
+class LSTMModel(nn.Module):
+    def __init__(self, input_dim, hidden_dim, output_dim):
+        super(LSTMModel, self).__init__()
+        self.hidden_dim = hidden_dim
+        self.lstm = nn.LSTM(input_dim, hidden_dim, num_layers=1, batch_first=True)
+        self.fc = nn.Linear(hidden_dim, output_dim)
 
-# Use the fine-tuned model to generate strategies
+    def forward(self, x):
+        h0 = torch.zeros(1, x.size(0), self.hidden_dim).to(x.device)
+        c0 = torch.zeros(1, x.size(0), self.hidden_dim).to(x.device)
+
+        out, _ = self.lstm(x, (h0, c0))
+        out = self.fc(out[:, -1, :])
+        return out
+
+# Initialize the model, optimizer, and loss function
+input_dim = len(numerical_features)  # Number of numerical features
+model = LSTMModel(input_dim=input_dim, hidden_dim=128, output_dim=1)
+optimizer = optim.Adam(model.parameters(), lr=0.001)
+criterion = nn.MSELoss()
+
+# Train the model
+for i in range(10):
+    model.train()
+    for batch in train_loader:
+        features = batch['features']
+        label = batch['label'].unsqueeze(1)
+
+        optimizer.zero_grad()
+        output = model(features)
+        loss = criterion(output, label)
+        loss.backward()
+        optimizer.step()
+
+    # Evaluate the model on the validation set
+    model.eval()
+    total_loss = 0
+    with torch.no_grad():
+        for batch in val_loader:
+            features = batch['features']
+            label = batch['label'].unsqueeze(1)
+            output = model(features)
+            loss = criterion(output, label)
+            total_loss += loss.item()
+    print(f'Iteration {i+1}, Val Loss: {total_loss / len(val_loader)}')
+
+# Use the final trained model to generate strategies
 def generate_strategies(data):
-    inputs = tokenizer(data['text'], return_tensors='pt')
-    outputs = model(**inputs)
-    logits = outputs.logits
-    strategies = torch.argmax(logits, dim=1)
-    return strategies
+    seq_data = data.iloc[-seq_len:][numerical_features].values
+    features = torch.tensor(seq_data, dtype=torch.float32).unsqueeze(0)  # Add batch dimension
+    output = model(features)
+    return output.item()
 
 strategies = generate_strategies(data)
-
-# Print the strategies
-print(strategies)
+print(f'Suggested strategy output: {strategies}')