Update app.py

app.py

@@ -2,57 +2,79 @@ import pandas as pd
 from prophet import Prophet
 import gradio as gr
 import plotly.graph_objs as go
+import numpy as np
 
 # Function to train the model and generate forecast
 def predict_sales(time_frame):
-    all_sales_data = pd.read_csv('All sales - House of Pizza.csv')
+    all_sales_data = pd.read_csv('/content/All sales - House of Pizza.csv')
 
-    # Clean up the 'Total paid' column
-    amount = all_sales_data['Total paid'].str.replace('₨', '', regex=False)
-    amount = amount.str.replace(',', '', regex=False)
-    amount = amount.str.strip()
-    amount = amount.astype(float)
+    # Clean up the 'Total paid' column by splitting based on '₨' symbol and converting to float
+    def clean_total_paid(val):
+        if isinstance(val, str):  # Only process if the value is a string
+            amounts = [float(x.replace(',', '').strip()) for x in val.split('₨') if x.strip()]
+            return sum(amounts)  # Sum if multiple values exist
+        elif pd.isna(val):  # Handle NaN values
+            return 0.0
+        return val  # If it's already a float, return it as-is
+
+    # Apply the cleaning function to the 'Total paid' column
+    all_sales_data['Total paid'] = all_sales_data['Total paid'].apply(clean_total_paid)
 
     # Convert the 'Date' column to datetime, coercing errors
     all_sales_data['Date'] = pd.to_datetime(all_sales_data['Date'], format='%m/%d/%Y %H:%M', errors='coerce')
 
     # Drop rows with invalid dates
     all_sales_data = all_sales_data.dropna(subset=['Date'])
+    all_sales_data['date_only'] = all_sales_data['Date'].dt.date
+    daily_sales = all_sales_data.groupby('date_only').agg(total_sales=('Total paid', 'sum')).reset_index()
 
-    # Prepare the DataFrame
+    # Prepare the DataFrame for Prophet
     df = pd.DataFrame({
-        'Date': all_sales_data['Date'],
-        'Total paid': amount
+        'Date': daily_sales['date_only'],
+        'Total paid': daily_sales['total_sales']
     })
 
+    # Apply log transformation
+    df['y'] = np.log1p(df['Total paid'])  # Using log1p to avoid log(0)
+
     # Prepare Prophet model
-    model = Prophet()
+    model = Prophet(weekly_seasonality=True)  # Enable weekly seasonality
     df['ds'] = df['Date']
-    df['y'] = df['Total paid']
     model.fit(df[['ds', 'y']])
-    last_date_value = df['Date'].iloc[-2]
+
     # Future forecast based on the time frame
     future_periods = {
-        '7 days': 7 ,
-        '10 days': 10 ,
-        '15 days': 15 ,
-        '1 month': 30 
+        'Next Day': 1,
+        '7 days': 7,
+        '10 days': 10,
+        '15 days': 15,
+        '1 month': 30
     }
 
-    # Get the future time based on the selected time frame
-    future_time = model.make_future_dataframe(periods=future_periods[time_frame])
-    current_time = pd.Timestamp.now()
+    # Get the last historical date and calculate the start date for the forecast
+    last_date_value = df['Date'].iloc[-1]
+    forecast_start_date = pd.Timestamp(last_date_value) + pd.Timedelta(days=1)  # Start the forecast from the next day
 
-    # Set the last historical date in the format 'MM/DD/YYYY HH:MM'
-    last_historical_date = pd.to_datetime(last_date_value, format='%m/%d/%Y %H:%M')
+    # Generate the future time DataFrame starting from the day after the last date
+    future_time = model.make_future_dataframe(periods=future_periods[time_frame], freq='D')
 
-    # Filter future_time to include rows from the current time and onwards, including future hours and minutes
-    future_only = future_time[(future_time['ds'] >= current_time) & (future_time['ds'] > last_historical_date)]
+    # Filter future_time to include only future dates starting from forecast_start_date
+    future_only = future_time[future_time['ds'] >= forecast_start_date]
     forecast = model.predict(future_only)
 
-    # Display the forecasted data
-    forecast_table = forecast[['ds', 'yhat', 'yhat_lower', 'yhat_upper']].tail(future_periods[time_frame])
-    
+    # Exponentiate the forecast to revert back to the original scale
+    forecast['yhat'] = np.expm1(forecast['yhat'])  # Use expm1 to handle the log transformation
+    forecast['yhat_lower'] = np.expm1(forecast['yhat_lower'])  # Exponentiate lower bound
+    forecast['yhat_upper'] = np.expm1(forecast['yhat_upper'])  # Exponentiate upper bound
+
+    # Create a DataFrame for weekends only
+    forecast['day_of_week'] = forecast['ds'].dt.day_name()  # Get the day name from the date
+    weekends = forecast[forecast['day_of_week'].isin(['Saturday', 'Sunday'])]  # Filter for weekends
+
+    # Display the forecasted data for the specified period
+    forecast_table = forecast[['ds', 'yhat', 'yhat_lower', 'yhat_upper']].head(future_periods[time_frame])
+    weekend_forecast_table = weekends[['ds', 'yhat', 'yhat_lower', 'yhat_upper']]  # Weekend forecast
+
     # Create a Plotly graph
     fig = go.Figure()
     fig.add_trace(go.Scatter(
@@ -63,26 +85,42 @@ def predict_sales(time_frame):
         marker=dict(size=6),
         hovertemplate='Date: %{x}<br>Forecasted Sales: %{y}<extra></extra>'
     ))
-    
+
+    # Add lines for yhat_lower and yhat_upper
+    fig.add_trace(go.Scatter(
+        x=forecast['ds'], y=forecast['yhat_lower'],
+        mode='lines',
+        name='Lower Bound',
+        line=dict(color='red', dash='dash')
+    ))
+
+    fig.add_trace(go.Scatter(
+        x=forecast['ds'], y=forecast['yhat_upper'],
+        mode='lines',
+        name='Upper Bound',
+        line=dict(color='green', dash='dash')
+    ))
+
     fig.update_layout(
         title='Sales Forecast using Prophet',
-        xaxis_title='Date and Time',
+        xaxis_title='Date',
         yaxis_title='Sales Price',
-        xaxis=dict(tickformat="%Y-%m-%d %H:%M"),
+        xaxis=dict(tickformat="%Y-%m-%d"),
         yaxis=dict(autorange=True)
     )
 
-    return forecast_table, fig
+    return forecast_table, weekend_forecast_table, fig  # Return the forecast table, weekend forecast, and plot
 
 # Gradio interface
 def run_gradio():
     # Create the Gradio Interface
-    time_options = ['7 days', '10 days', '15 days', '1 month']
+    time_options = ['Next Day', '7 days', '10 days', '15 days', '1 month']
     gr.Interface(
         fn=predict_sales,  # Function to be called
         inputs=gr.components.Dropdown(time_options, label="Select Forecast Time Range"),  # User input
         outputs=[
             gr.components.Dataframe(label="Forecasted Sales Table"),  # Forecasted data in tabular form
+            gr.components.Dataframe(label="Weekend Forecasted Sales Table"),  # Weekend forecast data
             gr.components.Plot(label="Sales Forecast Plot")  # Plotly graph output
         ],
         title="Sales Forecasting with Prophet",