Guardar mis cambios locales

app.py

@@ -1,88 +1,104 @@
-import pandas as pd
-import matplotlib.pyplot as plt
-import joblib
 import gradio as gr
-from dateutil.relativedelta import relativedelta
-import calendar
+import pandas as pd
+import numpy as np
+from datetime import datetime
+import pmdarima as pm
+from pmdarima import auto_arima
+import plotly.graph_objects as go
+from transformers import pipeline, TapasTokenizer, TapasForQuestionAnswering
+
+# Load the TAPAS Model
+def load_tapas_model():
+    model_name = "google/tapas-large-finetuned-wtq"
+    tokenizer = TapasTokenizer.from_pretrained(model_name)
+    model = TapasForQuestionAnswering.from_pretrained(model_name)
+    pipe = pipeline("table-question-answering", model=model, tokenizer=tokenizer)
+    return pipe
+
+pipe = load_tapas_model()
 
-def load_model():
-    try:
-        model = joblib.load('arima_sales_model.pkl')
-        return model, None
-    except Exception as e:
-        return None, f"Failed to load model: {str(e)}"
+# Helper Functions
+def drop(dataframe):
+    # Drop unnecessary columns and keep only 'Date' and 'Sales'
+    columns_to_keep = [col for col in dataframe.columns if "date" in col.lower() or "sales" in col.lower()]
+    dataframe = dataframe[columns_to_keep].dropna()
+    return dataframe
 
-def parse_date(date_str):
-    """Parse the custom date format 'Month-Year'."""
-    try:
-        date = pd.to_datetime(date_str, format="%B-%Y")
-        _, last_day = calendar.monthrange(date.year, date.month)
-        start_date = date.replace(day=1)
-        end_date = date.replace(day=last_day)
-        return start_date, end_date, None
-    except ValueError:
-        return None, None, "Date format should be 'Month-Year', e.g., 'January-2024'."
+def date_format(dataframe):
+    # Convert the 'Date' column to a proper datetime format
+    dataframe['Date'] = pd.to_datetime(dataframe['Date'].str.strip(), format="%m/%d/%Y")
+    return dataframe
 
-def forecast_sales(uploaded_file, start_date_str, end_date_str):
-    if uploaded_file is None:
-        return "No file uploaded.", None, "Please upload a file."
+def group_to_three(dataframe):
+    # Group the data into three-day intervals and calculate the mean sales
+    dataframe = dataframe.groupby(pd.Grouper(key='Date', freq='3D')).Sales.mean().dropna().round(2)
+    return dataframe
 
-    try:
-        df = pd.read_csv(uploaded_file)
-        if 'Date' not in df.columns or 'Sale' not in df.columns:
-            return None, "The uploaded file must contain 'Date' and 'Sale' columns.", "File does not have required columns."
-    except Exception as e:
-        return None, f"Failed to read the uploaded CSV file: {str(e)}", "Error reading file."
+def series_to_df_exogenous(series):
+    # Convert the series to a DataFrame and create exogenous variables
+    dataframe = series.to_frame().reset_index().set_index('Date')
+    dataframe['Sales First Difference'] = dataframe['Sales'].diff().dropna()
+    dataframe['Seasonal First Difference'] = dataframe['Sales'].diff(12).dropna()
+    return dataframe.dropna()
 
-    start_date, _, error = parse_date(start_date_str)
-    _, end_date, error_end = parse_date(end_date_str)
-    if error or error_end:
-        return None, error or error_end, "Invalid date format."
+def train_test(dataframe, n):
+    # Split the data into training and testing sets
+    training_y = dataframe['Sales'][:-n]
+    test_y = dataframe['Sales'][-n:]
+    training_X = dataframe.iloc[:-n, 1:]
+    test_X = dataframe.iloc[-n:, 1:]
+    return training_y, test_y, training_X, test_X
 
-    df['Date'] = pd.to_datetime(df['Date'])
-    df = df.rename(columns={'Date': 'ds', 'Sale': 'y'})
+def test_fitting(train_X, train_y):
+    # Fit a SARIMAX model using auto_arima
+    model = auto_arima(y=train_y, X=train_X, seasonal=True, m=12, stepwise=True, suppress_warnings=True)
+    return model
 
-    df_filtered = df[(df['ds'] >= start_date) & (df['ds'] <= end_date)]
+def forecast_sales(df, period):
+    # Prepare data and make predictions
+    df = drop(df)
+    df = date_format(df)
+    series = group_to_three(df)
+    exog_df = series_to_df_exogenous(series)
+    
+    n_periods = int(len(exog_df) * 0.2)
+    train_y, test_y, train_X, test_X = train_test(exog_df, n_periods)
+    
+    model = test_fitting(train_X, train_y)
+    future_fitted, _ = model.predict(n_periods=int(period / 3), X=exog_df.iloc[-int(period / 3):, 1:], return_conf_int=True)
+    
+    future_dates = pd.date_range(start=series.index[-1], periods=int(period / 3), freq='3D')
+    forecast_df = pd.DataFrame({'Date': future_dates, 'Forecasted Sales': future_fitted})
+    
+    return forecast_df
 
-    arima_model, error = load_model()
-    if arima_model is None:
-        return None, error, "Failed to load ARIMA model."
+def answer_question(forecast_df, question):
+    # Use TAPAS model to answer questions
+    answer = pipe(table=forecast_df, query=question)
+    return answer['answer']
 
-    try:
-        forecast = arima_model.get_forecast(steps=60)
-        forecast_index = pd.date_range(start=end_date, periods=61, freq='D')[1:]
-        forecast_df = pd.DataFrame({'Date': forecast_index, 'Sales Forecast': forecast.predicted_mean})
-        
-        fig, ax = plt.subplots(figsize=(10, 6))
-        ax.plot(df_filtered['ds'], df_filtered['y'], label='Actual Sales', color='blue')
-        ax.plot(forecast_df['Date'], forecast_df['Sales Forecast'], label='Sales Forecast', color='red', linestyle='--')
-        ax.set_xlabel('Date')
-        ax.set_ylabel('Sales')
-        ax.set_title('Sales Forecasting with ARIMA')
-        ax.legend()
-        return fig, "File loaded and processed successfully."
-    except Exception as e:
-        return None, f"Failed to generate plot: {str(e)}", "Plotting failed."
+# Gradio Interface
+def main(uploaded_file, period, question):
+    # Main function to process uploaded file, forecast sales, and answer the question
+    df = pd.read_csv(uploaded_file)
+    forecast_df = forecast_sales(df, period)
+    answer = answer_question(forecast_df, question)
+    
+    return forecast_df, answer
 
-def setup_interface():
-    with gr.Blocks() as demo:
-        gr.Markdown("## MLCast v1.1 - Intelligent Sales Forecasting System")
-        with gr.Row():
-            with gr.Column(scale=1):
-                file_input = gr.File(label="Upload your store data")
-                start_date_input = gr.Textbox(label="Start Date", placeholder="January-2024")
-                end_date_input = gr.Textbox(label="End Date", placeholder="December-2024")
-                forecast_button = gr.Button("Forecast Sales")
-            with gr.Column(scale=2):
-                output_plot = gr.Plot()
-                output_message = gr.Textbox(label="Notifications", visible=True, lines=2)
-        forecast_button.click(
-            forecast_sales,
-            inputs=[file_input, start_date_input, end_date_input],
-            outputs=[output_plot, output_message]
-        )
-    return demo
+interface = gr.Interface(
+    fn=main,
+    inputs=[
+        gr.File(label="Upload CSV File"),
+        gr.Slider(minimum=30, maximum=90, step=1, label="Forecast Days"),
+        gr.Textbox(placeholder="Ask a question about the forecasted data", label="Question")
+    ],
+    outputs=[
+        gr.Dataframe(label="Forecasted Sales Data"),
+        gr.Textbox(label="Answer")
+    ],
+    title="Sales Forecasting Dashboard",
+    description="Upload your sales data and get a forecast. You can also ask questions about the forecasted data."
+)
 
-if __name__ == "__main__":
-    interface = setup_interface()
-    interface.launch()
+interface.launch()