file added and deleted

app.py

@@ -1,87 +0,0 @@
-import streamlit as st
-import torch
-import numpy as np
-import matplotlib.pyplot as plt
-import seaborn as sns
-from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
-import joblib
-
-# Load the model and scaler
-def load_model(model_path, scaler_path):
-    model_state = torch.load(model_path)
-    model = LSTMPredictor(
-        input_dim=model_state['model_architecture']['input_dim'],
-        hidden_dim=model_state['model_architecture']['hidden_dim'],
-        output_dim=model_state['model_architecture']['output_dim'],
-        forecast_horizon=model_state['model_architecture']['forecast_horizon'],
-        n_layers=model_state['model_architecture']['n_layers'],
-        dropout=model_state['model_architecture']['dropout']
-    )
-    model.load_state_dict(model_state['model_state_dict'])
-    scaler = joblib.load(scaler_path)
-    return model, scaler
-
-# Prepare Streamlit interface
-st.title("Crisis Severity Prediction Model Evaluation")
-st.sidebar.title("Model Evaluation Dashboard")
-
-# Upload model and scaler files
-model_file = st.sidebar.file_uploader("Upload Trained Model", type=["pth", "pt"])
-scaler_file = st.sidebar.file_uploader("Upload Scaler File", type=["pkl"])
-
-if model_file and scaler_file:
-    # Load model and scaler
-    model, scaler = load_model(model_file, scaler_file)
-
-    # Example of how to prepare test data (adjust for actual data)
-    X_test = np.array([[...]])  # Test data input
-    y_test = np.array([[...]])  # Actual target values
-    
-    # Scale the test data using the loaded scaler
-    scaled_X_test = scaler.transform(X_test)
-
-    # Convert to tensor
-    X_test_tensor = torch.FloatTensor(scaled_X_test)
-
-    # Get predictions
-    model.eval()
-    with torch.no_grad():
-        predictions = model(X_test_tensor)
-
-    # Evaluate and display metrics (using first 3 months for example)
-    y_true = y_test
-    y_pred = predictions.numpy()
-    
-    metrics = {}
-    for month in range(3):  # Assuming forecast for 3 months
-        month_metrics = {
-            'mse': mean_squared_error(y_true[:, month], y_pred[:, month]),
-            'rmse': np.sqrt(mean_squared_error(y_true[:, month], y_pred[:, month])),
-            'mae': mean_absolute_error(y_true[:, month], y_pred[:, month]),
-            'r2': r2_score(y_true[:, month], y_pred[:, month])
-        }
-        metrics[f'month_{month+1}'] = month_metrics
-
-    # Display metrics
-    st.subheader("Model Performance Metrics:")
-    for month, month_metrics in metrics.items():
-        st.write(f"{month.upper()}:")
-        for metric_name, metric_value in month_metrics.items():
-            st.write(f"{metric_name.upper()}: {metric_value:.4f}")
-
-    # Visualization (actual vs predicted)
-    fig, ax = plt.subplots(figsize=(10, 6))
-    for month in range(3):
-        ax.scatter(y_true[:, month], y_pred[:, month], alpha=0.5, label=f'Month {month+1}')
-    ax.plot([0, 5], [0, 5], 'r--')
-    ax.set_xlabel('Actual Severity Index')
-    ax.set_ylabel('Predicted Severity Index')
-    ax.set_title('Actual vs Predicted')
-    ax.legend()
-
-    st.pyplot(fig)
-
-    # Option to download plot
-    st.download_button("Download Evaluation Plot", "evaluation_plot.png")
-else:
-    st.warning("Please upload both the trained model and scaler files.")

inference.py

@@ -1,24 +1,85 @@
-import requests
-import json
-import os
+# import requests
+# import json
+# import os
 
-# Your Hugging Face model URL
-API_URL = "sayyedAhmed/Crisis_Severity_Predictor_LSTM"  # Replace with your model's URL
+# # Your Hugging Face model URL
+# API_URL = "sayyedAhmed/Crisis_Severity_Predictor_LSTM"  # Replace with your model's URL
 
-# Load your Hugging Face API token
-API_KEY = os.getenv("HF_API_KEY")  # Ensure the API key is stored in the environment or replace with the actual key
+# # Load your Hugging Face API token
+# API_KEY = os.getenv("HF_API_KEY")  # Ensure the API key is stored in the environment or replace with the actual key
 
-headers = {
-    "Authorization": f"Bearer {API_KEY}",
-    "Content-Type": "application/json"
-}
+# headers = {
+#     "Authorization": f"Bearer {API_KEY}",
+#     "Content-Type": "application/json"
+# }
 
-payload = {
-    "inputs": "Your test input here"  # Replace this with the actual input for your model
-}
+# payload = {
+#     "inputs": "Your test input here"  # Replace this with the actual input for your model
+# }
 
-# Make the POST request to Hugging Face Inference API
-response = requests.post(API_URL, headers=headers, json=payload)
+# # Make the POST request to Hugging Face Inference API
+# response = requests.post(API_URL, headers=headers, json=payload)
+
+# # Print the response (the predictions)
+# print(response.json())
+import torch
+import numpy as np
+
+# Define the model architecture (this should match the one used during training)
+class LSTMPredictor(torch.nn.Module):
+    def __init__(self, input_dim, hidden_dim, output_dim, forecast_horizon, n_layers, dropout):
+        super(LSTMPredictor, self).__init__()
+        self.lstm = torch.nn.LSTM(input_dim, hidden_dim, n_layers, dropout=dropout, batch_first=True)
+        self.fc = torch.nn.Linear(hidden_dim, output_dim)
+        self.forecast_horizon = forecast_horizon
+
+    def forward(self, x):
+        # Forward pass through LSTM
+        lstm_out, _ = self.lstm(x)
+        # Only get the output from the last time step
+        out = self.fc(lstm_out[:, -1, :])
+        return out
+
+# Load the model
+def load_model(model_path):
+    model_state = torch.load(model_path)
+    model = LSTMPredictor(
+        input_dim=model_state['model_architecture']['input_dim'],
+        hidden_dim=model_state['model_architecture']['hidden_dim'],
+        output_dim=model_state['model_architecture']['output_dim'],
+        forecast_horizon=model_state['model_architecture']['forecast_horizon'],
+        n_layers=model_state['model_architecture']['n_layers'],
+        dropout=model_state['model_architecture']['dropout']
+    )
+    model.load_state_dict(model_state['model_state_dict'])
+    model.eval()  # Set model to evaluation mode
+    return model
+
+# Inference function
+def predict(model, features):
+    # Convert input features to tensor
+    input_tensor = torch.FloatTensor(features)
+    
+    # Get model prediction
+    with torch.no_grad():
+        predictions = model(input_tensor).numpy()  # No gradients needed for inference
+    
+    return predictions.tolist()
+
+# Main function to load the model and make predictions
+if __name__ == "__main__":
+    # Load the trained model
+    model = load_model('lstm_crisis_severity_predictor_20241116_092126.pt')  # Replace with actual model path
+
+    # Example input data (features) - Replace with actual features
+    test_features = np.array([[1.23, 4.56, 7.89, 10.11]])  # Example test features
+    
+    # Reshape for LSTM: (batch_size, seq_len, input_dim)
+    test_features = test_features.reshape((test_features.shape[0], 1, test_features.shape[1]))
+
+    # Get predictions
+    predictions = predict(model, test_features)
+    
+    # Output predictions
+    print("Predictions:", predictions)
 
-# Print the response (the predictions)
-print(response.json())

requirements.txt

@@ -23,4 +23,5 @@ python-dotenv
 pytest
 joblib
 plotly
-requests
+requests
+streamlit