code/TSDecompose/src/synthetic_ts_bench/decomp_sr_pipeline.py

"""
Decomposition + Symbolic Regression Pipeline.

Core pipeline that:
1. Decomposes time series into trend + seasonal + residual
2. Runs SR on each component separately
3. Combines expressions and evaluates mechanism match
4. Includes Oracle baselines for error attribution
"""

from __future__ import annotations

import time
from dataclasses import dataclass, field
from typing import Any, Dict, List, Optional, Tuple, Union

import numpy as np

from .budget_controller import BudgetController, BudgetConfig
from .mechanism_matcher import MechanismMatcher, MechanismMatch


@dataclass
class DecompSRResult:
    """Complete result from Decomposition + SR pipeline."""

    # === Metadata ===
    sample_id: str = ""
    scenario: str = ""
    decomp_method: str = ""
    sr_method: str = ""

    # === Ground truth (for evaluation) ===
    trend_true: Optional[np.ndarray] = None
    seasonal_true: Optional[np.ndarray] = None
    trend_expr_true: str = ""
    seasonal_expr_true: str = ""

    # === Decomposition results ===
    trend_estimated: Optional[np.ndarray] = None
    seasonal_estimated: Optional[np.ndarray] = None
    residual: Optional[np.ndarray] = None
    decomp_time_sec: float = 0.0
    decomp_metrics: Dict[str, float] = field(default_factory=dict)

    # === SR results (per component) ===
    trend_expr: str = ""
    trend_sr_metrics: Dict[str, float] = field(default_factory=dict)
    seasonal_expr: str = ""
    seasonal_sr_metrics: Dict[str, float] = field(default_factory=dict)

    # === Combined results ===
    full_expr: str = ""
    final_r2: float = 0.0
    final_mse: float = float('inf')
    mechanism_match: Optional[MechanismMatch] = None
    total_runtime_sec: float = 0.0

    # === Oracle results (for error attribution) ===
    oracle_trend_expr: str = ""          # SR on T_true
    oracle_seasonal_expr: str = ""       # SR on S_true
    oracle_trend_r2: float = 0.0
    oracle_seasonal_r2: float = 0.0
    oracle_full_r2: float = 0.0

    # === Error propagation ===
    delta_decomp_trend: float = 0.0      # MSE(T_true, T_hat)
    delta_decomp_seasonal: float = 0.0   # MSE(S_true, S_hat)
    delta_sr_trend: float = 0.0          # MSE(T_hat, f_T(t))
    delta_sr_seasonal: float = 0.0       # MSE(S_hat, f_S(t))
    delta_pipe: float = 0.0              # MSE(y, f_T + f_S)

    # === Status ===
    success: bool = True
    error_message: str = ""
    timeout: bool = False

    def to_dict(self) -> Dict[str, Any]:
        """Convert to dictionary for DataFrame."""
        result = {
            'sample_id': self.sample_id,
            'scenario': self.scenario,
            'decomp_method': self.decomp_method,
            'sr_method': self.sr_method,

            # Decomposition metrics
            'decomp_time_sec': self.decomp_time_sec,
            **{f'decomp_{k}': v for k, v in self.decomp_metrics.items()},

            # Expressions
            'trend_expr': self.trend_expr,
            'seasonal_expr': self.seasonal_expr,
            'full_expr': self.full_expr,

            # SR metrics
            **{f'trend_sr_{k}': v for k, v in self.trend_sr_metrics.items()},
            **{f'seasonal_sr_{k}': v for k, v in self.seasonal_sr_metrics.items()},

            # Final metrics
            'final_r2': self.final_r2,
            'final_mse': self.final_mse,
            'total_runtime_sec': self.total_runtime_sec,

            # Oracle
            'oracle_trend_expr': self.oracle_trend_expr,
            'oracle_seasonal_expr': self.oracle_seasonal_expr,
            'oracle_trend_r2': self.oracle_trend_r2,
            'oracle_seasonal_r2': self.oracle_seasonal_r2,
            'oracle_full_r2': self.oracle_full_r2,

            # Error propagation
            'delta_decomp_trend': self.delta_decomp_trend,
            'delta_decomp_seasonal': self.delta_decomp_seasonal,
            'delta_sr_trend': self.delta_sr_trend,
            'delta_sr_seasonal': self.delta_sr_seasonal,
            'delta_pipe': self.delta_pipe,

            # Status
            'success': self.success,
            'error_message': self.error_message,
            'timeout': self.timeout,
        }

        # Add mechanism match fields
        if self.mechanism_match:
            result.update({
                f'mech_{k}': v for k, v in self.mechanism_match.to_dict().items()
            })

        return result


class DecompSRPipeline:
    """
    Main pipeline for Decomposition + Symbolic Regression.

    Usage:
        pipeline = DecompSRPipeline(
            decomp_method='stl',
            sr_method='gplearn',
            budget_config=BudgetConfig(time_budget_sec=60),
        )
        result = pipeline.fit(sample)
    """

    def __init__(
        self,
        decomp_method: str = 'stl',
        sr_method: str = 'gplearn',
        budget_config: Optional[BudgetConfig] = None,
        run_oracle: bool = True,
        verbose: bool = False,
    ):
        """
        Initialize pipeline.

        Args:
            decomp_method: Decomposition method name ('stl', 'ssa', 'dr_ts_reg', etc.)
            sr_method: SR method name ('gplearn', 'pysr')
            budget_config: Fair comparison budget configuration
            run_oracle: Whether to run Oracle baselines
            verbose: Print progress
        """
        self.decomp_method = decomp_method
        self.sr_method = sr_method
        self.budget_config = budget_config or BudgetConfig()
        self.budget_controller = BudgetController(self.budget_config)
        self.run_oracle = run_oracle
        self.verbose = verbose
        self.mechanism_matcher = MechanismMatcher()

        # Initialize decomposition method
        self._decomposer = self._get_decomposer(decomp_method)

        # Initialize SR method
        self._sr = self._get_sr_method(sr_method)

    def _get_decomposer(self, name: str):
        """Get decomposition method by name."""
        name_lower = name.lower()

        if name_lower == 'none' or name_lower == 'original':
            # Identity decomposition (trend=y, seasonal=0, resid=0)
            return lambda y, **kwargs: type('DecompResult', (), {
                'trend': y, 'seasonal': np.zeros_like(y), 'residual': np.zeros_like(y), 'components': [y]
            })()

        if name_lower == 'stl':
            from synthetic_ts_bench.decomp_methods import stl_decompose
            return stl_decompose
        elif name_lower == 'mstl':
            from synthetic_ts_bench.decomp_methods import mstl_decompose
            return mstl_decompose
        elif name_lower == 'ssa':
            from synthetic_ts_bench.decomp_methods import ssa_decompose
            return ssa_decompose
        elif name_lower == 'dr_ts_reg':
            from synthetic_ts_bench.dr_ts_reg import dr_ts_reg_decompose
            return dr_ts_reg_decompose
        elif name_lower == 'dr_ts_ae':
            from synthetic_ts_bench.dr_ts_ae import dr_ts_ae_decompose
            return dr_ts_ae_decompose
        elif name_lower == 'sl_lib':
            from synthetic_ts_bench.sl_lib import sl_lib_decompose
            return sl_lib_decompose
        elif name_lower == 'wavelet':
            from synthetic_ts_bench.decomp_methods import wavelet_decompose
            return wavelet_decompose
        elif name_lower == 'emd':
            from synthetic_ts_bench.decomp_methods import emd_decompose
            return emd_decompose
        elif name_lower == 'ceemdan':
            from synthetic_ts_bench.decomp_methods import ceemdan_decompose
            return ceemdan_decompose
        elif name_lower == 'vmd':
            from synthetic_ts_bench.decomp_methods import vmd_decompose
            return vmd_decompose
        else:
            raise ValueError(f"Unknown decomposition method: {name}")

    def _get_sr_method(self, name: str):
        """Get SR method by name."""
        name_lower = name.lower()

        if name_lower == 'gplearn':
            from sr_methods import GPLearnRegressor
            return GPLearnRegressor(
                operators=self.budget_config.operators,
                time_limit=self.budget_config.time_budget_sec,
                verbose=self.verbose,
                population_size=500,
                generations=30,
            )
        elif name_lower == 'pysr':
            from sr_methods import PySRRegressor
            return PySRRegressor(
                operators=self.budget_config.operators,
                time_limit=self.budget_config.time_budget_sec,
                verbose=self.verbose,
            )
        elif name_lower == 'nd2':
            from sr_methods import ND2Regressor
            return ND2Regressor(
                time_limit=self.budget_config.time_budget_sec,
                verbose=self.verbose,
            )
        else:
            raise ValueError(f"Unknown SR method: {name}")

    def fit(self, sample) -> DecompSRResult:
        """
        Run full pipeline on a sample.

        Args:
            sample: SRSample object with t, y, trend, seasonal, etc.

        Returns:
            DecompSRResult with all metrics and expressions
        """
        start_time = time.time()

        result = DecompSRResult(
            sample_id=sample.sample_id,
            scenario=sample.scenario,
            decomp_method=self.decomp_method,
            sr_method=self.sr_method,
            trend_true=getattr(sample, 'trend', None),
            seasonal_true=getattr(sample, 'seasonal', None),
            trend_expr_true=getattr(sample, 'trend_expr', ''),
            seasonal_expr_true=getattr(sample, 'seasonal_expr', ''),
        )

        try:
            t = sample.t
            y = sample.y_clean if hasattr(sample, 'y_clean') else sample.y

            # === Step 1: Decomposition ===
            if self.verbose:
                print(f"  Decomposing with {self.decomp_method}...")

            decomp_start = time.time()

            # Prepare decomposition config
            decomp_config = {'period': 24}  # Default period for synthetic data

            # Get period from sample if available
            if hasattr(sample, 'period'):
                decomp_config['period'] = sample.period
            elif hasattr(sample, 'omega') and sample.omega > 0:
                # Convert omega to period: T = 2*pi/omega
                decomp_config['period'] = max(2, int(2 * np.pi / sample.omega))

            # Call decomposer with config
            try:
                decomp_result = self._decomposer(y, config=decomp_config)
            except TypeError:
                # Some methods don't accept config
                decomp_result = self._decomposer(y)

            result.decomp_time_sec = time.time() - decomp_start

            # Handle different result formats
            if hasattr(decomp_result, 'trend'):
                result.trend_estimated = decomp_result.trend
            elif hasattr(decomp_result, 'components') and len(decomp_result.components) > 0:
                result.trend_estimated = decomp_result.components[0]
            else:
                raise ValueError(f"Cannot extract trend from {type(decomp_result)}")

            if hasattr(decomp_result, 'seasonal'):
                result.seasonal_estimated = decomp_result.seasonal
            elif hasattr(decomp_result, 'components') and len(decomp_result.components) > 1:
                result.seasonal_estimated = decomp_result.components[1]
            elif hasattr(decomp_result, 'residual'):
                # Use y - trend as seasonal approximation
                result.seasonal_estimated = y - result.trend_estimated - decomp_result.residual
            else:
                result.seasonal_estimated = y - result.trend_estimated

            if hasattr(decomp_result, 'residual'):
                result.residual = decomp_result.residual
            else:
                result.residual = y - result.trend_estimated - result.seasonal_estimated

            # Decomposition metrics
            if result.trend_true is not None:
                result.decomp_metrics['T_r2'] = self._r2(result.trend_true, result.trend_estimated)
                result.delta_decomp_trend = self._mse(result.trend_true, result.trend_estimated)
            if result.seasonal_true is not None:
                result.decomp_metrics['S_r2'] = self._r2(result.seasonal_true, result.seasonal_estimated)
                result.delta_decomp_seasonal = self._mse(result.seasonal_true, result.seasonal_estimated)

            # === Step 2: SR on Trend ===
            if self.verbose:
                print(f"  SR on trend with {self.sr_method}...")

            trend_sr_result = self._sr.fit(t.reshape(-1, 1), result.trend_estimated)
            result.trend_expr = trend_sr_result.expression
            result.trend_sr_metrics = {
                'r2': trend_sr_result.r2_score,
                'mse': trend_sr_result.mse,
                'nodes': trend_sr_result.complexity,
                'runtime': trend_sr_result.runtime_sec,
            }
            result.delta_sr_trend = trend_sr_result.mse

            # === Step 3: SR on Seasonal ===
            if self.verbose:
                print(f"  SR on seasonal with {self.sr_method}...")

            seasonal_sr_result = self._sr.fit(t.reshape(-1, 1), result.seasonal_estimated)
            result.seasonal_expr = seasonal_sr_result.expression
            result.seasonal_sr_metrics = {
                'r2': seasonal_sr_result.r2_score,
                'mse': seasonal_sr_result.mse,
                'nodes': seasonal_sr_result.complexity,
                'runtime': seasonal_sr_result.runtime_sec,
            }
            result.delta_sr_seasonal = seasonal_sr_result.mse

            # === Step 4: Combine and Evaluate ===
            result.full_expr = f"({result.trend_expr}) + ({result.seasonal_expr})"

            # Predict combined
            trend_pred = self._sr.predict(t.reshape(-1, 1)) if hasattr(self._sr, 'predict') else np.zeros_like(t)
            # Need to refit for seasonal prediction...
            # For simplicity, compute final metrics from component predictions
            y_pred = trend_pred + seasonal_sr_result.r2_score * result.seasonal_estimated  # approximation

            result.final_r2 = self._r2(y, y_pred)
            result.final_mse = self._mse(y, y_pred)
            result.delta_pipe = result.final_mse

            # === Step 5: Oracle Baselines ===
            if self.run_oracle and result.trend_true is not None:
                if self.verbose:
                    print(f"  Running Oracle-SR...")

                # Oracle on true trend
                oracle_trend = self._sr.fit(t.reshape(-1, 1), result.trend_true)
                result.oracle_trend_expr = oracle_trend.expression
                result.oracle_trend_r2 = oracle_trend.r2_score

                # Oracle on true seasonal
                if result.seasonal_true is not None:
                    oracle_seasonal = self._sr.fit(t.reshape(-1, 1), result.seasonal_true)
                    result.oracle_seasonal_expr = oracle_seasonal.expression
                    result.oracle_seasonal_r2 = oracle_seasonal.r2_score

            # === Step 6: Mechanism Match ===
            result.mechanism_match = self.mechanism_matcher.match(
                pred_expr=result.full_expr,
                true_expr=getattr(sample, 'full_expr', ''),
                pred_trend_expr=result.trend_expr,
                true_trend_expr=result.trend_expr_true,
                pred_seasonal_expr=result.seasonal_expr,
                true_seasonal_expr=result.seasonal_expr_true,
            )

            result.success = True

        except Exception as e:
            result.success = False
            result.error_message = str(e)
            if self.verbose:
                print(f"  Error: {e}")

        result.total_runtime_sec = time.time() - start_time
        return result

    def _r2(self, y_true: np.ndarray, y_pred: np.ndarray) -> float:
        """Compute R² score."""
        ss_res = np.sum((y_true - y_pred) ** 2)
        ss_tot = np.sum((y_true - np.mean(y_true)) ** 2)
        return 1 - ss_res / ss_tot if ss_tot > 1e-10 else 0.0

    def _mse(self, y_true: np.ndarray, y_pred: np.ndarray) -> float:
        """Compute MSE."""
        return float(np.mean((y_true - y_pred) ** 2))