dfm-python 0.1.5__tar.gz → 0.1.6__tar.gz

{dfm_python-0.1.5 → dfm_python-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dfm-python
-Version: 0.1.5
+Version: 0.1.6
 Summary: Dynamic Factor Model (DFM) estimation and nowcasting in Python
 Project-URL: Homepage, https://github.com/yourusername/dfm-python
 Project-URL: Documentation, https://github.com/yourusername/dfm-python#readme
@@ -555,7 +555,7 @@ If you use this package in your research, please cite:
 @software{dfm-python,
   title = {dfm-python: Dynamic Factor Models for Nowcasting and Forecasting},
   author = {DFM Python Contributors},
-  year = {2024},
+  year = {2025},
   url = {https://pypi.org/project/dfm-python/},
   version = {0.1.5}
 }

{dfm_python-0.1.5 → dfm_python-0.1.6}/README.md

@@ -513,7 +513,7 @@ If you use this package in your research, please cite:
 @software{dfm-python,
   title = {dfm-python: Dynamic Factor Models for Nowcasting and Forecasting},
   author = {DFM Python Contributors},
-  year = {2024},
+  year = {2025},
   url = {https://pypi.org/project/dfm-python/},
   version = {0.1.5}
 }

{dfm_python-0.1.5 → dfm_python-0.1.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "dfm-python"
-version = "0.1.5"
+version = "0.1.6"
 description = "Dynamic Factor Model (DFM) estimation and nowcasting in Python"
 readme = "README.md"
 requires-python = ">=3.12"

{dfm_python-0.1.5 → dfm_python-0.1.6}/src/dfm_python/__init__.py

@@ -30,13 +30,13 @@ Example:
 For detailed documentation, see the README.md file.
 """
 
-__version__ = "0.1.4"
+__version__ = "0.1.6"
 
 from .config import DFMConfig
 from .data_loader import (
     load_config, load_config_from_yaml, load_config_from_csv, load_data, transform_data
 )
-from .dfm import DFMResult, dfm, calculate_rmse
+from .dfm import DFMResult, dfm, calculate_rmse, diagnose_series, print_series_diagnosis
 from .kalman import run_kf, skf, fis, miss_data
 from .news import update_nowcast, news_dfm, para_const
 
@@ -51,7 +51,7 @@ __all__ = [
     'ModelConfig',  # Alias for DFMConfig
     'load_config', 'load_config_from_yaml', 'load_config_from_csv',
     'load_data', 'transform_data',
-    'DFMResult', 'dfm', 'calculate_rmse',
+    'DFMResult', 'dfm', 'calculate_rmse', 'diagnose_series', 'print_series_diagnosis',
     'run_kf', 'skf', 'fis', 'miss_data',
     'update_nowcast', 'news_dfm', 'para_const',
     # Deprecated aliases

{dfm_python-0.1.5 → dfm_python-0.1.6}/src/dfm_python/dfm.py

@@ -646,6 +646,20 @@ class DFMResult:
         how many factors are in each block structure.
     p : int
         Number of lags in the autoregressive structure of factors. Typically p=1.
+    rmse : float, optional
+        Overall RMSE on original scale (averaged across all series).
+    rmse_per_series : np.ndarray, optional
+        RMSE per series on original scale (N,).
+    rmse_std : float, optional
+        Overall RMSE on standardized scale (averaged across all series).
+    rmse_std_per_series : np.ndarray, optional
+        RMSE per series on standardized scale (N,).
+    converged : bool, optional
+        Whether EM algorithm converged.
+    num_iter : int, optional
+        Number of EM iterations performed.
+    loglik : float, optional
+        Final log-likelihood value.
     
     Examples
     --------
@@ -673,8 +687,10 @@ class DFMResult:
     converged: bool = False  # Whether EM algorithm converged
     num_iter: int = 0     # Number of iterations completed
     loglik: float = -np.inf  # Final log-likelihood
-    rmse: Optional[float] = None  # Root Mean Squared Error (averaged across all series)
-    rmse_per_series: Optional[np.ndarray] = None  # RMSE per series (N,)
+    rmse: Optional[float] = None  # Overall RMSE (original scale)
+    rmse_per_series: Optional[np.ndarray] = None  # RMSE per series (original scale)
+    rmse_std: Optional[float] = None  # Overall RMSE (standardized scale)
+    rmse_std_per_series: Optional[np.ndarray] = None  # RMSE per series (standardized scale)
 
 
 def em_converged(loglik: float, previous_loglik: float, threshold: float = 1e-4,
@@ -1729,12 +1745,11 @@ def em_step(y: np.ndarray, A: np.ndarray, C: np.ndarray, Q: np.ndarray,
     num_blocks = blocks.shape[1]
     
     # Get config defaults if not provided
+    # Create a minimal config object with defaults for backward compatibility
+    # We use a simple object to avoid DFMConfig validation which requires series
     if config is None:
-        # Create a minimal config with defaults for backward compatibility
-        from dfm_python.config import DFMConfig
-        config = DFMConfig(
-            series=[],
-            block_names=[],
+        from types import SimpleNamespace
+        config = SimpleNamespace(
             clip_ar_coefficients=True,
             ar_clip_min=-0.99,
             ar_clip_max=0.99,
@@ -2953,6 +2968,12 @@ def dfm(X: np.ndarray, config: DFMConfig, threshold: Optional[float] = None, max
     # Only use non-missing observations for comparison
     rmse_overall, rmse_per_series = calculate_rmse(X, X_sm, mask=None)
     
+    # Calculate standardized RMSE for better comparison across series
+    # Standardize both actual and predicted using the same Wx and Mx
+    X_std = (X - Mx_clean) / np.where(Wx_clean != 0, Wx_clean, 1.0)
+    x_sm_std = x_sm  # Already standardized
+    rmse_std_overall, rmse_std_per_series = calculate_rmse(X_std, x_sm_std, mask=None)
+    
     # Create result structure
     Res = DFMResult(
         x_sm=x_sm,
@@ -2972,7 +2993,9 @@ def dfm(X: np.ndarray, config: DFMConfig, threshold: Optional[float] = None, max
         num_iter=num_iter,
         loglik=loglik,
         rmse=rmse_overall,
-        rmse_per_series=rmse_per_series
+        rmse_per_series=rmse_per_series,
+        rmse_std=rmse_std_overall,
+        rmse_std_per_series=rmse_std_per_series
     )
     
     # Display output tables (optional - can be disabled for cleaner output)
@@ -3099,22 +3122,243 @@ def _display_dfm_tables(Res: DFMResult, config, nQ: int) -> None:
         # Table 8: Model Fit Statistics (RMSE)
         if Res.rmse is not None and not np.isnan(Res.rmse):
             print('Table 8: Model Fit Statistics')
-            print(f'  Overall RMSE (averaged across all series): {Res.rmse:.6f}')
+            print(f'  Overall RMSE (original scale): {Res.rmse:.6f}')
+            if Res.rmse_std is not None and not np.isnan(Res.rmse_std):
+                print(f'  Overall RMSE (standardized scale): {Res.rmse_std:.6f}')
             if Res.rmse_per_series is not None and len(Res.rmse_per_series) > 0:
-                print('\n  RMSE per Series:')
+                print('\n  RMSE per Series (Original Scale):')
                 try:
                     series_names = config.SeriesName if hasattr(config, 'SeriesName') else [f"Series_{i}" for i in range(len(Res.rmse_per_series))]
                     for i, (name, rmse_val) in enumerate(zip(series_names, Res.rmse_per_series)):
                         if not np.isnan(rmse_val):
-                            print(f'    {name:40s}: {rmse_val:.6f}')
+                            # Calculate RMSE as percentage of mean if available
+                            mean_val = Res.Mx[i] if i < len(Res.Mx) else np.nan
+                            if not np.isnan(mean_val) and abs(mean_val) > 1e-6:
+                                pct = 100.0 * rmse_val / abs(mean_val)
+                                print(f'    {name:40s}: {rmse_val:.6f} ({pct:.2f}% of mean)')
+                            else:
+                                print(f'    {name:40s}: {rmse_val:.6f}')
                 except Exception:
                     # Fallback if series names not available
                     for i, rmse_val in enumerate(Res.rmse_per_series):
                         if not np.isnan(rmse_val):
                             print(f'    Series {i:3d}: {rmse_val:.6f}')
+            
+            # Show standardized RMSE per series
+            if Res.rmse_std_per_series is not None and len(Res.rmse_std_per_series) > 0:
+                print('\n  RMSE per Series (Standardized Scale):')
+                try:
+                    series_names = config.SeriesName if hasattr(config, 'SeriesName') else [f"Series_{i}" for i in range(len(Res.rmse_std_per_series))]
+                    for i, (name, rmse_std_val) in enumerate(zip(series_names, Res.rmse_std_per_series)):
+                        if not np.isnan(rmse_std_val):
+                            print(f'    {name:40s}: {rmse_std_val:.6f} std dev')
+                except Exception:
+                    # Fallback if series names not available
+                    for i, rmse_std_val in enumerate(Res.rmse_std_per_series):
+                        if not np.isnan(rmse_std_val):
+                            print(f'    Series {i:3d}: {rmse_std_val:.6f} std dev')
+            
+            # Diagnostic warnings for high RMSE
+            if Res.rmse_per_series is not None and Res.Mx is not None:
+                print('\n  Diagnostic Warnings:')
+                try:
+                    series_names = config.SeriesName if hasattr(config, 'SeriesName') else [f"Series_{i}" for i in range(len(Res.rmse_per_series))]
+                    warnings_count = 0
+                    for i, (name, rmse_val) in enumerate(zip(series_names, Res.rmse_per_series)):
+                        if not np.isnan(rmse_val) and i < len(Res.Mx):
+                            mean_val = Res.Mx[i]
+                            std_val = Res.Wx[i] if i < len(Res.Wx) else np.nan
+                            if not np.isnan(mean_val) and abs(mean_val) > 1e-6:
+                                pct_of_mean = 100.0 * rmse_val / abs(mean_val)
+                                # Warn if RMSE > 50% of mean or > 10 standard deviations
+                                if pct_of_mean > 50.0 or (not np.isnan(std_val) and rmse_val > 10.0 * std_val):
+                                    warnings_count += 1
+                                    if warnings_count <= 5:  # Limit to first 5 warnings
+                                        print(f'    ⚠ {name:40s}: RMSE is {pct_of_mean:.1f}% of mean')
+                                        if not np.isnan(std_val):
+                                            print(f'      (RMSE={rmse_val:.2e}, Mean={mean_val:.2e}, Std={std_val:.2e})')
+                    if warnings_count > 5:
+                        print(f'    ... and {warnings_count - 5} more series with high RMSE')
+                except Exception:
+                    pass
             print('\n\n\n')
         
     except Exception as e:
         print(f'Error displaying tables: {e}')
         pass
 
+
+def diagnose_series(Res: DFMResult, config: DFMConfig, series_name: Optional[str] = None, 
+                    series_idx: Optional[int] = None) -> Dict[str, Any]:
+    """Diagnose model fit issues for a specific series.
+    
+    This function provides detailed diagnostics to help identify why a series
+    may have high RMSE, including factor loadings, standardization values,
+    and reconstruction errors.
+    
+    Parameters
+    ----------
+    Res : DFMResult
+        DFM estimation results
+    config : DFMConfig
+        DFM configuration
+    series_name : str, optional
+        Name of the series to diagnose. If provided, series_idx is ignored.
+    series_idx : int, optional
+        Index of the series to diagnose (0-based). Used if series_name is not provided.
+        
+    Returns
+    -------
+    dict
+        Dictionary containing diagnostic information:
+        - 'series_name': Name of the series
+        - 'series_idx': Index of the series
+        - 'rmse_original': RMSE on original scale
+        - 'rmse_standardized': RMSE on standardized scale
+        - 'mean': Series mean (Mx)
+        - 'std': Series standard deviation (Wx)
+        - 'rmse_pct_of_mean': RMSE as percentage of mean
+        - 'rmse_in_std_devs': RMSE in standard deviations
+        - 'factor_loadings': Factor loadings for this series
+        - 'max_loading': Maximum absolute loading
+        - 'loading_sum_sq': Sum of squared loadings
+        - 'reconstruction_error_mean': Mean reconstruction error
+        - 'reconstruction_error_std': Std of reconstruction error
+        
+    Examples
+    --------
+    >>> Res = dfm(X, config)
+    >>> diag = diagnose_series(Res, config, series_name="Real GDP")
+    >>> print(f"Standardized RMSE: {diag['rmse_standardized']:.4f}")
+    """
+    # Find series index
+    if series_name is not None:
+        try:
+            series_names = config.SeriesName if hasattr(config, 'SeriesName') else []
+            if series_name in series_names:
+                series_idx = series_names.index(series_name)
+            else:
+                # Try case-insensitive match
+                series_idx = next((i for i, name in enumerate(series_names) 
+                                 if name.lower() == series_name.lower()), None)
+                if series_idx is None:
+                    raise ValueError(f"Series '{series_name}' not found in configuration")
+        except (AttributeError, ValueError) as e:
+            raise ValueError(f"Cannot find series '{series_name}': {e}")
+    
+    if series_idx is None:
+        raise ValueError("Must provide either series_name or series_idx")
+    
+    if series_idx < 0 or series_idx >= Res.C.shape[0]:
+        raise ValueError(f"Series index {series_idx} out of range [0, {Res.C.shape[0]})")
+    
+    # Get series name
+    try:
+        series_names = config.SeriesName if hasattr(config, 'SeriesName') else []
+        name = series_names[series_idx] if series_idx < len(series_names) else f"Series_{series_idx}"
+    except (AttributeError, IndexError):
+        name = f"Series_{series_idx}"
+    
+    # Get RMSE values
+    rmse_original = None
+    rmse_standardized = None
+    if Res.rmse_per_series is not None and series_idx < len(Res.rmse_per_series):
+        rmse_original = Res.rmse_per_series[series_idx]
+    if Res.rmse_std_per_series is not None and series_idx < len(Res.rmse_std_per_series):
+        rmse_standardized = Res.rmse_std_per_series[series_idx]
+    
+    # Get standardization values
+    mean_val = Res.Mx[series_idx] if series_idx < len(Res.Mx) else np.nan
+    std_val = Res.Wx[series_idx] if series_idx < len(Res.Wx) else np.nan
+    
+    # Calculate RMSE metrics
+    rmse_pct_of_mean = None
+    rmse_in_std_devs = None
+    if not np.isnan(rmse_original) and not np.isnan(mean_val) and abs(mean_val) > 1e-6:
+        rmse_pct_of_mean = 100.0 * rmse_original / abs(mean_val)
+    if not np.isnan(rmse_original) and not np.isnan(std_val) and std_val > 1e-6:
+        rmse_in_std_devs = rmse_original / std_val
+    
+    # Get factor loadings
+    factor_loadings = Res.C[series_idx, :] if series_idx < Res.C.shape[0] else np.array([])
+    max_loading = np.max(np.abs(factor_loadings)) if len(factor_loadings) > 0 else np.nan
+    loading_sum_sq = np.sum(factor_loadings ** 2) if len(factor_loadings) > 0 else np.nan
+    
+    # Calculate reconstruction errors (if we have original data)
+    reconstruction_error_mean = None
+    reconstruction_error_std = None
+    # Note: We don't have access to original X here, so we can't calculate this
+    # This would require passing X to the function or storing it in Res
+    
+    return {
+        'series_name': name,
+        'series_idx': series_idx,
+        'rmse_original': rmse_original,
+        'rmse_standardized': rmse_standardized,
+        'mean': mean_val,
+        'std': std_val,
+        'rmse_pct_of_mean': rmse_pct_of_mean,
+        'rmse_in_std_devs': rmse_in_std_devs,
+        'factor_loadings': factor_loadings,
+        'max_loading': max_loading,
+        'loading_sum_sq': loading_sum_sq,
+        'reconstruction_error_mean': reconstruction_error_mean,
+        'reconstruction_error_std': reconstruction_error_std
+    }
+
+
+def print_series_diagnosis(Res: DFMResult, config: DFMConfig, 
+                          series_name: Optional[str] = None, 
+                          series_idx: Optional[int] = None) -> None:
+    """Print a formatted diagnosis report for a specific series.
+    
+    Parameters
+    ----------
+    Res : DFMResult
+        DFM estimation results
+    config : DFMConfig
+        DFM configuration
+    series_name : str, optional
+        Name of the series to diagnose
+    series_idx : int, optional
+        Index of the series to diagnose
+        
+    Examples
+    --------
+    >>> Res = dfm(X, config)
+    >>> print_series_diagnosis(Res, config, series_name="Real GDP")
+    """
+    diag = diagnose_series(Res, config, series_name=series_name, series_idx=series_idx)
+    
+    print(f"\n{'='*70}")
+    print(f"DIAGNOSTIC REPORT: {diag['series_name']}")
+    print(f"{'='*70}\n")
+    
+    print("RMSE Statistics:")
+    print(f"  Original scale:     {diag['rmse_original']:.6e}" if diag['rmse_original'] is not None else "  Original scale:     N/A")
+    print(f"  Standardized scale: {diag['rmse_standardized']:.6f} std dev" if diag['rmse_standardized'] is not None else "  Standardized scale: N/A")
+    if diag['rmse_pct_of_mean'] is not None:
+        print(f"  As % of mean:       {diag['rmse_pct_of_mean']:.2f}%")
+    if diag['rmse_in_std_devs'] is not None:
+        print(f"  In std deviations: {diag['rmse_in_std_devs']:.2f}x")
+    
+    print("\nStandardization Values:")
+    print(f"  Mean:  {diag['mean']:.6e}" if not np.isnan(diag['mean']) else "  Mean:  N/A")
+    print(f"  Std:   {diag['std']:.6e}" if not np.isnan(diag['std']) else "  Std:   N/A")
+    
+    print("\nFactor Loadings:")
+    if len(diag['factor_loadings']) > 0:
+        print(f"  Number of loadings: {len(diag['factor_loadings'])}")
+        print(f"  Max absolute:       {diag['max_loading']:.6f}" if not np.isnan(diag['max_loading']) else "  Max absolute:       N/A")
+        print(f"  Sum of squares:     {diag['loading_sum_sq']:.6f}" if not np.isnan(diag['loading_sum_sq']) else "  Sum of squares:     N/A")
+        # Show top 5 loadings
+        abs_loadings = np.abs(diag['factor_loadings'])
+        top_indices = np.argsort(abs_loadings)[-5:][::-1]
+        print(f"  Top 5 loadings:")
+        for idx in top_indices:
+            print(f"    Factor {idx:3d}: {diag['factor_loadings'][idx]:8.4f}")
+    else:
+        print("  No loadings available")
+    
+    print(f"\n{'='*70}\n")
+

dfm_python-0.1.5/test_comprehensive.py

@@ -1,510 +0,0 @@
-"""Comprehensive test suite for DFM package with various parameters and situations."""
-
-import numpy as np
-import pandas as pd
-from pathlib import Path
-import sys
-import warnings
-
-# Add src to path
-project_root = Path(__file__).parent
-sys.path.insert(0, str(project_root / 'src'))
-
-from dfm_python import load_config, load_data, dfm
-from dfm_python.config import DFMConfig, SeriesConfig
-from dfm_python.dfm import init_conditions, em_step
-from dfm_python.kalman import run_kf
-
-warnings.filterwarnings('ignore')
-
-import logging
-logging.getLogger('dfm_python').setLevel(logging.ERROR)  # Suppress INFO/WARNING logs
-
-def create_test_data(T=100, N=10, seed=42, missing_rate=0.1):
-    """Create synthetic test data."""
-    np.random.seed(seed)
-    # Generate data with some structure
-    factors = np.random.randn(T, 2)
-    loadings = np.random.randn(N, 2) * 0.5
-    X = factors @ loadings.T + np.random.randn(T, N) * 0.3
-    
-    # Add missing values
-    if missing_rate > 0:
-        missing_mask = np.random.rand(T, N) < missing_rate
-        X[missing_mask] = np.nan
-    
-    return X
-
-def create_test_config(series_freqs, clock='m', block_names=None, factors_per_block=None):
-    """Create test configuration."""
-    if block_names is None:
-        block_names = ['Global', 'Block1']
-    if factors_per_block is None:
-        factors_per_block = [1, 1]
-    
-    N = len(series_freqs)
-    series_list = []
-    for i, freq in enumerate(series_freqs):
-        # All series load on Global, first half also load on Block1
-        blocks = [1, 1 if i < N // 2 else 0]
-        series_list.append(SeriesConfig(
-            series_id=f"test_{i:02d}",
-            series_name=f"Test Series {i}",
-            frequency=freq,
-            transformation='pch',
-            category='Test',
-            units='Index',
-            blocks=blocks
-        ))
-    
-    return DFMConfig(
-        series=series_list,
-        block_names=block_names,
-        factors_per_block=factors_per_block,
-        ar_lag=1,
-        threshold=1e-4,
-        max_iter=100,
-        nan_method=2,
-        nan_k=3,
-        clock=clock
-    )
-
-def test_clock_frequencies():
-    """Test different clock frequencies."""
-    print("\n" + "="*70)
-    print("TEST: Different Clock Frequencies")
-    print("="*70)
-    
-    results = {}
-    # Test with monthly and quarterly clocks (daily/weekly may have issues with small data)
-    clocks = ['m', 'q']
-    series_freqs = ['m', 'm', 'm', 'q', 'q']  # 3 monthly, 2 quarterly
-    
-    for clock in clocks:
-        try:
-            print(f"\n  Testing clock='{clock}'...")
-            config = create_test_config(series_freqs, clock=clock)
-            X = create_test_data(T=100, N=5, seed=42)
-            
-            result = dfm(X, config, max_iter=5, threshold=1e-3)
-            results[clock] = 'PASS'
-            print(f"    ✓ clock='{clock}' passed")
-        except Exception as e:
-            results[clock] = f'FAIL: {str(e)[:50]}'
-            print(f"    ✗ clock='{clock}' failed: {str(e)[:50]}")
-    
-    return results
-
-def test_mixed_frequencies():
-    """Test various mixed frequency combinations."""
-    print("\n" + "="*70)
-    print("TEST: Mixed Frequency Combinations")
-    print("="*70)
-    
-    test_cases = [
-        ('All Monthly', ['m', 'm', 'm', 'm', 'm'], 'm'),
-        ('Monthly + Quarterly', ['m', 'm', 'm', 'q', 'q'], 'm'),
-        ('Daily + Monthly', ['d', 'd', 'm', 'm', 'm'], 'm'),
-        ('Weekly + Monthly', ['w', 'w', 'm', 'm', 'm'], 'm'),
-        ('Quarterly + Semi-annual', ['q', 'q', 'sa', 'sa'], 'q'),
-        ('All Frequencies', ['d', 'w', 'm', 'q', 'sa', 'a'], 'm'),
-        ('Monthly + Quarterly + Annual', ['m', 'm', 'q', 'q', 'a'], 'm'),
-    ]
-    
-    results = {}
-    for name, freqs, clock in test_cases:
-        try:
-            print(f"\n  Testing {name} (clock={clock})...")
-            config = create_test_config(freqs, clock=clock)
-            X = create_test_data(T=100, N=len(freqs), seed=42)
-            
-            result = dfm(X, config, max_iter=5, threshold=1e-3)
-            results[name] = 'PASS'
-            print(f"    ✓ {name} passed")
-        except Exception as e:
-            results[name] = f'FAIL: {str(e)[:50]}'
-            print(f"    ✗ {name} failed: {str(e)[:50]}")
-    
-    return results
-
-def test_parameters():
-    """Test different parameter combinations."""
-    print("\n" + "="*70)
-    print("TEST: Different Parameter Combinations")
-    print("="*70)
-    
-    base_config = create_test_config(['m', 'm', 'm', 'q', 'q'], clock='m')
-    X = create_test_data(T=100, N=5, seed=42)
-    
-    test_cases = [
-        ('Low threshold', {'threshold': 1e-6, 'max_iter': 10}),
-        ('High threshold', {'threshold': 1e-2, 'max_iter': 10}),
-        ('Few iterations', {'threshold': 1e-3, 'max_iter': 3}),
-        ('Many iterations', {'threshold': 1e-4, 'max_iter': 50}),
-        ('nan_method=1', {'nan_method': 1, 'nan_k': 3}),
-        ('nan_method=2', {'nan_method': 2, 'nan_k': 3}),
-        ('nan_method=3', {'nan_method': 3, 'nan_k': 3}),
-        ('nan_k=1', {'nan_method': 2, 'nan_k': 1}),
-        ('nan_k=5', {'nan_method': 2, 'nan_k': 5}),
-        ('ar_lag=2', {'ar_lag': 2}),
-    ]
-    
-    results = {}
-    for name, params in test_cases:
-        try:
-            print(f"\n  Testing {name}...")
-            config_dict = base_config.__dict__.copy()
-            config_dict.update(params)
-            config = DFMConfig(**config_dict)
-            
-            result = dfm(X, config, max_iter=params.get('max_iter', 10), 
-                        threshold=params.get('threshold', 1e-3))
-            results[name] = 'PASS'
-            print(f"    ✓ {name} passed")
-        except Exception as e:
-            results[name] = f'FAIL: {str(e)[:50]}'
-            print(f"    ✗ {name} failed: {str(e)[:50]}")
-    
-    return results
-
-def test_data_scenarios():
-    """Test different data scenarios."""
-    print("\n" + "="*70)
-    print("TEST: Different Data Scenarios")
-    print("="*70)
-    
-    test_cases = [
-        ('No missing', {'missing_rate': 0.0, 'T': 100, 'N': 5}),
-        ('Low missing (5%)', {'missing_rate': 0.05, 'T': 100, 'N': 5}),
-        ('Medium missing (20%)', {'missing_rate': 0.20, 'T': 100, 'N': 5}),
-        ('High missing (40%)', {'missing_rate': 0.40, 'T': 100, 'N': 5}),
-        ('Short series (T=50)', {'T': 50, 'N': 5, 'missing_rate': 0.1}),
-        ('Long series (T=200)', {'T': 200, 'N': 5, 'missing_rate': 0.1}),
-        ('Few series (N=3)', {'N': 3, 'T': 100, 'missing_rate': 0.1}),
-        ('Many series (N=15)', {'N': 15, 'T': 100, 'missing_rate': 0.1}),
-    ]
-    
-    results = {}
-    for name, params in test_cases:
-        try:
-            print(f"\n  Testing {name}...")
-            T = params.get('T', 100)
-            N = params.get('N', 5)
-            missing_rate = params.get('missing_rate', 0.1)
-            
-            # Adjust config for different N
-            freqs = ['m'] * N
-            config = create_test_config(freqs, clock='m')
-            
-            X = create_test_data(T=T, N=N, seed=42, missing_rate=missing_rate)
-            result = dfm(X, config, max_iter=5, threshold=1e-3)
-            results[name] = 'PASS'
-            print(f"    ✓ {name} passed")
-        except Exception as e:
-            results[name] = f'FAIL: {str(e)[:50]}'
-            print(f"    ✗ {name} failed: {str(e)[:50]}")
-    
-    return results
-
-def test_block_configurations():
-    """Test different block configurations."""
-    print("\n" + "="*70)
-    print("TEST: Different Block Configurations")
-    print("="*70)
-    
-    test_cases = [
-        ('Single block', ['Global'], [1], 5),
-        ('Two blocks', ['Global', 'Block1'], [1, 1], 5),
-        ('Three blocks', ['Global', 'Block1', 'Block2'], [1, 1, 1], 8),
-        ('Different factors', ['Global', 'Block1'], [2, 1], 5),
-        ('All on Global', ['Global'], [1], 5, True),  # All series only on Global
-    ]
-    
-    results = {}
-    for case in test_cases:
-        name = case[0]
-        block_names = case[1]
-        factors = case[2]
-        N = case[3]
-        all_global = case[4] if len(case) > 4 else False
-        
-        try:
-            print(f"\n  Testing {name}...")
-            freqs = ['m'] * N
-            series_list = []
-            for i in range(N):
-                if all_global:
-                    blocks = [1]  # Only Global
-                else:
-                    # Distribute across blocks
-                    blocks = [1]  # Always Global
-                    if len(block_names) > 1:
-                        blocks.append(1 if i < N // 2 else 0)  # First half on Block1
-                    if len(block_names) > 2:
-                        blocks.append(1 if i >= N // 2 else 0)  # Second half on Block2
-                
-                series_list.append(SeriesConfig(
-                    series_id=f"test_{i:02d}",
-                    series_name=f"Test Series {i}",
-                    frequency='m',
-                    transformation='pch',
-                    category='Test',
-                    units='Index',
-                    blocks=blocks
-                ))
-            
-            config = DFMConfig(
-                series=series_list,
-                block_names=block_names,
-                factors_per_block=factors,
-                clock='m'
-            )
-            
-            X = create_test_data(T=100, N=N, seed=42)
-            result = dfm(X, config, max_iter=5, threshold=1e-3)
-            results[name] = 'PASS'
-            print(f"    ✓ {name} passed")
-        except Exception as e:
-            results[name] = f'FAIL: {str(e)[:50]}'
-            print(f"    ✗ {name} failed: {str(e)[:50]}")
-    
-    return results
-
-def test_transformations():
-    """Test different transformation types."""
-    print("\n" + "="*70)
-    print("TEST: Different Transformation Types")
-    print("="*70)
-    
-    transformations = ['lin', 'chg', 'pch', 'pca', 'log']
-    results = {}
-    
-    for trans in transformations:
-        try:
-            print(f"\n  Testing transformation='{trans}'...")
-            series_list = []
-            for i in range(5):
-                series_list.append(SeriesConfig(
-                    series_id=f"test_{i:02d}",
-                    series_name=f"Test Series {i}",
-                    frequency='m',
-                    transformation=trans,
-                    category='Test',
-                    units='Index',
-                    blocks=[1, 1 if i < 3 else 0]
-                ))
-            
-            config = DFMConfig(
-                series=series_list,
-                block_names=['Global', 'Block1'],
-                clock='m'
-            )
-            
-            X = create_test_data(T=100, N=5, seed=42)
-            result = dfm(X, config, max_iter=5, threshold=1e-3)
-            results[trans] = 'PASS'
-            print(f"    ✓ transformation='{trans}' passed")
-        except Exception as e:
-            results[trans] = f'FAIL: {str(e)[:50]}'
-            print(f"    ✗ transformation='{trans}' failed: {str(e)[:50]}")
-    
-    return results
-
-def test_edge_cases():
-    """Test edge cases and boundary conditions."""
-    print("\n" + "="*70)
-    print("TEST: Edge Cases and Boundary Conditions")
-    print("="*70)
-    
-    results = {}
-    
-    # Test cases (skip problematic ones)
-    test_cases = [
-        ('Minimal data (T=30, N=3)', {'T': 30, 'N': 3}),
-        ('Very high missing (50%)', {'missing_rate': 0.5}),
-        ('Constant series', {'constant': True}),
-        ('Extreme values', {'extreme': True}),
-    ]
-    
-    for name, params in test_cases:
-        try:
-            print(f"\n  Testing {name}...")
-            T = params.get('T', 100)
-            N = params.get('N', 5)
-            missing_rate = params.get('missing_rate', 0.1)
-            
-            if params.get('constant'):
-                X = np.ones((T, N)) * 100.0
-                # Add some variation to first series
-                np.random.seed(42)
-                X[:, 0] = 100.0 + np.random.randn(T) * 0.1
-            elif params.get('extreme'):
-                np.random.seed(42)
-                X = np.random.randn(T, N) * 1e6  # Very large values
-            else:
-                X = create_test_data(T=T, N=N, seed=42, missing_rate=missing_rate)
-            
-            config = create_test_config(['m'] * N, clock='m')
-            result = dfm(X, config, max_iter=3, threshold=1e-2)
-            results[name] = 'PASS'
-            print(f"    ✓ {name} passed")
-        except Exception as e:
-            results[name] = f'FAIL: {str(e)[:50]}'
-            print(f"    ✗ {name} failed: {str(e)[:50]}")
-    
-    return results
-
-def test_tent_weights_scenarios():
-    """Test scenarios that trigger tent weights."""
-    print("\n" + "="*70)
-    print("TEST: Tent Weights Scenarios")
-    print("="*70)
-    
-    results = {}
-    
-    # Test cases that should use tent weights (slower freq < clock)
-    test_cases = [
-        ('Quarterly with monthly clock', ['m', 'm', 'q', 'q'], 'm'),
-        ('Semi-annual with monthly clock', ['m', 'm', 'sa'], 'm'),
-        ('Annual with monthly clock', ['m', 'm', 'a'], 'm'),
-        ('Annual with quarterly clock', ['q', 'q', 'a'], 'q'),
-        ('Quarterly with daily clock', ['d', 'd', 'q'], 'd'),
-    ]
-    
-    for name, freqs, clock in test_cases:
-        try:
-            print(f"\n  Testing {name}...")
-            config = create_test_config(freqs, clock=clock)
-            X = create_test_data(T=100, N=len(freqs), seed=42)
-            
-            result = dfm(X, config, max_iter=5, threshold=1e-3)
-            results[name] = 'PASS'
-            print(f"    ✓ {name} passed")
-        except Exception as e:
-            results[name] = f'FAIL: {str(e)[:50]}'
-            print(f"    ✗ {name} failed: {str(e)[:50]}")
-    
-    return results
-
-def test_convergence_scenarios():
-    """Test convergence behavior with different settings."""
-    print("\n" + "="*70)
-    print("TEST: Convergence Scenarios")
-    print("="*70)
-    
-    config = create_test_config(['m', 'm', 'm', 'q', 'q'], clock='m')
-    X = create_test_data(T=100, N=5, seed=42)
-    
-    results = {}
-    test_cases = [
-        ('Converges quickly', {'threshold': 1e-2, 'max_iter': 50}),
-        ('Strict convergence', {'threshold': 1e-6, 'max_iter': 100}),
-        ('Max iterations reached', {'threshold': 1e-8, 'max_iter': 5}),
-    ]
-    
-    for name, params in test_cases:
-        try:
-            print(f"\n  Testing {name}...")
-            result = dfm(X, config, max_iter=params['max_iter'], 
-                        threshold=params['threshold'])
-            
-            # Check if converged or hit max_iter
-            converged = hasattr(result, 'converged') and result.converged if hasattr(result, 'converged') else True
-            results[name] = 'PASS'
-            print(f"    ✓ {name} passed (converged: {converged})")
-        except Exception as e:
-            results[name] = f'FAIL: {str(e)[:50]}'
-            print(f"    ✗ {name} failed: {str(e)[:50]}")
-    
-    return results
-
-def test_real_data_scenario():
-    """Test with real sample data configuration."""
-    print("\n" + "="*70)
-    print("TEST: Real Sample Data Scenario")
-    print("="*70)
-    
-    try:
-        config_file = project_root / 'config' / 'example_config.yaml'
-        data_file = project_root / 'data' / 'sample_data.csv'
-        
-        if not config_file.exists() or not data_file.exists():
-            print("    ⚠ Sample data files not found, skipping...")
-            return {'Real data': 'SKIP'}
-        
-        config = load_config(config_file)
-        X, Time, Z = load_data(data_file, config)
-        
-        # Test with different parameters
-        test_cases = [
-            ('Default params', {}),
-            ('Quick test', {'max_iter': 5, 'threshold': 1e-2}),
-            ('Strict convergence', {'max_iter': 100, 'threshold': 1e-6}),
-        ]
-        
-        results = {}
-        for name, params in test_cases:
-            try:
-                print(f"\n  Testing {name}...")
-                result = dfm(X, config, **params)
-                results[name] = 'PASS'
-                print(f"    ✓ {name} passed")
-            except Exception as e:
-                results[name] = f'FAIL: {str(e)[:50]}'
-                print(f"    ✗ {name} failed: {str(e)[:50]}")
-        
-        return results
-    except Exception as e:
-        return {'Real data': f'FAIL: {str(e)[:50]}'}
-
-def run_all_tests():
-    """Run all comprehensive tests."""
-    print("\n" + "="*70)
-    print("COMPREHENSIVE TEST SUITE FOR DFM PACKAGE")
-    print("="*70)
-    
-    all_results = {}
-    
-    # Run all test suites
-    all_results['Clock Frequencies'] = test_clock_frequencies()
-    all_results['Mixed Frequencies'] = test_mixed_frequencies()
-    all_results['Parameters'] = test_parameters()
-    all_results['Data Scenarios'] = test_data_scenarios()
-    all_results['Block Configurations'] = test_block_configurations()
-    all_results['Transformations'] = test_transformations()
-    all_results['Edge Cases'] = test_edge_cases()
-    all_results['Tent Weights'] = test_tent_weights_scenarios()
-    all_results['Convergence'] = test_convergence_scenarios()
-    all_results['Real Data'] = test_real_data_scenario()
-    
-    # Print summary
-    print("\n" + "="*70)
-    print("TEST SUMMARY")
-    print("="*70)
-    
-    total_tests = 0
-    passed_tests = 0
-    failed_tests = 0
-    
-    for suite_name, suite_results in all_results.items():
-        print(f"\n{suite_name}:")
-        for test_name, result in suite_results.items():
-            total_tests += 1
-            if result == 'PASS':
-                passed_tests += 1
-                print(f"  ✓ {test_name}")
-            elif result == 'SKIP':
-                print(f"  ⊘ {test_name} (skipped)")
-            else:
-                failed_tests += 1
-                print(f"  ✗ {test_name}: {result}")
-    
-    print("\n" + "="*70)
-    print(f"TOTAL: {total_tests} tests | PASSED: {passed_tests} | FAILED: {failed_tests} | SKIPPED: {total_tests - passed_tests - failed_tests}")
-    print("="*70)
-    
-    return all_results
-
-if __name__ == '__main__':
-    results = run_all_tests()
-