Add modular model architecture with dropdown selector

- Create models.py for centralized model configuration
- Support both Chronos-2 and Chronos-T5 pipeline classes
- Add model selector dropdown with 6 model options
- Separate model loading logic from app logic
- Easy to extend with new models in the future
- Fix compatibility with different Chronos variants

app.py

@@ -1,23 +1,17 @@
 import streamlit as st
 import pandas as pd
 import torch
-from chronos import Chronos2Pipeline
 import matplotlib.pyplot as plt
 import numpy as np
 from gridstatus import Ercot
 from datetime import datetime, timedelta
+from models import ModelConfig, load_model_pipeline
 
-# Load the Chronos Pipeline model
+# Load the forecasting model pipeline
 @st.cache_resource
-def load_pipeline():
-    pipeline = Chronos2Pipeline.from_pretrained(
-        "amazon/chronos-2",
-        device_map="cpu",  # Change to CPU
-        dtype=torch.float32,  # Use float32 for CPU
-    )
-    return pipeline
-
-pipeline = load_pipeline()
+def load_pipeline(model_name):
+    """Load and cache the model pipeline"""
+    return load_model_pipeline(model_name, device_map="cpu", dtype=torch.float32)
 
 # Function to fetch ERCOT electricity price data
 @st.cache_data(ttl=3600)  # Cache for 1 hour
@@ -49,6 +43,19 @@ def fetch_ercot_data(days_back=180):
 st.title("Electricity Market Price Forecasting with Chronos-2")
 st.write("This demo uses **Chronos-2** to forecast electricity prices from ERCOT (Texas) market data.")
 
+# Model selection
+available_model_names = ModelConfig.get_model_names()
+
+selected_model_name = st.selectbox(
+    "Select Forecasting Model:",
+    options=available_model_names,
+    index=0  # Default to first model (Chronos-2)
+)
+
+# Load the selected model
+with st.spinner(f"Loading {selected_model_name}..."):
+    pipeline = load_pipeline(selected_model_name)
+
 # Fetch default ERCOT data
 with st.spinner("Fetching latest ERCOT electricity prices..."):
     ercot_data = fetch_ercot_data()

models.py

@@ -0,0 +1,118 @@
+"""
+Model configuration and loading for time series forecasting.
+Supports multiple Chronos model variants with different architectures.
+"""
+
+import torch
+from chronos import Chronos2Pipeline, ChronosPipeline
+
+
+class ModelConfig:
+    """Configuration for available forecasting models"""
+    
+    CHRONOS_2_MODELS = {
+        "Chronos-2 (Latest, 120M params)": {
+            "model_id": "amazon/chronos-2",
+            "pipeline_class": Chronos2Pipeline,
+            "description": "Latest Chronos-2 model with 120M parameters"
+        }
+    }
+    
+    CHRONOS_T5_MODELS = {
+        "Chronos-T5 Tiny (8M params)": {
+            "model_id": "amazon/chronos-t5-tiny",
+            "pipeline_class": ChronosPipeline,
+            "description": "Smallest Chronos-T5 model, fastest inference"
+        },
+        "Chronos-T5 Mini (20M params)": {
+            "model_id": "amazon/chronos-t5-mini",
+            "pipeline_class": ChronosPipeline,
+            "description": "Mini Chronos-T5 model"
+        },
+        "Chronos-T5 Small (46M params)": {
+            "model_id": "amazon/chronos-t5-small",
+            "pipeline_class": ChronosPipeline,
+            "description": "Small Chronos-T5 model"
+        },
+        "Chronos-T5 Base (200M params)": {
+            "model_id": "amazon/chronos-t5-base",
+            "pipeline_class": ChronosPipeline,
+            "description": "Base Chronos-T5 model"
+        },
+        "Chronos-T5 Large (710M params)": {
+            "model_id": "amazon/chronos-t5-large",
+            "pipeline_class": ChronosPipeline,
+            "description": "Largest Chronos-T5 model, best accuracy"
+        }
+    }
+    
+    @classmethod
+    def get_all_models(cls):
+        """Get all available models"""
+        all_models = {}
+        all_models.update(cls.CHRONOS_2_MODELS)
+        all_models.update(cls.CHRONOS_T5_MODELS)
+        return all_models
+    
+    @classmethod
+    def get_model_names(cls):
+        """Get list of model names for dropdown"""
+        return list(cls.get_all_models().keys())
+    
+    @classmethod
+    def get_model_config(cls, model_name):
+        """Get configuration for a specific model"""
+        return cls.get_all_models().get(model_name)
+
+
+def load_model_pipeline(model_name, device_map="cpu", dtype=torch.float32):
+    """
+    Load a forecasting model pipeline.
+    
+    Args:
+        model_name: Display name of the model
+        device_map: Device to load model on (default: "cpu")
+        dtype: Data type for model weights (default: torch.float32)
+    
+    Returns:
+        Loaded pipeline instance
+    """
+    config = ModelConfig.get_model_config(model_name)
+    
+    if config is None:
+        raise ValueError(f"Unknown model: {model_name}")
+    
+    pipeline_class = config["pipeline_class"]
+    model_id = config["model_id"]
+    
+    # Load the appropriate pipeline
+    pipeline = pipeline_class.from_pretrained(
+        model_id,
+        device_map=device_map,
+        dtype=dtype,
+    )
+    
+    return pipeline
+
+
+def get_model_info(model_name):
+    """
+    Get information about a model.
+    
+    Args:
+        model_name: Display name of the model
+    
+    Returns:
+        Dictionary with model information
+    """
+    config = ModelConfig.get_model_config(model_name)
+    
+    if config is None:
+        return None
+    
+    return {
+        "name": model_name,
+        "model_id": config["model_id"],
+        "description": config["description"],
+        "pipeline": config["pipeline_class"].__name__
+    }