Upload 2 files

app.py

@@ -0,0 +1,307 @@
+import gradio as gr
+import pandas as pd
+import json
+import requests
+from typing import Dict, Any
+import os
+from datetime import datetime
+
+# Configuration
+HF_ENDPOINT = os.getenv("HF_ENDPOINT", "https://i3302d3uxvtjxwjm.us-east-1.aws.endpoints.huggingface.cloud")
+HF_TOKEN = os.getenv("HF_TOKEN")
+
+# Validate that HF_TOKEN is set
+if not HF_TOKEN:
+    raise ValueError(
+        "HF_TOKEN environment variable is not set. "
+        "Please set it in your HuggingFace Space secrets or local environment."
+    )
+
+
+def load_scenarios_from_file(scenarios_file_path: str) -> Dict[str, Any]:
+    """Load scenarios from JSON file"""
+    try:
+        with open(scenarios_file_path, 'r') as f:
+            return json.load(f)
+    except Exception as e:
+        # Return default scenarios if file cannot be loaded
+        print(f"Warning: Could not load scenarios file. Using defaults. Error: {e}")
+        return {
+            "base": {},
+            "price_up_2pct": {"planned_price_index": 1.02},
+            "price_up_5pct": {"planned_price_index": 1.05},
+            "price_up_10pct": {"planned_price_index": 1.1},
+            "price_down_2pct": {"planned_price_index": 0.98},
+            "price_down_5pct": {"planned_price_index": 0.95},
+            "price_down_10pct": {"planned_price_index": 0.9},
+            "discount_5pct": {"planned_discount_pct": 5},
+            "discount_10pct": {"planned_discount_pct": 10},
+            "discount_20pct": {"planned_discount_pct": 20},
+            "promo_on": {"planned_promo_flag": 1.0},
+            "promo_off": {"planned_promo_flag": 0.0},
+            "tender_on": {"planned_tender_flag": 1.0},
+            "regulatory_event": {"planned_regulatory_event_flag": 1.0},
+            "supply_risk_high": {"planned_supply_risk": 1.0},
+            "competitor_pressure_high": {"planned_competitor_pressure": 1.0},
+            "growth_push": {
+                "planned_price_index": 0.95,
+                "planned_discount_pct": 10,
+                "planned_promo_flag": 1.0
+            },
+            "margin_push": {
+                "planned_price_index": 1.05,
+                "planned_discount_pct": 0.0,
+                "planned_promo_flag": 0.0
+            },
+            "promo_plus_discount": {
+                "planned_discount_pct": 15,
+                "planned_promo_flag": 1.0
+            },
+            "tender_plus_supply_risk": {
+                "planned_tender_flag": 1.0,
+                "planned_supply_risk": 1.0
+            },
+            "worst_case": {
+                "planned_price_index": 1.1,
+                "planned_supply_risk": 1.0,
+                "planned_competitor_pressure": 1.0
+            }
+        }
+
+
+def csv_to_inference_json(csv_file_path: str, scenarios: Dict[str, Any]) -> Dict[str, Any]:
+    """Convert CSV file to inference JSON format"""
+    # Read CSV
+    df = pd.read_csv(csv_file_path)
+    
+    # Clean up month column - handle both datetime and string formats
+    df['month'] = pd.to_datetime(df['month']).dt.strftime('%Y-%m')
+    
+    # Replace NaN with None for JSON serialization
+    df = df.where(pd.notna(df), None)
+    
+    # Build the inference JSON structure
+    inference_data = {
+        "inputs": {
+            "data": {
+                "month": df['month'].tolist(),
+                "product_id": df['product_id'].tolist(),
+                "market_id": df['market_id'].tolist(),
+                "units_sold": df['units_sold'].tolist(),
+                "planned_price_index": df['planned_price_index'].tolist(),
+                "planned_discount_pct": df['planned_discount_pct'].tolist(),
+                "planned_promo_flag": df['planned_promo_flag'].tolist(),
+                "planned_tender_flag": df['planned_tender_flag'].tolist(),
+                "planned_supply_risk": df['planned_supply_risk'].tolist(),
+                "planned_competitor_pressure": df['planned_competitor_pressure'].tolist(),
+                "planned_regulatory_event_flag": df['planned_regulatory_event_flag'].tolist()
+            },
+            "parameters": {
+                "encoder_length": 12,
+                "prediction_length": 6,
+                "batch_size": 256,
+                "n_samples": 1000,
+                "quantiles": [0.1, 0.5, 0.9],
+                "scenarios": scenarios,
+                "round_outputs": True
+            }
+        }
+    }
+    
+    return inference_data
+
+
+def send_inference_request(inference_json: Dict[str, Any], endpoint: str, token: str) -> Dict[str, Any]:
+    """Send inference request to HuggingFace endpoint"""
+    headers = {
+        "Authorization": f"Bearer {token}",
+        "Content-Type": "application/json"
+    }
+    
+    response = requests.post(endpoint, headers=headers, json=inference_json)
+    response.raise_for_status()
+    
+    return response.json()
+
+
+def parse_forecast_response(response_json: Dict[str, Any]) -> pd.DataFrame:
+    """Parse the forecast response and convert to DataFrame"""
+    forecasts = response_json.get("forecasts", [])
+    
+    if not forecasts:
+        return pd.DataFrame()
+    
+    # Convert to DataFrame
+    df = pd.DataFrame(forecasts)
+    
+    # Reorder columns for better display
+    column_order = [
+        'scenario', 'product_id', 'market_id', 'month', 'horizon_step',
+        'point_mean', 'p10', 'p50', 'p90',
+        'confidence_label', 'confidence_score', 'requires_review',
+        'planned_price_index', 'planned_discount_pct', 'planned_promo_flag',
+        'planned_tender_flag', 'planned_regulatory_event_flag',
+        'planned_supply_risk', 'planned_competitor_pressure'
+    ]
+    
+    # Only include columns that exist
+    column_order = [col for col in column_order if col in df.columns]
+    df = df[column_order]
+    
+    return df
+
+
+def process_forecast(csv_file, scenarios_file):
+    """Main processing function for the Gradio interface"""
+    try:
+        # Validate inputs
+        if csv_file is None:
+            return None, "❌ **Error**: Please upload a CSV file", None
+        
+        if scenarios_file is None:
+            return None, "❌ **Error**: Please upload a scenarios JSON file", None
+        
+        # Load scenarios from uploaded file
+        scenarios = load_scenarios_from_file(scenarios_file.name)
+        
+        # Convert CSV to inference JSON
+        inference_json = csv_to_inference_json(csv_file.name, scenarios)
+        
+        # Send request to endpoint
+        response_json = send_inference_request(inference_json, HF_ENDPOINT, HF_TOKEN)
+        
+        # Parse response into DataFrame
+        df_forecasts = parse_forecast_response(response_json)
+        
+        if df_forecasts.empty:
+            return None, "⚠️ **Warning**: No forecasts returned from the model", None
+        
+        # Generate summary statistics
+        summary_text = f"""
+✅ **Forecast Generation Successful!**
+
+**Summary:**
+- 📊 Total forecasts: **{len(df_forecasts)}**
+- 🎯 Unique scenarios: **{df_forecasts['scenario'].nunique()}**
+- 📦 Products: **{df_forecasts['product_id'].nunique()}**
+- 🌍 Markets: **{df_forecasts['market_id'].nunique()}**
+- 📅 Date range: **{df_forecasts['month'].min()}** to **{df_forecasts['month'].max()}**
+
+**Confidence Distribution:**
+- 🟢 HIGH: **{(df_forecasts['confidence_label'] == 'HIGH').sum()}** forecasts
+- 🟡 MEDIUM: **{(df_forecasts['confidence_label'] == 'MEDIUM').sum()}** forecasts
+- 🔴 LOW: **{(df_forecasts['confidence_label'] == 'LOW').sum()}** forecasts
+
+**Scenarios Processed:** {', '.join(df_forecasts['scenario'].unique()[:5])}{'...' if df_forecasts['scenario'].nunique() > 5 else ''}
+        """
+        
+        # Save to CSV for download
+        output_csv_path = f"forecasts_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv"
+        df_forecasts.to_csv(output_csv_path, index=False)
+        
+        return df_forecasts, summary_text, output_csv_path
+        
+    except Exception as e:
+        error_msg = f"❌ **Error**: {str(e)}"
+        return None, error_msg, None
+
+
+# Create Gradio interface
+with gr.Blocks(title="Demand Forecasting - HF Endpoint", theme=gr.themes.Soft()) as demo:
+    gr.Markdown(
+        """
+        # 📊 Demand Forecasting Application
+        Upload your historical demand CSV file and scenarios JSON to get forecasts for multiple scenarios.
+        """
+    )
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.Markdown("### 📁 Input Files")
+            
+            csv_input = gr.File(
+                label="1️⃣ Upload CSV File (Historical Data)",
+                file_types=[".csv"]
+            )
+            
+            scenarios_input = gr.File(
+                label="2️⃣ Upload Scenarios JSON File",
+                file_types=[".json"]
+            )
+            
+            gr.Markdown(
+                """
+                **CSV Format:**
+                ```
+                month,product_id,market_id,units_sold,
+                planned_price_index,planned_discount_pct,
+                planned_promo_flag,planned_tender_flag,
+                planned_supply_risk,planned_competitor_pressure,
+                planned_regulatory_event_flag
+                ```
+                ⚠️ Last 6 rows: empty `units_sold` (forecast horizon)
+                
+                **JSON Format:**
+                ```json
+                {
+                  "base": {},
+                  "price_up_10pct": {
+                    "planned_price_index": 1.1
+                  },
+                  "discount_10pct": {
+                    "planned_discount_pct": 10
+                  }
+                }
+                ```
+                """
+            )
+            
+            submit_btn = gr.Button("🚀 Generate Forecasts", variant="primary", size="lg")
+        
+        with gr.Column(scale=2):
+            gr.Markdown("### 📈 Results")
+            summary_output = gr.Markdown(label="Summary")
+    
+    with gr.Row():
+        forecast_table = gr.Dataframe(
+            label="Forecast Results",
+            interactive=False,
+            wrap=True
+        )
+    
+    with gr.Row():
+        download_btn = gr.File(label="📥 Download Forecasts CSV")
+    
+    gr.Markdown(
+        """
+        ---
+        ### 🔍 About
+        This application uses a private HuggingFace endpoint to generate demand forecasts for multiple scenarios.
+        
+        **Common Scenarios:**
+        - 📈 Base scenario
+        - 💰 Price adjustments (±2%, ±5%, ±10%)
+        - 🏷️ Discount variations (5%, 10%, 20%)
+        - 🎁 Promotional scenarios
+        - ⚠️ Supply risk scenarios
+        - 🏆 Competitive pressure scenarios
+        - 🎯 Strategic scenarios (growth_push, margin_push, worst_case, etc.)
+        
+        **Output Columns:**
+        - Point forecasts (mean) and prediction intervals (P10, P50, P90)
+        - Confidence scores and labels (HIGH/MEDIUM/LOW)
+        - Review flags for forecasts requiring attention
+        - All input parameters used for each scenario
+        """
+    )
+    
+    # Connect the button to the processing function
+    submit_btn.click(
+        fn=process_forecast,
+        inputs=[csv_input, scenarios_input],
+        outputs=[forecast_table, summary_output, download_btn]
+    )
+
+# Launch the app
+if __name__ == "__main__":
+    demo.launch(share=False)

requirements.txt

@@ -0,0 +1,3 @@
+gradio>=4.0.0
+pandas>=2.0.0
+requests>=2.31.0