Update app.py

app.py

@@ -1,77 +1,3 @@
-# ============================================================================
-# TIME SERIES FORECASTING TUTORIAL: Prophet, ARIMA, and SARIMA
-# ============================================================================
-#
-# WHAT IS TIME SERIES DATA?
-# -------------------------
-# Time series data is a sequence of measurements taken at regular intervals
-# over time. Examples include:
-#   - Daily temperature readings
-#   - Hourly stock prices
-#   - Monthly sales figures
-#   - Minute-by-minute sensor readings (like in this code!)
-#
-# The goal of time series forecasting is to predict FUTURE values based on
-# PAST patterns in the data.
-#
-# KEY CONCEPTS IN TIME SERIES:
-# ----------------------------
-# 1. TREND: The long-term direction of the data (going up, down, or staying flat)
-#    Example: Global temperatures have an upward trend over decades
-#
-# 2. SEASONALITY: Patterns that repeat at regular intervals
-#    Example: Ice cream sales are higher in summer, lower in winter (yearly cycle)
-#    Example: Electricity usage is higher during day, lower at night (daily cycle)
-#
-# 3. NOISE: Random fluctuations that don't follow any pattern
-#    Example: Unexpected spikes or dips due to random events
-#
-# THE THREE MODELS WE'LL USE:
-# ---------------------------
-# 1. ARIMA (AutoRegressive Integrated Moving Average)
-#    - A classic statistical model
-#    - Good for data with trends but NO seasonality
-#    - Uses past values and past errors to predict future
-#
-# 2. SARIMA (Seasonal ARIMA)
-#    - ARIMA + ability to handle seasonal patterns
-#    - Good for data with BOTH trends AND seasonality
-#    - NOTE: Can be SLOW on large datasets! (see PERFORMANCE section below)
-#
-# 3. Prophet (by Meta/Facebook)
-#    - A modern, user-friendly model
-#    - Automatically detects trends and multiple seasonalities
-#    - Great for business forecasting with daily/weekly/yearly patterns
-#
-# ============================================================================
-# PERFORMANCE CONSIDERATIONS (IMPORTANT!)
-# ============================================================================
-# SARIMA can be VERY SLOW on large datasets because:
-#   - It needs to compute seasonal lags (looking back 's' time steps)
-#   - Computational complexity grows with data size AND seasonal period
-#   - A dataset of 4500 points with s=60 could take 20-60 minutes!
-#
-# SOLUTION: DOWNSAMPLING
-# ----------------------
-# Instead of using every data point, we can use every Nth point.
-# Example: Instead of 4500 minute-by-minute readings, use 75 hourly averages
-#
-# This is like looking at a photo:
-#   - Full resolution (4500 pixels): Very detailed, slow to process
-#   - Thumbnail (75 pixels): Less detail, but captures the main patterns quickly
-#
-# For SARIMA in this code, we downsample to make it run in ~30 seconds
-# instead of 20+ minutes, while still capturing the important patterns.
-#
-# Prophet and ARIMA are faster, so they use the full resolution data.
-# ============================================================================
-
-# ============================================================================
-# REQUIRED PACKAGES
-# ============================================================================
-# Before running this code, install these packages:
-#   pip install prophet statsmodels pandas numpy matplotlib gradio
-
 import numpy as np
 import pandas as pd
 import matplotlib.pyplot as plt
@@ -176,7 +102,7 @@ PROPHET_N_CHANGEPOINTS = 25
 # ============================================================================
 # DATA GENERATION
 # ============================================================================
-# We'll create SYNTHETIC (fake but realistic) environmental sensor data
+# We'll create SYNTHETIC environmental sensor data
 # This simulates what you might see in a space station or submarine!
 #
 # We generate 4 types of measurements:
@@ -186,40 +112,6 @@ PROPHET_N_CHANGEPOINTS = 25
 #   4. PM (Particulate Matter in μg/m³) - tiny particles in the air
 
 def smooth_noise(n_points, low, high, window=30):
-    """
-    Generate smooth random noise.
-
-    WHY SMOOTH NOISE?
-    -----------------
-    Pure random noise looks very jagged and unrealistic. Real sensor data
-    usually has smoother variations. We achieve this by:
-    1. Generating random numbers between 'low' and 'high'
-    2. Applying a "moving average" to smooth them out
-
-    WHAT IS A MOVING AVERAGE?
-    -------------------------
-    Instead of using each random number directly, we replace it with the
-    average of itself and its neighbors. This removes sharp spikes.
-
-    Example with window=3:
-    Original: [10, 2, 8, 4, 6]
-    Smoothed: [6, 6.67, 4.67, 6, 5]  (each value = average of 3 neighbors)
-
-    Parameters:
-    -----------
-    n_points : int
-        How many data points to generate
-    low : float
-        Minimum value for random numbers
-    high : float
-        Maximum value for random numbers
-    window : int
-        How many neighbors to average (bigger = smoother)
-
-    Returns:
-    --------
-    numpy array of smoothed random values
-    """
     # Generate random numbers from a UNIFORM distribution
     # Uniform means every number between low and high is equally likely
     raw_noise = np.random.uniform(low, high, n_points)
@@ -233,31 +125,6 @@ def smooth_noise(n_points, low, high, window=30):
 
 
 def generate_mission_data(seed=42, n_points=4500):
-    """
-    Generate synthetic environmental sensor data.
-
-    This creates realistic-looking data with:
-    - A TREND (gradual increase or decrease over time)
-    - SEASONALITY (repeating daily and weekly patterns)
-    - NOISE (random small variations)
-
-    Parameters:
-    -----------
-    seed : int
-        Random seed for reproducibility (same seed = same data every time)
-    n_points : int
-        How many minutes of data to generate (4500 = ~3 days)
-
-    Returns:
-    --------
-    pandas DataFrame with columns:
-        - ds: datetime timestamp
-        - Time_min: minute number (0, 1, 2, ...)
-        - O2_percent: oxygen percentage
-        - CO2_ppm: carbon dioxide in parts per million
-        - VOCs_ppb: volatile organic compounds in parts per billion
-        - Particulates_ugm3: particulate matter in micrograms per cubic meter
-    """
     # Set random seed so we get the same "random" data each time
     # This is important for reproducibility in science!
     np.random.seed(seed)
@@ -357,33 +224,6 @@ def generate_mission_data(seed=42, n_points=4500):
 # ============================================================================
 
 def downsample_series(series, factor):
-    """
-    Reduce the number of data points by averaging every 'factor' points.
-
-    WHY DOWNSAMPLE?
-    ---------------
-    Some algorithms (like SARIMA) are very slow on large datasets.
-    Downsampling reduces the data size while preserving the overall pattern.
-
-    HOW IT WORKS:
-    -------------
-    Original (factor=3):  [1, 2, 3, 4, 5, 6, 7, 8, 9]
-    Downsampled:          [2, 5, 8]  (average of each group of 3)
-
-    This is similar to how video compression works - instead of storing
-    every frame, store key frames that capture the important information.
-
-    Parameters:
-    -----------
-    series : pandas Series or numpy array
-        The original data
-    factor : int
-        How many points to combine into one (e.g., 60 = hourly from minute data)
-
-    Returns:
-    --------
-    numpy array of downsampled values
-    """
     arr = np.array(series)
     # Calculate how many complete groups we can make
     n_groups = len(arr) // factor
@@ -396,36 +236,6 @@ def downsample_series(series, factor):
 
 
 def upsample_predictions(predictions, factor, target_length):
-    """
-    Expand predictions back to original resolution using interpolation.
-
-    WHY UPSAMPLE?
-    -------------
-    After SARIMA makes predictions on downsampled data, we need to
-    "stretch" those predictions back to match the original data length
-    for fair comparison.
-
-    HOW IT WORKS:
-    -------------
-    Downsampled predictions: [10, 20, 30]  (3 points)
-    Upsampled (factor=3):    [10, 13, 17, 20, 23, 27, 30, ...]  (9 points)
-
-    We use LINEAR INTERPOLATION - drawing straight lines between points
-    and filling in the values along those lines.
-
-    Parameters:
-    -----------
-    predictions : numpy array
-        Predictions from the downsampled model
-    factor : int
-        The downsampling factor used
-    target_length : int
-        The desired output length (original test set size)
-
-    Returns:
-    --------
-    numpy array of upsampled predictions matching target_length
-    """
     # Create x-coordinates for original predictions
     x_original = np.arange(len(predictions)) * factor
 
@@ -443,42 +253,6 @@ def upsample_predictions(predictions, factor, target_length):
 # ============================================================================
 
 def train_prophet(train_df, test_df):
-    """
-    Train a Prophet model and make predictions.
-
-    HOW PROPHET WORKS (Simplified):
-    -------------------------------
-    Prophet breaks down the time series into components:
-
-    y(t) = trend(t) + seasonality(t) + holidays(t) + error(t)
-
-    1. TREND: Prophet fits a piecewise linear trend (like connecting dots
-       with straight lines, but allowing the slope to change at "changepoints")
-
-    2. SEASONALITY: Prophet uses Fourier series (fancy sine/cosine waves)
-       to capture daily, weekly, and yearly patterns
-
-    3. HOLIDAYS: Prophet can account for special events (we don't use this here)
-
-    4. ERROR: The random noise that can't be predicted
-
-    Prophet is great because:
-    - It handles missing data well
-    - It automatically detects seasonality
-    - It's robust to outliers
-    - It's easy to use!
-
-    Parameters:
-    -----------
-    train_df : DataFrame
-        Training data with 'ds' (datetime) and 'y' (value) columns
-    test_df : DataFrame
-        Test data with 'ds' column (we'll predict 'y' values)
-
-    Returns:
-    --------
-    numpy array of predictions for the test period
-    """
     # Create and configure the Prophet model
     model = Prophet(
         growth="linear",              # Use linear trend (not logistic)
@@ -505,51 +279,6 @@ def train_prophet(train_df, test_df):
 
 
 def train_arima(train_series, test_len):
-    """
-    Train an ARIMA model and make predictions.
-
-    HOW ARIMA WORKS (Simplified):
-    -----------------------------
-    ARIMA stands for: AutoRegressive Integrated Moving Average
-
-    Let's break it down:
-
-    1. AR (AutoRegressive): Predict using past values
-       "Tomorrow's temperature depends on today's temperature"
-
-       Formula: y(t) = c + φ1*y(t-1) + φ2*y(t-2) + ... + error
-
-       Where φ (phi) are learned weights for each past value
-
-    2. I (Integrated): Differencing to remove trends
-       Instead of predicting y(t), we predict the CHANGE: y(t) - y(t-1)
-
-       This converts: [100, 102, 105, 109] (trending up)
-       Into:          [2, 3, 4]            (the differences - no trend!)
-
-    3. MA (Moving Average): Predict using past errors
-       "If I was wrong yesterday, adjust today's prediction"
-
-       Formula: y(t) = c + θ1*e(t-1) + θ2*e(t-2) + ... + error
-
-       Where e is the error (actual - predicted) from past forecasts
-
-    ARIMA combines all three: AR + I + MA
-
-    LIMITATION: Basic ARIMA doesn't handle seasonality well!
-    (That's why we have SARIMA)
-
-    Parameters:
-    -----------
-    train_series : pandas Series
-        Historical data to train on
-    test_len : int
-        How many future points to predict
-
-    Returns:
-    --------
-    numpy array of predictions
-    """
     try:
         # Create and fit the ARIMA model
         model = ARIMA(train_series, order=ARIMA_ORDER)
@@ -569,50 +298,6 @@ def train_arima(train_series, test_len):
 
 
 def train_sarima(train_series, test_len, original_test_len):
-    """
-    Train a SARIMA model on DOWNSAMPLED data for speed, then upsample predictions.
-
-    HOW SARIMA WORKS (Simplified):
-    ------------------------------
-    SARIMA = Seasonal ARIMA = ARIMA + Seasonal components
-
-    It adds seasonal versions of AR, I, and MA:
-
-    Regular ARIMA(p,d,q) handles: trends and short-term patterns
-    Seasonal (P,D,Q,s) handles: repeating seasonal patterns
-
-    Example with daily temperature (s=365 for yearly seasonality):
-    - Regular AR: "Today's temp depends on yesterday's temp"
-    - Seasonal AR: "Today's temp also depends on this day LAST YEAR"
-
-    The seasonal differencing (D) removes seasonal trends:
-    Instead of: y(t) - y(t-1)          [regular differencing]
-    We use:     y(t) - y(t-s)          [seasonal differencing]
-
-    This removes patterns like "summer is always hotter than winter"
-
-    SPEED OPTIMIZATION:
-    -------------------
-    SARIMA is slow on large datasets. To speed it up:
-    1. We DOWNSAMPLE the training data (e.g., minute → hourly)
-    2. Train on the smaller dataset (much faster!)
-    3. UPSAMPLE the predictions back to original resolution
-
-    This trades a small amount of accuracy for a HUGE speed improvement.
-
-    Parameters:
-    -----------
-    train_series : pandas Series
-        DOWNSAMPLED historical data to train on
-    test_len : int
-        How many DOWNSAMPLED points to predict
-    original_test_len : int
-        Original test length (for upsampling predictions)
-
-    Returns:
-    --------
-    numpy array of predictions (upsampled to original resolution)
-    """
     try:
         # Create and fit the SARIMA model (called SARIMAX in statsmodels)
         # The X in SARIMAX stands for "eXogenous variables" (external factors)
@@ -655,28 +340,6 @@ def train_sarima(train_series, test_len, original_test_len):
 # ============================================================================
 
 def run_prediction(seed, model_choice):
-    """
-    Main function that orchestrates the entire prediction pipeline.
-
-    Steps:
-    1. Generate synthetic data
-    2. Split into training and test sets
-    3. Train selected model(s)
-    4. Make predictions
-    5. Calculate accuracy metrics
-    6. Create visualizations
-
-    Parameters:
-    -----------
-    seed : int
-        Random seed for data generation
-    model_choice : str
-        Which model to use: "Prophet", "ARIMA", "SARIMA", or "All"
-
-    Returns:
-    --------
-    tuple: (metrics_dataframe, seed_string, matplotlib_figure)
-    """
     # ========================================================================
     # STEP 1: Generate Data
     # ========================================================================