dfm-python 0.5.59__py3-none-any.whl → 0.6.0__py3-none-any.whl

dfm_python/__init__.py

@@ -32,7 +32,9 @@ Example:
     >>> df_processed = df[[col for col in df.columns if col != 'date']]
     >>> 
     >>> # Step 2: Create Dataset
-    >>> dataset = DFMDataset(config_path='config/default.yaml', data=df_processed)
+    >>> from dfm_python.config import DFMConfig
+    >>> config = DFMConfig.from_yaml('config/default.yaml')
+    >>> dataset = DFMDataset(config=config, data=df_processed)
     >>> 
     >>> # Step 3: Create model and load config
     >>> model = DFM()
@@ -61,7 +63,7 @@ Note: DFMConfig uses frequency dict to specify series (column names -> frequenci
 For detailed documentation, see the README.md file and the tutorial notebooks/scripts.
 """
 
-__version__ = "0.5.56"
+__version__ = "0.5.60"
 
 # ============================================================================
 # PUBLIC API DEFINITION
@@ -102,7 +104,10 @@ from .models.base import BaseFactorModel
 from .models.dfm import DFM
 
 # DDFM high-level API (PyTorch is mandatory)
-from .models.ddfm import DDFM
+try:
+    from .models.ddfm.ddfm import DDFM
+except ImportError:
+    DDFM = None
 
 __all__ = [
     # Core classes

dfm_python/config/__init__.py

@@ -81,12 +81,7 @@ from .types import (
 )
 # Import lazily to avoid circular dependencies
 try:
-    from ..numeric.builder import compute_idio_lengths
-except ImportError:
-    compute_idio_lengths = None
-
-try:
-    from ..numeric.tent import get_agg_structure, group_by_freq
+    from ..models.dfm.tent import get_agg_structure, group_by_freq
 except ImportError:
     get_agg_structure = None
     group_by_freq = None
@@ -100,7 +95,7 @@ def get_periods_per_year(frequency: str) -> int:
 __all__ = [
     # Base classes
     'BaseModelConfig', 'BaseResult',
-    # 'DEFAULT_BLOCK_NAME',  # Removed to avoid circular import - import directly from functional.dfm_block
+    # 'DEFAULT_BLOCK_NAME',  # Removed to avoid circular import
     # Model-specific configs (from schema.py)
     'DFMConfig', 'DDFMConfig',
     # State-space parameters
@@ -117,7 +112,6 @@ __all__ = [
     'FREQUENCY_HIERARCHY',
     'PERIODS_PER_YEAR',
     'get_periods_per_year',
-    'compute_idio_lengths',
     'get_agg_structure',
     'group_by_freq',
     # Type definitions (from types.py)

dfm_python/config/adapter.py

@@ -303,7 +303,6 @@ class YamlSource:
         _EXCLUDED_KEYS = {
             'defaults', '_target_', '_recursive_', '_convert_', 
             'series', 'blocks', 'data', 'output', 'description', 'name', 'target', 'model',
-            'nan_method', 'nan_k'  # Internal constants, not user-configurable
         }
         main_settings = {k: v for k, v in cfg_dict.items() if k not in _EXCLUDED_KEYS}
         
@@ -509,18 +508,16 @@ def make_config_source(
 # ============================================================================
 
 # Model type constants (exported for use in schema/model.py)
-MODEL_TYPE_KDFM = 'kdfm'
+# NOTE: KDFM is legacy and has been removed from this codebase.
 MODEL_TYPE_DDFM = 'ddfm'
 MODEL_TYPE_DFM = 'dfm'
 
 # Model type detection patterns
-_KDFM_TYPE_ALIASES = {'kdfm', 'kernelized'}
 _DDFM_TYPE_ALIASES = {'ddfm', 'deep'}
-_KDFM_PARAMS = {'ar_order', 'ma_order', 'structural_method', 'structural_reg_weight'}
 _DDFM_PARAMS = {'encoder_layers', 'epochs', 'learning_rate', 'batch_size'}
 
 def detect_config_type(data: Dict[str, Any]) -> str:
-    """Detect config type (DFM, DDFM, or KDFM) from data dictionary.
+    """Detect config type (DFM or DDFM) from data dictionary.
     
     Parameters
     ----------
@@ -530,7 +527,7 @@ def detect_config_type(data: Dict[str, Any]) -> str:
     Returns
     -------
     str
-        'kdfm', 'ddfm', or 'dfm'
+        'ddfm' or 'dfm'
         
     Raises
     ------
@@ -545,8 +542,6 @@ def detect_config_type(data: Dict[str, Any]) -> str:
     model_type = data.get('model_type', '').lower()
     
     # Check explicit model type
-    if model_type in _KDFM_TYPE_ALIASES:
-        return MODEL_TYPE_KDFM
     if model_type in _DDFM_TYPE_ALIASES:
         return MODEL_TYPE_DDFM
     if model_type == MODEL_TYPE_DFM:
@@ -559,8 +554,6 @@ def detect_config_type(data: Dict[str, Any]) -> str:
     
     # Check for model-specific parameters
     keys = set(data.keys())
-    if keys & _KDFM_PARAMS:
-        return MODEL_TYPE_KDFM
     if any(k.startswith('ddfm_') for k in keys) or (keys & _DDFM_PARAMS):
         return MODEL_TYPE_DDFM
     

dfm_python/config/constants.py

@@ -35,6 +35,29 @@ DEFAULT_VARIANCE_FALLBACK = 1.0  # Default variance fallback value for numerical
 # Maximum eigenvalues
 MAX_EIGENVALUE = 1e3  # Maximum eigenvalue cap (reduced to 1e3 to improve condition number: 1e3/1e-6 = 1e9)
 
+# ============================================================================
+# Performance and Numerical Health Guardrails
+# ============================================================================
+
+# Time budgets (hard limits to prevent pathological runs)
+# Single constraint: 10 minutes for all datasets
+MAX_ESTEP_SECONDS = 600.0  # Maximum E-step time (Kalman filter + smoother) - 10 minutes
+MAX_MSTEP_SECONDS = 600.0  # Maximum M-step time (parameter updates) - 10 minutes
+MAX_EM_ITERATION_SECONDS = 1200.0  # Maximum total EM iteration time - 20 minutes
+MAX_FIRST_ITERATION_SECONDS = 600.0  # Maximum first iteration E-step time (diagnostic) - 10 minutes
+
+# Numerical health thresholds (fail fast on pathological regimes)
+# Note: Condition number check is more lenient during initialization (first iteration)
+MAX_CONDITION_NUMBER_SMOOTHER = 1e8  # Maximum condition number before refusing to smooth (increased from 1e7)
+MAX_CONDITION_NUMBER_INIT = 1e10  # Maximum condition number during initialization (more lenient)
+MAX_STABILIZATION_AMOUNT = 1e-3  # Maximum stabilization amount before error (increased from 1e-4 to 0.1% diagonal loading)
+MAX_STABILIZATION_AMOUNT_INIT = 5e-3  # Maximum stabilization during initialization (more lenient)
+MAX_STD_UNSCALED = 100.0  # Maximum standard deviation for unscaled data (indicates missing preprocessing)
+MIN_STD_SCALED = 1e-4  # Minimum standard deviation for scaled data (indicates degenerate series)
+
+# Fallback tracking
+MAX_FALLBACKS_PER_ITERATION = 0  # Maximum allowed fallbacks per iteration (0 = fail on any fallback)
+
 # Eigenvalue stability thresholds
 DEFAULT_EIGENVALUE_MAX_MAGNITUDE = 1.0  # Default maximum eigenvalue magnitude for stability checks
 DEFAULT_EIGENVALUE_WARN_THRESHOLD = 0.99  # Default warning threshold for near-unstable eigenvalues
@@ -566,5 +589,17 @@ __all__ = [
     # Frequency hierarchy and tent kernels
     'FREQUENCY_HIERARCHY',
     'MAX_TENT_SIZE',
+    # Performance and numerical health guardrails
+    'MAX_ESTEP_SECONDS',
+    'MAX_MSTEP_SECONDS',
+    'MAX_EM_ITERATION_SECONDS',
+    'MAX_FIRST_ITERATION_SECONDS',
+    'MAX_CONDITION_NUMBER_SMOOTHER',
+    'MAX_CONDITION_NUMBER_INIT',
+    'MAX_STABILIZATION_AMOUNT',
+    'MAX_STABILIZATION_AMOUNT_INIT',
+    'MAX_STD_UNSCALED',
+    'MIN_STD_SCALED',
+    'MAX_FALLBACKS_PER_ITERATION',
 ]
 

dfm_python/config/schema/model.py

@@ -65,8 +65,6 @@ from ..constants import (
     MIN_EIGENVALUE,
     MAX_EIGENVALUE,
     MIN_DIAGONAL_VARIANCE,
-    DEFAULT_NAN_METHOD,
-    DEFAULT_NAN_K,
     DEFAULT_CLOCK_FREQUENCY,
     DEFAULT_KDFM_AR_ORDER,
     DEFAULT_KDFM_MA_ORDER,
@@ -138,7 +136,6 @@ class BaseModelConfig:
     # ========================================================================
     clock: str = 'm'  # Required: Base frequency for latent factors (global clock): 'd', 'w', 'm', 'q', 'sa', 'a' (defaults to 'm' for monthly)
     target_scaler: Optional[ScalerType] = None  # Fitted sklearn scaler instance (StandardScaler, RobustScaler, etc.) for target series only. Must be a fitted scaler object (call .fit() on target data first). Pass scaler object directly, not string. Feature series are assumed to be manually preprocessed. If None, target series are assumed to be already in the desired scale.
-    # Note: nan_method and nan_k are internal constants (DEFAULT_NAN_METHOD, DEFAULT_NAN_K) used during initialization only
     
     def __post_init__(self):
         """Validate basic model structure.
@@ -294,9 +291,6 @@ class DFMConfig(BaseModelConfig):
     # - If mixed frequencies detected: augment_idio=True, augment_idio_slow=True (required for tent kernel)
     # These are properties, not config fields - automatically determined from frequency configuration
     
-    # Kalman Filter Type
-    use_cholesky_filter: bool = False  # Use CholeskyKalmanFilter for better numerical stability (default: False)
-    
     # Tent Kernel Weights (for mixed-frequency aggregation)
     tent_weights: Optional[Union[Dict[str, List[float]], Dict[str, np.ndarray]]] = None  # Required for mixed-frequency data: tent weights for frequency pairs. Format: {'freq_pair': [weights]} or {'freq': [weights]}. Example: {'m:w': [1, 2, 1]} or {'m': [1, 2, 1]}. Must be specified in config for all slower-frequency pairs.
     
@@ -379,7 +373,11 @@ class DFMConfig(BaseModelConfig):
         object.__setattr__(self, '_augment_idio_slow', is_mixed_freq)
     
     def to_em_config(self) -> 'EMConfig':
-        """Create EMConfig from DFMConfig consolidated parameters."""
+        """Create EMConfig from DFMConfig consolidated parameters.
+        
+        Automatically passes all numerical stability parameters (regularization, ar_clip,
+        damping_factor, data_clip) from DFMConfig to EMConfig for use in EM algorithm.
+        """
         from ...functional.em import EMConfig
         from ..constants import DEFAULT_REGULARIZATION, VAR_STABILITY_THRESHOLD
         
@@ -397,6 +395,10 @@ class DFMConfig(BaseModelConfig):
             regularization=reg_scale,
             min_norm=min_eigenval,
             max_eigenval=max_eigenval,
+            # Pass numerical stability parameters from DFMConfig
+            ar_clip=self.ar_clip,
+            damping_factor=self.damping_factor,
+            data_clip=self.data_clip,
             # Other parameters use defaults from EMConfig
         )
     
@@ -416,16 +418,32 @@ class DFMConfig(BaseModelConfig):
             series_ids = list(self.frequency.keys()) if columns is None else columns
             
             # Build blocks array from block series lists (N x B matrix)
-            block_series_sets = {
-                name: set(self.blocks[name].get('series', []))
-                for name in self.block_names
-            }
+            # Default global block behavior:
+            # If config omitted blocks.series (empty list) and we have runtime columns,
+            # interpret a single empty Block_Global as "all series in this block".
+            block_series_sets: Dict[str, set] = {}
+            default_global_applied = False
+            for name in self.block_names:
+                series_list = self.blocks[name].get('series', [])
+                if (
+                    columns is not None
+                    and (series_list is None or len(series_list) == 0)
+                    and len(self.block_names) == 1
+                    and name == "Block_Global"
+                ):
+                    block_series_sets[name] = set(series_ids)
+                    default_global_applied = True
+                else:
+                    block_series_sets[name] = set(series_list or [])
+
             blocks_list = [
                 [1 if series_id in block_series_sets[name] else 0 for name in self.block_names]
                 for series_id in series_ids
             ]
             
             self._cached_blocks = np.array(blocks_list, dtype=int)
+
+            # Quick sanity on membership counts for the first block (if any)
         return self._cached_blocks
     
     @classmethod
@@ -453,7 +471,6 @@ class DFMConfig(BaseModelConfig):
             'data_clip': data.get('data_clip', None),
             'regularization': data.get('regularization', None),
             'damping_factor': data.get('damping_factor', None),
-            'use_cholesky_filter': data.get('use_cholesky_filter', False),
             'tent_weights': data.get('tent_weights', None),
         }
         
@@ -462,14 +479,14 @@ class DFMConfig(BaseModelConfig):
         return result
     
     @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> Union['DFMConfig', 'DDFMConfig', 'KDFMConfig']:
-        """Create DFMConfig, DDFMConfig, or KDFMConfig from dictionary.
+    def from_dict(cls, data: Dict[str, Any]) -> Union['DFMConfig', 'DDFMConfig']:
+        """Create DFMConfig or DDFMConfig from dictionary.
         
         Expected format: {'frequency': {'column_name': 'frequency'}, 'blocks': {...}, ...}
         
         Also accepts estimation parameters: threshold, max_iter, etc.
         """
-        from ...config.adapter import detect_config_type, MODEL_TYPE_DDFM, MODEL_TYPE_KDFM, _normalize_blocks_dict
+        from ...config.adapter import detect_config_type, MODEL_TYPE_DDFM, _normalize_blocks_dict
         from ...utils.errors import ConfigurationError
         
         # Extract base params (handles frequency conversion from series if needed)
@@ -481,14 +498,24 @@ class DFMConfig(BaseModelConfig):
         if config_type == MODEL_TYPE_DDFM:
             return DDFMConfig(**base_params, **DDFMConfig._extract_ddfm(data))
         
-        if config_type == MODEL_TYPE_KDFM:
-            return KDFMConfig(**base_params, **KDFMConfig._extract_kdfm(data))
-        
         # Handle blocks for DFM
         from ...config.adapter import _raise_config_error, _is_dict_like
         blocks_dict = data.get('blocks', {})
         if not blocks_dict:
-            _raise_config_error("blocks dict is required for DFM config")
+            # Default behavior: single global block.
+            # This enables minimal configs like:
+            #   clock: d
+            #   num_factors: 2
+            # and lets the model bind series names from the dataset at runtime.
+            default_num_factors = int(data.get('num_factors', 1) or 1)
+            if default_num_factors < 1:
+                _raise_config_error(f"num_factors must be >= 1, got {default_num_factors}")
+            blocks_dict = {
+                "Block_Global": {
+                    "num_factors": default_num_factors,
+                    "series": [],  # to be bound from dataset columns
+                }
+            }
         if not _is_dict_like(blocks_dict):
             _raise_config_error(f"blocks must be a dict, got {type(blocks_dict)}")
         
@@ -599,72 +626,6 @@ class DDFMConfig(BaseModelConfig):
         )
 
 
-@dataclass
-class KDFMConfig(BaseModelConfig):
-    """KDFM configuration dataclass.
-    
-    This dataclass contains all configuration parameters for the KDFM model.
-    It inherits from BaseModelConfig and adds KDFM-specific parameters.
-    
-    Note: KDFM does not use blocks structure (unlike DFM). Only frequency dict is needed.
-    """
-    # VARMA parameters
-    ar_order: int = DEFAULT_KDFM_AR_ORDER  # VAR order p
-    ma_order: int = DEFAULT_KDFM_MA_ORDER  # MA order q (0 = pure VAR)
-    
-    # Structural identification
-    structural_method: str = 'cholesky'  # 'cholesky', 'full', 'low_rank'
-    structural_rank: Optional[int] = None  # For low-rank parameterization
-    
-    # Training parameters (use constants for defaults)
-    learning_rate: float = DEFAULT_LEARNING_RATE
-    max_epochs: int = DEFAULT_MAX_EPOCHS
-    batch_size: int = DEFAULT_BATCH_SIZE
-    weight_decay: float = DEFAULT_REGULARIZATION_SCALE
-    grad_clip_val: float = DEFAULT_GRAD_CLIP_VAL
-    
-    # Regularization
-    structural_reg_weight: float = DEFAULT_STRUCTURAL_REG_WEIGHT  # Weight for structural loss
-    use_regularization: bool = True
-    regularization_scale: float = DEFAULT_REGULARIZATION_SCALE
-    
-    # ========================================================================
-    # Factory Methods
-    # ========================================================================
-    
-    @classmethod
-    def _extract_kdfm(cls, data: Dict[str, Any]) -> Dict[str, Any]:
-        """Extract KDFM-specific parameters from config dict."""
-        # Don't extract base params here - they're already in base_params from from_dict
-        kdfm_params = cls._extract_params(data, {
-            'ar_order': DEFAULT_KDFM_AR_ORDER,
-            'ma_order': DEFAULT_KDFM_MA_ORDER,
-            'structural_method': 'cholesky',
-            'structural_rank': None,
-            'learning_rate': DEFAULT_LEARNING_RATE,
-            'max_epochs': DEFAULT_MAX_EPOCHS,
-            'batch_size': DEFAULT_BATCH_SIZE,
-            'weight_decay': DEFAULT_REGULARIZATION_SCALE,
-            'grad_clip_val': DEFAULT_GRAD_CLIP_VAL,
-            'structural_reg_weight': DEFAULT_STRUCTURAL_REG_WEIGHT,
-            'use_regularization': True,
-            'regularization_scale': DEFAULT_REGULARIZATION_SCALE,
-        })
-        return kdfm_params
-    
-    @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> 'KDFMConfig':
-        """Create KDFMConfig from dictionary (delegates to DFMConfig.from_dict for type detection)."""
-        result = DFMConfig.from_dict(data)
-        if isinstance(result, KDFMConfig):
-            return result
-        from ..utils.errors import ConfigurationError
-        raise ConfigurationError(
-            f"Expected KDFMConfig but got {type(result).__name__}",
-            details=f"Result type: {type(result).__name__}, expected: KDFMConfig"
-        )
-
-
 # ============================================================================
 # Validation Functions
 # ============================================================================

dfm_python/config/schema/params.py

@@ -8,97 +8,12 @@ import numpy as np
 from typing import Optional, Any
 
 
-@dataclass
-class DFMStateSpaceParams:
-    """State-space model parameters for DFM (fitted during model training).
-    
-    These parameters are computed during DFM.fit() and represent the fitted
-    state-space model structure. Contains only the state-space parameters,
-    not training metadata (loglik, num_iter, converged) which are stored
-    separately in checkpoint dicts.
-    
-    Parameters
-    ----------
-    A : np.ndarray
-        Transition matrix (m x m) - VAR dynamics for factors
-    C : np.ndarray
-        Observation matrix (N x m) - factor loadings
-    Q : np.ndarray
-        Process noise covariance (m x m) - innovation covariance
-    R : np.ndarray
-        Observation noise covariance (N x N) - typically diagonal
-    Z_0 : np.ndarray
-        Initial state mean (m,) - initial factor values
-    V_0 : np.ndarray
-        Initial state covariance (m x m) - initial uncertainty
-    """
-    A: np.ndarray  # Transition matrix (m x m)
-    C: np.ndarray  # Observation matrix (N x m)
-    Q: np.ndarray  # Process noise covariance (m x m)
-    R: np.ndarray  # Observation noise covariance (N x N)
-    Z_0: np.ndarray  # Initial state mean (m,)
-    V_0: np.ndarray  # Initial state covariance (m x m)
-    
-    @classmethod
-    def from_model(cls, model: Any) -> 'DFMStateSpaceParams':
-        """Create DFMStateSpaceParams from DFM model instance.
-        
-        Parameters
-        ----------
-        model : DFM
-            DFM model instance with fitted parameters
-            
-        Returns
-        -------
-        DFMStateSpaceParams
-            State-space parameters dataclass
-        """
-        # Get parameters from model (stored after fit)
-        # First check if training_state is already DFMStateSpaceParams (new format)
-        if hasattr(model, 'training_state') and model.training_state is not None:
-            if isinstance(model.training_state, cls):
-                # Already a DFMStateSpaceParams instance
-                return model.training_state
-            # Backward compatibility: If old format training_state (has A, C, Q, R, Z_0, V_0 attributes)
-            if hasattr(model.training_state, 'A'):
-                return cls(
-                    A=model.training_state.A,
-                    C=model.training_state.C,
-                    Q=model.training_state.Q,
-                    R=model.training_state.R,
-                    Z_0=model.training_state.Z_0,
-                    V_0=model.training_state.V_0
-                )
-        
-        # Get from model attributes (after _update_parameters is called)
-        return cls(
-            A=getattr(model, 'A', None),
-            C=getattr(model, 'C', None),
-            Q=getattr(model, 'Q', None),
-            R=getattr(model, 'R', None),
-            Z_0=getattr(model, 'Z_0', None),
-            V_0=getattr(model, 'V_0', None)
-        )
-    
-    def apply_to_model(self, model: Any) -> None:
-        """Apply state-space parameters to DFM model instance.
-        
-        Parameters
-        ----------
-        model : DFM
-            DFM model instance to update
-        """
-        model._update_parameters(
-            self.A, self.C, self.Q, self.R, self.Z_0, self.V_0
-        )
-
-
 @dataclass
 class DFMModelState:
-    """DFM model structure and mixed-frequency parameters.
+    """DFM model state including structure, mixed-frequency parameters, and state-space parameters.
     
-    Consolidates model structure and mixed-frequency state for checkpointing.
-    This allows save/load methods to be simplified by using a single dataclass.
+    Consolidates all DFM model state for checkpointing: model structure, mixed-frequency
+    configuration, and fitted state-space parameters.
     
     Attributes
     ----------
@@ -128,6 +43,18 @@ class DFMModelState:
         Indicator for idiosyncratic components
     max_lag_size : int, optional
         Maximum lag size for state dimension
+    A : np.ndarray, optional
+        Transition matrix (m x m) - VAR dynamics for factors
+    C : np.ndarray, optional
+        Observation matrix (N x m) - factor loadings
+    Q : np.ndarray, optional
+        Process noise covariance (m x m) - innovation covariance
+    R : np.ndarray, optional
+        Observation noise covariance (N x N) - typically diagonal
+    Z_0 : np.ndarray, optional
+        Initial state mean (m,) - initial factor values
+    V_0 : np.ndarray, optional
+        Initial state covariance (m x m) - initial uncertainty
     """
     num_factors: int
     r: np.ndarray
@@ -142,6 +69,13 @@ class DFMModelState:
     frequencies: Optional[np.ndarray] = None
     idio_indicator: Optional[np.ndarray] = None
     max_lag_size: Optional[int] = None
+    # State-space parameters (fitted during training)
+    A: Optional[np.ndarray] = None
+    C: Optional[np.ndarray] = None
+    Q: Optional[np.ndarray] = None
+    R: Optional[np.ndarray] = None
+    Z_0: Optional[np.ndarray] = None
+    V_0: Optional[np.ndarray] = None
     
     @classmethod
     def from_model(cls, model: Any) -> 'DFMModelState':
@@ -157,6 +91,27 @@ class DFMModelState:
         DFMModelState
             Model state dataclass
         """
+        # Get state-space parameters from training_state if available
+        A = C = Q = R = Z_0 = V_0 = None
+        if hasattr(model, 'training_state') and model.training_state is not None:
+            # Handle both old DFMStateSpaceParams format and new DFMModelState format
+            ts = model.training_state
+            if hasattr(ts, 'A'):
+                A = ts.A
+                C = ts.C
+                Q = ts.Q
+                R = ts.R
+                Z_0 = ts.Z_0
+                V_0 = ts.V_0
+        else:
+            # Fallback: get from model attributes directly
+            A = getattr(model, 'A', None)
+            C = getattr(model, 'C', None)
+            Q = getattr(model, 'Q', None)
+            R = getattr(model, 'R', None)
+            Z_0 = getattr(model, 'Z_0', None)
+            V_0 = getattr(model, 'V_0', None)
+        
         return cls(
             num_factors=model.num_factors,
             r=model.r,
@@ -170,7 +125,13 @@ class DFMModelState:
             tent_weights_dict=getattr(model, '_tent_weights_dict', None),
             frequencies=getattr(model, '_frequencies', None),
             idio_indicator=getattr(model, '_idio_indicator', None),
-            max_lag_size=getattr(model, '_max_lag_size', None)
+            max_lag_size=getattr(model, '_max_lag_size', None),
+            A=A,
+            C=C,
+            Q=Q,
+            R=R,
+            Z_0=Z_0,
+            V_0=V_0
         )
     
     def apply_to_model(self, model: Any) -> None:
@@ -194,6 +155,12 @@ class DFMModelState:
         model._frequencies = self.frequencies
         model._idio_indicator = self.idio_indicator
         model._max_lag_size = self.max_lag_size
+        
+        # Apply state-space parameters if available
+        if self.A is not None and self.C is not None and self.Q is not None:
+            model._update_parameters(
+                self.A, self.C, self.Q, self.R, self.Z_0, self.V_0
+            )
 
 @dataclass
 class DDFMTrainingState:
@@ -277,3 +244,6 @@ class DDFMStateSpaceParams:
     H: np.ndarray  # Observation matrix (N x m) - theta in paper
     R: np.ndarray  # Observation noise covariance (N x N)
 
+# Backward compatibility alias
+DFMStateSpaceParams = DFMModelState
+