Update app.py

app.py

@@ -2,7 +2,6 @@ import streamlit as st
 import pandas as pd
 from prophet import Prophet
 from datetime import datetime, timedelta
-import numpy as np
 import plotly.graph_objects as go
 
 # Prepare data for Prophet
@@ -11,130 +10,124 @@ def prepare_prophet_data(usage_series):
     start_date = end_date - timedelta(days=len(usage_series) - 1)
     dates = [start_date + timedelta(days=i) for i in range(len(usage_series))]
     
-    prophet_df = pd.DataFrame({
-        'ds': dates,
-        'y': usage_series
-    })
-    return prophet_df
-
-# Train model with sensitivity option
-def train_model_with_usage(usage_series, sensitivity):
-    prophet_df = prepare_prophet_data(usage_series)
-    
-    # Set changepoint_prior_scale based on selected sensitivity
-    if sensitivity == "Low":
-        cps = 0.01
-    elif sensitivity == "Medium":
-        cps = 0.1
-    else:  # High
-        cps = 0.5
-    
+    return pd.DataFrame({'ds': dates, 'y': usage_series})
+
+# Train model with fixed low sensitivity
+def train_model(usage_series):
+    df = prepare_prophet_data(usage_series)
     model = Prophet(
         yearly_seasonality=False,
         weekly_seasonality=True,
         daily_seasonality=True,
-        changepoint_prior_scale=cps,
+        changepoint_prior_scale=0.05,  # Low sensitivity to recent changes
         changepoint_range=0.6
     )
-    model.fit(prophet_df)
+    model.fit(df)
     return model
 
-# Function to make forecasts
+# Forecast future usage
 def make_forecast(model, periods):
     future = model.make_future_dataframe(periods=periods)
     forecast = model.predict(future)
     return forecast, round(forecast['yhat'].tail(periods).sum())
 
-# Function to validate input
+# Validate input
 def validate_usage_series(usage_str):
     try:
-        usage_list = [float(x) for x in usage_str.split(',')]
-        if len(usage_list) != 60:
-            return None, "Usage series must contain exactly 60 values."
-        if any(x < 0 for x in usage_list):
+        usage = [float(x) for x in usage_str.split(',')]
+        if len(usage) != 60:
+            return None, "Please enter exactly 60 values."
+        if any(x < 0 for x in usage):
             return None, "Usage values must be non-negative."
-        return usage_list, None
+        return usage, None
     except:
-        return None, "Invalid usage series format. Please enter 60 comma-separated numbers."
+        return None, "Invalid format. Use 60 comma-separated numbers."
 
-# Main Streamlit app
+# Main app
 def main():
     st.title("SmartLab Consumables Forecast")
 
     st.header("Input Parameters")
     consumable_type = st.selectbox("Consumable Type", ['Filters', 'Reagents', 'Vials'])
-    usage_series = st.text_input("Last 60 Days Usage (comma-separated)", "")
+    usage_input = st.text_input("Last 60 Days Usage (comma-separated)", "")
     current_stock = st.number_input("Current Stock", min_value=0, value=0)
-    sensitivity = st.selectbox("Forecast Sensitivity", ['Low', 'Medium', 'High'])
 
     if st.button("Generate Forecast"):
-        usage_list, error = validate_usage_series(usage_series)
+        usage_series, error = validate_usage_series(usage_input)
         if error:
             st.error(error)
             return
 
-        try:
-            model = train_model_with_usage(usage_list, sensitivity)
-        except Exception as e:
-            st.error(f"Error training model: {str(e)}")
-            return
-
+        model = train_model(usage_series)
         forecast_df, forecast_7 = make_forecast(model, 7)
         _, forecast_14 = make_forecast(model, 14)
         _, forecast_30 = make_forecast(model, 30)
 
         st.header("Forecast Results")
-        st.write(f"**7-Day Forecast**: {forecast_7} units")
-        st.write(f"**14-Day Forecast**: {forecast_14} units")
-        st.write(f"**30-Day Forecast**: {forecast_30} units")
-
-        st.header("Threshold Alerts")
-        if current_stock < forecast_7:
-            st.warning(f"⚠️ Stock ({current_stock}) is below 7-day forecast ({forecast_7})")
-        if current_stock < forecast_14:
-            st.warning(f"⚠️ Stock ({current_stock}) is below 14-day forecast ({forecast_14})")
-        if current_stock < forecast_30:
-            st.warning(f"⚠️ Stock ({current_stock}) is below 30-day forecast ({forecast_30})")
-
-        st.header("Order Suggestions")
-        st.write(f"🛒 **Order for 7 Days**: {max(0, forecast_7 - current_stock)} units")
-        st.write(f"🛒 **Order for 14 Days**: {max(0, forecast_14 - current_stock)} units")
-        st.write(f"🛒 **Order for 30 Days**: {max(0, forecast_30 - current_stock)} units")
-
-        # Forecast Trend Visualization
-        st.header("Forecast Curve")
+        st.write(f"📊 **7-Day Forecast**: {forecast_7} units")
+        st.write(f"📊 **14-Day Forecast**: {forecast_14} units")
+        st.write(f"📊 **30-Day Forecast**: {forecast_30} units")
+
+        st.header("Threshold Alerts 🚨")
+        alert_7 = current_stock < forecast_7
+        alert_14 = current_stock < forecast_14
+        alert_30 = current_stock < forecast_30
+
+        if alert_7:
+            st.warning(f"🚩 Current stock ({current_stock}) is below 7-day forecast ({forecast_7})")
+        if alert_14:
+            st.warning(f"🚩 Current stock ({current_stock}) is below 14-day forecast ({forecast_14})")
+        if alert_30:
+            st.warning(f"🚩 Current stock ({current_stock}) is below 30-day forecast ({forecast_30})")
+
+        st.header("Order Suggestions 🛒")
+        st.write(f"➡️ **7 Days**: Order {max(0, forecast_7 - current_stock)} units")
+        st.write(f"➡️ **14 Days**: Order {max(0, forecast_14 - current_stock)} units")
+        st.write(f"➡️ **30 Days**: Order {max(0, forecast_30 - current_stock)} units")
+
+        # Forecast trend line
+        st.header("Forecast Trend")
         fig_curve = go.Figure()
         fig_curve.add_trace(go.Scatter(
             x=forecast_df['ds'],
             y=forecast_df['yhat'],
             mode='lines',
-            name='Forecasted Usage',
-            line=dict(color='royalblue')
+            name='Predicted Usage',
+            line=dict(color='blue')
         ))
         fig_curve.update_layout(
-            title='Forecast Trend (yhat)',
-            xaxis_title='Date',
-            yaxis_title='Predicted Usage',
-            template='plotly_white'
+            title="Forecast Curve",
+            xaxis_title="Date",
+            yaxis_title="Units",
+            template="plotly_white"
         )
         st.plotly_chart(fig_curve)
 
-        # Summary Bar Chart
-        st.header("Forecast Summary")
-        bar_data = pd.DataFrame({
-            'Period': ['7 Days', '14 Days', '30 Days'],
-            'Forecast Units': [forecast_7, forecast_14, forecast_30]
+        # Threshold bar chart
+        st.header("Stock vs Forecast 🚦")
+        alert_data = pd.DataFrame({
+            'Category': ['Current Stock', '7-Day Forecast', '14-Day Forecast', '30-Day Forecast'],
+            'Units': [current_stock, forecast_7, forecast_14, forecast_30],
+            'Flag': [False, alert_7, alert_14, alert_30]
         })
-        fig_bar = go.Figure(data=[
-            go.Bar(x=bar_data['Period'], y=bar_data['Forecast Units'], marker_color='blue')
-        ])
-        fig_bar.update_layout(
-            title="Forecast Summary",
-            xaxis_title="Forecast Period",
+        colors = ['green'] + ['red' if a else 'blue' for a in alert_data['Flag'][1:]]
+        flags = ["" if not f else "🚩" for f in alert_data['Flag']]
+
+        fig_alert = go.Figure()
+        fig_alert.add_trace(go.Bar(
+            x=alert_data['Category'],
+            y=alert_data['Units'],
+            marker_color=colors,
+            text=flags,
+            textposition='auto'
+        ))
+        fig_alert.update_layout(
+            title="Threshold Alerts Overview",
+            xaxis_title="Category",
             yaxis_title="Units",
-            template='plotly_white'
+            template="plotly_white"
         )
-        st.plotly_chart(fig_bar)
+        st.plotly_chart(fig_alert)
 
 if __name__ == "__main__":
     main()