Guardar mis cambios locales

app.py

@@ -2,104 +2,157 @@ import gradio as gr
 import pandas as pd
 import numpy as np
 from datetime import datetime
-import joblib
-import pmdarima as pm
-from pmdarima import auto_arima
 import plotly.graph_objects as go
+import torch
 from transformers import pipeline, TapasTokenizer, TapasForQuestionAnswering
+import pmdarima as pm
+from pmdarima import auto_arima
 
-# Load the TAPAS Model
-def load_tapas_model():
-    model_name = joblib.load('arima_sales_model.pkl')
-    tokenizer = TapasTokenizer.from_pretrained(model_name)
-    model = TapasForQuestionAnswering.from_pretrained(model_name)
-    pipe = pipeline("table-question-answering", model=model, tokenizer=tokenizer)
-    return pipe
+# Preprocessing functions (same as before)
+def merge(B, C, A):
+    # Implement merge function here...
+    pass
 
-pipe = load_tapas_model()
+def merge_sort(dataframe):
+    # Implement merge_sort function here...
+    pass
 
-# 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
+    # Implement drop function here...
+    pass
 
 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
+    # Implement date_format function here...
+    pass
 
 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
+    # Implement group_to_three function here...
+    pass
 
 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()
+    # Implement series_to_df_exogenous function here...
+    pass
+
+def dates_df(dataframe):
+    # Implement dates_df function here...
+    pass
+
+def get_forecast_period(period):
+    # Implement get_forecast_period function here...
+    pass
 
 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
-
-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
-
-def forecast_sales(df, period):
-    # Prepare data and make predictions
+    # Implement train_test function here...
+    pass
+
+def test_fitting(dataframe, Exo, trainY):
+    # Implement test_fitting function here...
+    pass
+
+def forecast_accuracy(forecast, actual):
+    # Implement forecast_accuracy function here...
+    pass
+
+def sales_growth(dataframe, fittedValues):
+    # Implement sales_growth function here...
+    pass
+
+def merge_forecast_data(actual, predicted, future):
+    # Implement merge_forecast_data function here...
+    pass
+
+def interpret_mape(mape_score):
+    # Implement interpret_mape function here...
+    pass
+
+def load_tapas_model():
+    model_name = "google/tapas-large-finetuned-wtq"
+    tokenizer = TapasTokenizer.from_pretrained(model_name)
+    model = TapasForQuestionAnswering.from_pretrained(model_name, local_files_only=False)
+    pipe = pipeline("table-question-answering", model=model, tokenizer=tokenizer)
+    return pipe
+
+pipe = load_tapas_model()
+
+def get_answer(table, query):
+    answers = pipe(table=table, query=query)
+    return answers
+
+def convert_answer(answer):
+    # Implement convert_answer function here...
+    pass
+
+def get_converted_answer(table, query):
+    # Implement get_converted_answer function here...
+    pass
+
+# Gradio Interface
+def upload_and_forecast(uploaded_file, period):
+    if uploaded_file is None:
+        return "Please upload a file to proceed."
+    
+    # Load the data
+    df = pd.read_csv(uploaded_file)
     df = drop(df)
     df = date_format(df)
+    merge_sort(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)
+    forecast_period = get_forecast_period(period)
+    df = series_to_df_exogenous(series)
     
-    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)
+    # Train the model
+    n_periods = round(len(df) * 0.2)
+    train = train_test(df, n_periods)
+    training_y, test_y, test_y_series, training_X, test_X, future_X = train
+    train_test_model = test_fitting(df, training_X, training_y)
     
-    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
+    fitted, confint = train_test_model.predict(X=test_X, n_periods=n_periods, return_conf_int=True)
+    index_of_fc = test_y_series.index
+    fitted_series = pd.Series(fitted)
+    fitted_series.index = index_of_fc
 
-def answer_question(forecast_df, question):
-    # Use TAPAS model to answer questions
-    answer = pipe(table=forecast_df, query=question)
-    return answer['answer']
+    future_n_periods = forecast_period
+    future_fitted, confint = train_test_model.predict(X=df.iloc[-future_n_periods:, 1:], n_periods=future_n_periods, return_conf_int=True, freq='3D')
+    future_index_of_fc = pd.date_range(df['Sales'].index[-1], periods=future_n_periods, freq='3D')
+    future_fitted_series = pd.Series(future_fitted)
+    future_fitted_series.index = future_index_of_fc
 
-# 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)
+    # Calculate sales growth
+    future_sales_growth = sales_growth(df, future_fitted_series)
+    
+    # Prepare merged data for chart plotting
+    merged_data = merge_forecast_data(df['Sales'], fitted_series, future_fitted_series)
     
-    return forecast_df, answer
+    # Plot the charts
+    fig_compare = go.Figure()
+    fig_compare.add_trace(go.Scatter(x=merged_data[merged_data.columns[0]], y=merged_data['Actual Sales'], mode='lines', name='Actual Sales'))
+    fig_compare.add_trace(go.Scatter(x=merged_data[merged_data.columns[0]], y=merged_data['Predicted Sales'], mode='lines', name='Predicted Sales', line=dict(color='#006400')))
+    fig_compare.update_layout(title='Historical Sales Data', xaxis_title='Date', yaxis_title='Sales')
+
+    fig_forecast = go.Figure()
+    fig_forecast.add_trace(go.Scatter(x=merged_data[merged_data.columns[0]], y=merged_data['Actual Sales'], mode='lines', name='Actual Sales'))
+    fig_forecast.add_trace(go.Scatter(x=merged_data[merged_data.columns[0]], y=merged_data['Forecasted Future Sales'], mode='lines', name='Future Forecasted Sales'))
+    fig_forecast.update_layout(title='Forecasted Sales Data', xaxis_title='Date', yaxis_title='Sales')
+
+    # Return the figures and growth data
+    return fig_compare, fig_forecast, future_sales_growth
 
-interface = gr.Interface(
-    fn=main,
+# Gradio Interface setup
+iface = gr.Interface(
+    fn=upload_and_forecast,
     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")
+        gr.File(label="Upload your sales data (CSV)"),
+        gr.Slider(minimum=30, maximum=90, step=1, label="Forecast Period (Days)")
     ],
     outputs=[
-        gr.Dataframe(label="Forecasted Sales Data"),
-        gr.Textbox(label="Answer")
+        gr.Plot(label="Historical vs Predicted Sales"),
+        gr.Plot(label="Forecasted Sales Data"),
+        gr.DataFrame(label="Sales Growth")
     ],
-    title="Sales Forecasting Dashboard",
-    description="Upload your sales data and get a forecast. You can also ask questions about the forecasted data."
+    live=True,
+    title="Sales Forecasting System",
+    description="Upload your sales data to start forecasting."
 )
 
-interface.launch()
+iface.launch()