Initial Commit

app.py

@@ -0,0 +1,52 @@
+import torch
+import gradio as gr
+import numpy as np
+from src.model import LSTM  
+
+# Load the model
+device = 'cuda' if torch.cuda.is_available() else 'cpu'
+model_path = "./water_forecast_8.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):
+   
+    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(inputs) != 3:  
+        return {"error": "Structured data should have 3 years of data."}
+
+
+
+    inputs = torch.tensor(inputs, dtype=torch.float32)
+    predictions = model(inputs).cpu().detach().numpy()
+
+    with torch.no_grad():
+        output = [np.exp(prediction) - 1 for prediction in predictions]
+        return output
+    # Get model output
+
+    return {"error" : "Does not contain the torch model grad"}
+
+# Configure Gradio interface
+inputs = [
+    gr.Number(label="State Index"),  # Numeric input for state index
+    gr.Number(label="Target Year"),  # Numeric input for target year
+    gr.JSON(label="Structured Data")  # JSON input for structured data
+]
+
+outputs = gr.JSON(label="Prediction")
+
+# Set up the Gradio Interface
+interface = gr.Interface(fn=predict_water_usage, inputs=inputs, outputs=outputs)
+
+# Launch Gradio
+if __name__ == "__main__":
+    interface.launch(show_error=True)

requirements.txt

@@ -0,0 +1,8 @@
+torch
+fastapi
+pydantic
+numpy
+pandas
+scikit-learn
+uvicorn
+gradio

src/data.py

@@ -0,0 +1,99 @@
+import os
+import pandas as pd
+import numpy as np
+import torch
+from torch.utils.data import Dataset, DataLoader
+from sklearn.preprocessing import StandardScaler
+
+class WaterDataset(Dataset):
+    def __init__(self, sequence_length=5, transform=None):
+        """
+        Initializes the dataset by loading LUC, population, and usage data, merging them 
+        based on year and state, and creating sequences of data for training.
+        
+        Args:
+            sequence_length (int): The length of each data sequence for time series forecasting.
+            transform (callable, optional): Optional transform to be applied on a sample.
+        """
+        self.sequence_length = sequence_length
+        self.luc = pd.read_csv('data/luc.csv')
+        self.population = pd.read_csv('data/population.csv')
+        self.usage = pd.read_csv('data/usage.csv')
+        self.transform = transform
+
+        self.years = sorted(set(self.usage['Year']))
+        self.states = sorted(set(self.usage['State']))
+        self.all_years = sorted(set(self.population['Year']))
+
+        self.df = self.merge_data()
+        self.x, self.y = self.create_sequence()
+        
+        self.scaler = StandardScaler()
+        self.x = self.scaler.fit_transform(self.x.reshape(-1, self.x.shape[-1])).reshape(self.x.shape)
+
+    def merge_data(self):
+        """
+        Merges land use classification (LUC) and population data based on year and state.
+        
+        Returns:
+            pd.DataFrame: A DataFrame with merged data on population, urban/rural breakdown, 
+                          and LUC attributes for each year and state.
+        """
+        merged_data = []
+
+        for year, state in [(y, s) for y in self.all_years for s in self.states]:
+            population_data = self.population[(self.population['Year'] == year)]
+            luc_data = self.luc[(self.luc['Year'] == year) & (self.luc['State'] == state)]
+
+            if not population_data.empty and not luc_data.empty:
+                combined_data = {
+                    'year': year,
+                    'state': state,
+                    'population': population_data['Population'].values[0],
+                    'urban_population': population_data['Urban Population'].values[0],
+                    'rural_population': population_data['Rural Population'].values[0],
+                    'forest': luc_data['Forest'].values[0],
+                    'barren': luc_data['Barren'].values[0],
+                    'others': luc_data['Others'].values[0],
+                    'fallow': luc_data['Fallow'].values[0],
+                    'cropped': luc_data['Cropped'].values[0]
+                }
+                merged_data.append(combined_data)
+
+        return pd.DataFrame(merged_data)
+
+    def create_sequence(self):
+        """
+        Creates sequences of input data and their corresponding labels for training.
+        
+        Returns:
+            tuple: Two numpy arrays, one for data sequences and one for label sequences.
+        """
+        data_sequences, label_sequences = [], []
+        missing_sequences = {state: [] for state in self.states}
+
+        for state in self.states:
+            state_data = self.df[self.df['state'] == state].sort_values('year')
+            usage_state_data = self.usage[self.usage['State'] == state]
+
+            for i in range(len(state_data) - self.sequence_length):
+                sequence = state_data.iloc[i:i + self.sequence_length]
+                year = sequence['year'].values[-1] + 1
+
+                usage_label = usage_state_data[usage_state_data['Year'] == year]
+                
+                if len(sequence) == self.sequence_length and not usage_label.empty:
+                    data_sequences.append(sequence[['population', 'urban_population', 'rural_population', 
+                                                    'forest', 'barren', 'others', 'fallow', 'cropped']].values.astype(np.float32))
+                    label_sequences.append(usage_label[['Domestic', 'Industrial', 'Irrigation']].values[0].astype(np.float32))
+                else:
+                    missing_sequences[state].append(year)
+
+        return np.array(data_sequences), np.array(label_sequences)
+
+    def __len__(self):
+        return len(self.x)
+
+    def __getitem__(self, index):
+        return (torch.tensor(self.x[index], dtype=torch.float32), 
+                torch.tensor(self.y[index], dtype=torch.float32))

src/model.py

@@ -0,0 +1,122 @@
+import torch
+import torch.nn as nn
+import math
+#from transformers import AutoModelForCausalLM, AutoTokenizer
+
+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.relu(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)
+            
+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_()
+        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))
+        pe[:, 0::2] = torch.sin(position * div_term)
+        pe[:, 1::2] = torch.cos(position * div_term)
+        pe = pe.unsqueeze(0).transpose(0, 1)
+        self.register_buffer('pe', pe)
+
+    def forward(self, x):
+        return x + self.pe[:x.size(0), :]
+    
+class Transformer(nn.Module):
+    def _init_(self):
+        super(Transformer,self)._init_()

water_forecast_8.pt

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