Upgraded model

andhra_forecast.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:199336d9e211a73d273cc588765bf1dbbfb42451ddc28c5e49b133c42dd11d14
+size 258558

app.py

@@ -1,42 +1,39 @@
 import torch
 import gradio as gr
 import numpy as np
-from src.model import LSTM  # Adjust to your model path
+from src.model import LSTM  
 
 # Load the model
 device = 'cuda' if torch.cuda.is_available() else 'cpu'
-model_path = "./water_forecast_2.pth"  # Path to the model file
-model = LSTM(input_size=8, lstm_layer_sizes=[128, 128, 128], output_size=3).to(device)
-model.load_state_dict(torch.load(model_path, map_location=device, weights_only=True))
+model_path = "./andhra_forecast.pt" 
+model = torch.load(model_path, map_location=device)
 model.eval()
-
 # Define the prediction function
 def predict_water_usage(state_idx, target_year, structured_data):
-    # structured_data is now a dictionary directly, no need to parse it
-    if len(structured_data) < 5:
-        return {"error": "Structured data must include 5 years of data for the specified state."}
+   
+    if len(structured_data) < 3:
+        return {"error": "Structured data must include 3 years of data for the specified state."}
 
     # Convert structured data for model input (extract values for model)
     data_values = [list(values) for values in structured_data.values()]
+    inputs = [[np.log(value + 1) for value in sublist] for sublist in data_values]
     
     
     # Ensure the data has the right shape for the model
-    if len(data_values) != 5:  # Check if there are exactly 5 years of data
-        return {"error": "Structured data should have 5 years of data."}
+    if len(inputs) != 3:  
+        return {"error": "Structured data should have 3 years of data."}
 
-    # Check if data_values contains only numeric data
-    for year_data in data_values:
-        if not all(isinstance(val, (int, float)) for val in year_data):
-            return {"error": "All values in structured data should be numeric."}
 
-    # Convert data_values to tensor
-    tensor_data = torch.tensor(data_values, dtype=torch.float32).to(device)
 
-    # Get model output
+    inputs = torch.tensor(inputs, dtype=torch.float32)
+    predictions = model(inputs).cpu().detach().numpy()
+
     with torch.no_grad():
-        output = model(tensor_data)
+        output = [np.exp(prediction) - 1 for prediction in predictions]
+        return output
+    # Get model output
 
-    return {"prediction": output.tolist()}
+    return {"error" : "Does not contain the torch model grad"}
 
 # Configure Gradio interface
 inputs = [

src/model.py

@@ -4,16 +4,19 @@ import math
 #from transformers import AutoModelForCausalLM, AutoTokenizer
 
 class LSTM(nn.Module):
-    def __init__(self, input_size, lstm_layer_sizes, output_size):
-        super(LSTM, self).__init__()
+    def _init_(self, input_size, lstm_layer_sizes,linear_layer_size, output_size):
+        super(LSTM, self)._init_()
 
         self.input_size = input_size
+        self.linear_layer_size = linear_layer_size
 
         self.lstm_layer_1 = nn.LSTM(input_size, lstm_layer_sizes[0], batch_first=True)
         self.lstm_layer_2 = nn.LSTM(lstm_layer_sizes[0], lstm_layer_sizes[1], batch_first=True)
         self.lstm_layer_3 = nn.LSTM(lstm_layer_sizes[1], lstm_layer_sizes[2], batch_first=True)
 
-        self.fc = nn.Linear(lstm_layer_sizes[2], output_size)
+        self.fc = Linear(lstm_layer_sizes[2], self.linear_layer_size,output_size)
+
+        self.apply(self.initialize_weights)
 
     def forward(self, x):
 
@@ -25,25 +28,84 @@ class LSTM(nn.Module):
         out = self.fc(out)
         return out
     
-    
+    def initialize_weights(self, layer):
+        if isinstance(layer, nn.Linear):
+            nn.init.xavier_uniform_(layer.weight)
+            nn.init.zeros_(layer.bias)
+        elif isinstance(layer, nn.LSTM):
+            for name, param in layer.named_parameters():
+                if 'weight' in name:
+                    nn.init.xavier_uniform_(param.data)
+                elif 'bias' in name:
+                    nn.init.zeros_(param.data)
+
 class Linear(nn.Module):
-    def __init__(self,input_size,output_size):
-        super(Linear,self).__init__()
+    def _init_(self,input_size,hidden_sizes,output_size):
+        super(Linear,self)._init_()
         
-        self.relu =nn.relu()
-        self.input = nn.Linear(input_size,1024)
-        self.fc = nn.Linear(1024,256)
-        self.output = nn.Linear(256,output_size)
+        self.relu =nn.ReLU()
+        self.sigmoid =nn.Sigmoid()
+        self.tanh = nn.Tanh()
+        self.input = nn.Linear(input_size,hidden_sizes[0])
+        self.fc = nn.Linear(hidden_sizes[0],hidden_sizes[1])
+        self.output = nn.Linear(hidden_sizes[1],output_size)
+
+        self.apply(self.initialize_weights)
 
     def forward(self,x):
         out = self.relu(self.input(x))
         out = self.relu(self.fc(out))
         out = self.relu(self.output(out))
-        return out[:, -1, :]
+        return out
+    
+    def initialize_weights(self, layer):
+        if isinstance(layer, nn.Linear):
+            nn.init.xavier_uniform_(layer.weight)
+            nn.init.zeros_(layer.bias)
+            
+class LUCLSTM(nn.Module):
+    def _init_(self, input_size, lstm_layer_sizes, output_size):
+        super(LUCLSTM, self)._init_()
+
+        self.input_size = input_size
+
+        self.lstm_layer_1 = nn.LSTM(input_size, lstm_layer_sizes[0], batch_first=True)
+        self.lstm_layer_2 = nn.LSTM(lstm_layer_sizes[0], lstm_layer_sizes[1], batch_first=True)
+        self.lstm_layer_3 = nn.LSTM(lstm_layer_sizes[1], lstm_layer_sizes[2], batch_first=True)
+
+        self.fc = nn.Linear(lstm_layer_sizes[2],64)
+        self.fc2 = nn.Linear(64,output_size)
+        self.tanh = nn.Tanh()
+        self.relu =nn.ReLU()
+
+        self.apply(self.initialize_weights)
+
+    def forward(self, x):
+
+        out, (hn_1, cn_1) = self.lstm_layer_1(x)
+        out, (hn_2, cn_2) = self.lstm_layer_2(out)
+        out, (hn_3, cn_3) = self.lstm_layer_3(out)
+
+        out = hn_3[-1]
+        out = self.tanh(self.fc(out))
+        out = self.fc2(out)
+        return out
+    
+    def initialize_weights(self, layer):
+        if isinstance(layer, nn.Linear):
+            nn.init.xavier_uniform_(layer.weight)
+            nn.init.zeros_(layer.bias)
+        elif isinstance(layer, nn.LSTM):
+            for name, param in layer.named_parameters():
+                if 'weight' in name:
+                    nn.init.xavier_uniform_(param.data)
+                elif 'bias' in name:
+                    nn.init.zeros_(param.data)
+    
     
 class PositionalEncoding(nn.Module):
-    def __init__(self, dim, max_len=300):
-        super(PositionalEncoding, self).__init__()
+    def _init_(self, dim, max_len=300):
+        super(PositionalEncoding, self)._init_()
         pe = torch.zeros(max_len, dim)
         position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)
         div_term = torch.exp(torch.arange(0, dim, 2).float() * (-math.log(10000.0) / dim))
@@ -56,5 +118,5 @@ class PositionalEncoding(nn.Module):
         return x + self.pe[:x.size(0), :]
     
 class Transformer(nn.Module):
-    def __init__(self):
-        super(Transformer,self).__init__()
+    def _init_(self):
+        super(Transformer,self)._init_()