app.py

import gradio as gr
import pandas as pd
import numpy as np
from statsmodels.tsa.arima.model import ARIMA
from sklearn.metrics import mean_squared_error, mean_absolute_error
import matplotlib.pyplot as plt
import io
import base64

# Load and preprocess data
def load_data():
    df = pd.read_csv("data (3).csv", skiprows=2, header=None)
    header_df = pd.read_csv("data (3).csv", nrows=2, header=None)
    
    column_names = ['PN', 'Dummy_Project'] + [
        f"{header_df.iloc[0, i]}_{header_df.iloc[1, i]}" for i in range(2, len(header_df.columns))
    ]
    
    df.columns = column_names
    id_vars = ['PN', 'Dummy_Project']
    value_vars = column_names[2:]
    
    df_long = df.melt(
        id_vars=id_vars,
        value_vars=value_vars,
        var_name='Time_Period',
        value_name='y'
    )
    
    df_long[['Year', 'Month']] = df_long['Time_Period'].str.split('_', expand=True)
    df_long.drop(columns=['Time_Period'], inplace=True)
    df_long['Year'] = df_long['Year'].astype(int)
    df_long['Month'] = df_long['Month'].astype(str)
    
    df_long['Date'] = pd.to_datetime(
        df_long['Year'].astype(str) + '-' + df_long['Month'] + '-01',
        format='%Y-%b-%d',
        errors='coerce'
    )
    
    df_long.dropna(subset=['y'], inplace=True)
    df_long.reset_index(drop=True, inplace=True)
    
    return df_long

# Get available part numbers
def get_part_numbers(df):
    return df['PN'].unique().tolist()

# Train ARIMA model and make predictions
def train_arima(series, order=(5,1,0)):
    model = ARIMA(series, order=order)
    model_fit = model.fit()
    forecast = model_fit.forecast(steps=10)
    return model_fit, forecast

# Create plot
def create_plot(historical, forecast):
    plt.figure(figsize=(12, 6))
    plt.plot(historical.index, historical, label='Historical')
    plt.plot(range(len(historical), len(historical) + len(forecast)), forecast, 
             label='Forecast', color='orange')
    plt.legend()
    plt.title('Time Series Forecast')
    plt.xlabel('Time Period')
    plt.ylabel('Value')
    
    # Convert plot to base64 for Gradio
    buf = io.BytesIO()
    plt.savefig(buf, format='png')
    buf.seek(0)
    img_str = base64.b64encode(buf.read()).decode('utf-8')
    buf.close()
    
    return f'<img src="data:image/png;base64,{img_str}" />'

# Main prediction function
def predict(part_number, model_name):
    df = load_data()
    df_part = df[df['PN'] == part_number].copy()
    
    # Prepare time series data
    start_date = '2021-10-09'
    date_range = pd.date_range(start=start_date, periods=len(df_part), freq='W')
    df_part['Date'] = date_range
    df_part.set_index('Date', inplace=True)
    
    series = df_part['y'].astype(float)
    
    if model_name == 'ARIMA':
        model, forecast = train_arima(series)
    
    # Calculate metrics
    train_size = int(len(series) * 0.8)
    train, test = series[:train_size], series[train_size:]
    
    model_eval = ARIMA(train, order=(5,1,0))
    model_fit_eval = model_eval.fit()
    predictions = model_fit_eval.forecast(steps=len(test))
    
    rmse = np.sqrt(mean_squared_error(test, predictions))
    mae = mean_absolute_error(test, predictions)
    
    plot_html = create_plot(series, forecast)
    
    metrics = f"""
    Model Performance Metrics:
    - RMSE: {rmse:.2f}
    - MAE: {mae:.2f}
    
    Forecast for next 10 periods:
    {', '.join([f'{x:.2f}' for x in forecast])}
    """
    
    return metrics, plot_html

# Create Gradio interface
def create_interface():
    df = load_data()
    part_numbers = get_part_numbers(df)
    
    with gr.Blocks() as demo:
        gr.Markdown("# Time Series Forecasting Dashboard")
        
        with gr.Row():
            part_dropdown = gr.Dropdown(choices=part_numbers, label="Select Part Number")
            model_dropdown = gr.Dropdown(choices=['ARIMA'], label="Select Model")
        
        predict_btn = gr.Button("Predict")
        
        with gr.Row():
            metrics_output = gr.Textbox(label="Metrics and Forecast")
            plot_output = gr.HTML(label="Forecast Plot")
        
        predict_btn.click(
            fn=predict,
            inputs=[part_dropdown, model_dropdown],
            outputs=[metrics_output, plot_output]
        )
    
    return demo

if __name__ == "__main__":
    demo = create_interface()
    demo.launch()