Upload 3 files

app.py

@@ -0,0 +1,176 @@
+import streamlit as st
+import pandas as pd
+import numpy as np
+import torch
+import torch.nn as nn
+import pickle
+import plotly.express as px
+from sklearn.preprocessing import MinMaxScaler
+
+# Define the LSTM model class (same as in train_model.py)
+class LSTMModel(nn.Module):
+    def __init__(self, input_size=1, hidden_size=50, num_layers=2):
+        super(LSTMModel, self).__init__()
+        self.hidden_size = hidden_size
+        self.num_layers = num_layers
+        self.lstm = nn.LSTM(input_size, hidden_size, num_layers, batch_first=True)
+        self.fc = nn.Linear(hidden_size, 1)
+
+    def forward(self, x):
+        h0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size)
+        c0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size)
+        out, _ = self.lstm(x, (h0, c0))
+        out = self.fc(out[:, -1, :])
+        return out
+
+# Load the pre-trained model and scaler
+@st.cache_resource
+def load_model_and_scaler():
+    with open("model.pkl", "rb") as f:
+        saved_data = pickle.load(f)
+    model = saved_data['model']
+    scaler = saved_data['scaler']
+    model.eval()
+    return model, scaler
+
+# Load and preprocess data
+@st.cache_data
+def load_and_preprocess_data():
+    df = pd.read_excel("SmartLab_Consumables_Forecast_Sample.xlsx")
+    df['Usage_Date'] = pd.to_datetime(df['Usage_Date'])
+    return df
+
+# Function to generate forecasts using the model
+def generate_forecasts(df, model, scaler, sequence_length=10):
+    consumables = df['Consumable_Name'].unique()
+    forecasts = []
+    
+    for consumable in consumables:
+        consumable_data = df[df['Consumable_Name'] == consumable].set_index('Usage_Date')
+        consumable_data = consumable_data['Quantity_Used'].resample('D').sum().fillna(0)
+        if len(consumable_data) < sequence_length:
+            continue
+            
+        # Scale the data
+        scaled_data = scaler.transform(consumable_data.values.reshape(-1, 1))
+        
+        # Prepare the last sequence for prediction
+        last_sequence = scaled_data[-sequence_length:]
+        last_sequence = torch.FloatTensor(last_sequence).unsqueeze(0)  # Shape: (1, sequence_length, 1)
+        
+        # Predict future usage
+        with torch.no_grad():
+            pred_7 = model(last_sequence).numpy()
+            pred_14 = model(last_sequence).numpy() * 2  # Simplified scaling for 14 days
+            pred_30 = model(last_sequence).numpy() * 4  # Simplified scaling for 30 days
+        
+        # Inverse transform predictions
+        pred_7 = scaler.inverse_transform(pred_7)[0][0]
+        pred_14 = scaler.inverse_transform(pred_14)[0][0]
+        pred_30 = scaler.inverse_transform(pred_30)[0][0]
+        
+        # Add to forecasts
+        latest_date = consumable_data.index.max()
+        for _, row in df[df['Consumable_Name'] == consumable].iterrows():
+            forecasts.append({
+                'Lab_ID': row['Lab_ID'],
+                'Consumable_Name': consumable,
+                'Usage_Date': latest_date,
+                'Quantity_Used': row['Quantity_Used'],
+                'Current_Stock': row['Current_Stock'],
+                'Reorder_Threshold': row['Reorder_Threshold'],
+                'Forecast_7_Days': pred_7,
+                'Forecast_14_Days': pred_14,
+                'Forecast_30_Days': pred_30,
+                'Reorder_Recommended': row['Current_Stock'] < row['Reorder_Threshold'] or (row['Current_Stock'] - pred_30) < row['Reorder_Threshold'],
+                'Order_Suggestion': max(pred_30 - row['Current_Stock'] + row['Reorder_Threshold'], 0) if (row['Current_Stock'] < row['Reorder_Threshold'] or (row['Current_Stock'] - pred_30) < row['Reorder_Threshold']) else 0,
+                'Forecast_Generated_Date': pd.to_datetime('2025-06-06')
+            })
+    
+    return pd.DataFrame(forecasts)
+
+# Streamlit app
+def main():
+    st.set_page_config(page_title="SmartLab Consumables Forecasting", layout="wide")
+    st.title("SmartLab Consumables Forecasting Dashboard")
+    st.markdown("Forecast consumable usage, monitor stock thresholds, and get order suggestions.")
+
+    # Load model and data
+    with st.spinner("Loading model and data..."):
+        model, scaler = load_model_and_scaler()
+        df = load_and_preprocess_data()
+        forecast_df = generate_forecasts(df, model, scaler)
+
+    # Sidebar filters
+    st.sidebar.header("Filters")
+    labs = ['All Labs'] + sorted(forecast_df['Lab_ID'].unique().tolist())
+    selected_lab = st.sidebar.selectbox("Filter by Lab", labs)
+    
+    consumables = ['All Consumables'] + sorted(forecast_df['Consumable_Name'].unique().tolist())
+    selected_consumable = st.sidebar.selectbox("Filter by Consumable", consumables)
+
+    # Apply filters
+    filtered_df = forecast_df.copy()
+    if selected_lab != 'All Labs':
+        filtered_df = filtered_df[filtered_df['Lab_ID'] == selected_lab]
+    if selected_consumable != 'All Consumables':
+        filtered_df = filtered_df[filtered_df['Consumable_Name'] == selected_consumable]
+
+    # Forecast Overview Chart
+    st.header("Forecast Overview")
+    chart_data = filtered_df.groupby(['Lab_ID', 'Consumable_Name']).agg({
+        'Forecast_7_Days': 'mean',
+        'Forecast_14_Days': 'mean',
+        'Forecast_30_Days': 'mean'
+    }).reset_index()
+    chart_data['name'] = chart_data['Lab_ID'] + ' - ' + chart_data['Consumable_Name']
+    chart_data = chart_data.melt(id_vars=['name'], value_vars=['Forecast_7_Days', 'Forecast_14_Days', 'Forecast_30_Days'],
+                                 var_name='Forecast_Period', value_name='Forecasted_Usage')
+    
+    fig = px.line(chart_data, x='name', y='Forecasted_Usage', color='Forecast_Period',
+                  labels={'Forecasted_Usage': 'Forecasted Usage', 'name': 'Lab - Consumable'},
+                  color_discrete_map={
+                      'Forecast_7_Days': '#8884d8',
+                      'Forecast_14_Days': '#82ca9d',
+                      'Forecast_30_Days': '#ff7300'
+                  })
+    fig.update_layout(
+        xaxis_title="Lab - Consumable",
+        yaxis_title="Forecasted Usage",
+        xaxis_tickangle=45,
+        margin=dict(b=150),
+        legend_title_text='Forecast Period'
+    )
+    st.plotly_chart(fig, use_container_width=True)
+
+    # Inventory Status Table
+    st.header("Inventory Status")
+    display_df = filtered_df.copy()
+    display_df['Reorder_Recommended'] = display_df['Reorder_Recommended'].apply(lambda x: 'Yes 🚩' if x else 'No')
+    display_df['Order_Suggestion'] = display_df['Order_Suggestion'].apply(lambda x: f"{x:.0f} units" if x > 0 else "None")
+    display_df = display_df[[
+        'Lab_ID', 'Consumable_Name', 'Current_Stock', 'Reorder_Threshold',
+        'Forecast_7_Days', 'Forecast_14_Days', 'Forecast_30_Days',
+        'Reorder_Recommended', 'Order_Suggestion'
+    ]]
+    # Apply conditional styling
+    def highlight_reorder(row):
+        return ['background-color: #fee2e2' if row['Reorder_Recommended'] == 'Yes 🚩' else '' for _ in row]
+    styled_df = display_df.style.apply(highlight_reorder, axis=1).format({
+        'Forecast_7_Days': '{:.2f}',
+        'Forecast_14_Days': '{:.2f}',
+        'Forecast_30_Days': '{:.2f}'
+    })
+    st.dataframe(styled_df, use_container_width=True)
+
+    # Interesting Fact
+    st.header("Interesting Fact")
+    max_forecast = chart_data[chart_data['Forecast_Period'] == 'Forecast_30_Days'].nlargest(1, 'Forecasted_Usage')
+    if not max_forecast.empty:
+        st.info(
+            f"Did you know? The consumable with the highest 30-day forecast is **{max_forecast['name'].iloc[0]}** "
+            f"at **{max_forecast['Forecasted_Usage'].iloc[0]:.2f} units**, indicating a significant upcoming demand!"
+        )
+
+if __name__ == "__main__":
+    main()

model.pkl

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

requirements.txt

@@ -0,0 +1,7 @@
+pandas
+numpy
+torch
+scikit-learn
+openpyxl
+streamlit
+plotly