Intial Commit

app.py

@@ -0,0 +1,70 @@
+import torch
+import gradio as gr
+import pickle
+import numpy as np
+from sklearn.preprocessing import StandardScaler
+
+# Load the model and scalers
+device = 'cuda' if torch.cuda.is_available() else 'cpu'
+model_path = 'model/res_1.pt'
+scaler_x_path = 'data/scaler_x.pkl'
+scaler_y_path = 'data/scaler_y.pkl'
+
+# Load the model
+model = torch.load(model_path, map_location=device)
+model.eval()
+
+# Load the scalers
+with open(scaler_x_path, 'rb') as f:
+    scaler_x = pickle.load(f)
+
+with open(scaler_y_path, 'rb') as f:
+    scaler_y = pickle.load(f)
+
+# Define the prediction function
+def predict(inputs):
+    """
+    Predict future values based on input features.
+
+    Inputs: List of lists, where each inner list contains 
+            ['Current Level', 'Current Storage', 'Inflow', 'Outflow'] values.
+    """
+    try:
+        # Ensure inputs are in the correct shape
+        inputs = np.array(inputs).reshape(-1, 4)
+        
+        # Scale inputs using the pre-loaded scaler
+        inputs_scaled = scaler_x.transform(inputs)
+
+        # Convert to tensor and move to the correct device
+        inputs_tensor = torch.tensor(inputs_scaled, dtype=torch.float32).to(device)
+
+        # Make predictions
+        with torch.no_grad():
+            predictions = model(inputs_tensor).cpu().numpy()
+
+        # Rescale predictions back to the original scale
+        predictions_original_scale = scaler_y.inverse_transform(predictions)
+
+        return {"predictions": predictions_original_scale.flatten().tolist()}
+
+    except Exception as e:
+        return {"error": str(e)}
+
+# Configure Gradio interface
+inputs = gr.Dataframe(
+    headers=["Current Level", "Current Storage", "Inflow", "Outflow"],
+    type="numpy",
+    row_count=5,
+    col_count=4,
+    label="Input Features (5 rows with 4 columns)"
+)
+
+outputs = gr.JSON(label="Predicted Values")
+
+# Set up the Gradio Interface
+interface = gr.Interface(fn=predict, inputs=inputs, outputs=outputs)
+
+# Launch Gradio
+if __name__ == "__main__":
+    interface.launch(show_error=True)

requirements.txt

@@ -0,0 +1,5 @@
+torch       
+gradio     
+numpy      
+scikit-learn
+pickle-mixin

res_1.pt

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

scaler_x.pkl

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

scaler_y.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:50fcea07aa11ebb9bfb18a6beb9ba438f4d9c3f5f829b5615e46ec966e04718e
+size 497

src/model.py

@@ -0,0 +1,63 @@
+import torch.nn as nn
+
+
+
+class LSTM(nn.Module):
+    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 = Linear(lstm_layer_sizes[2], self.linear_layer_size,output_size)
+
+        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.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,hidden_sizes,output_size):
+        super(Linear,self)._init_()
+        
+        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.output(out)
+        return out
+    
+    def initialize_weights(self, layer):
+        if isinstance(layer, nn.Linear):
+            nn.init.xavier_uniform_(layer.weight)
+            nn.init.zeros_(layer.bias)