dfm-python 0.4.8__py3-none-any.whl → 0.4.51__py3-none-any.whl

dfm_python/__init__.py

@@ -6,6 +6,7 @@ This package implements a comprehensive Dynamic Factor Model framework with supp
 - Tent kernel aggregation for low-to-high frequency mapping
 - Expectation-Maximization (EM) algorithm for parameter estimation
 - Kalman filtering and smoothing for factor extraction
+- News decomposition for nowcasting
 - Deep Dynamic Factor Models (DDFM) with nonlinear encoders (requires PyTorch)
 
 The package implements a clock-based approach to mixed-frequency DFMs, where all latent 
@@ -22,6 +23,7 @@ Key Features:
     - Flexible block structure for factor modeling
     - Robust handling of missing data (internal spline interpolation)
     - Automatic standardization and data clipping
+    - News decomposition for forecast updates
 
 Example (Standard Lightning Pattern):
     >>> from dfm_python import DFM, DFMDataModule, DFMTrainer
@@ -65,7 +67,7 @@ Note: DFMConfig and SeriesConfig are internal implementation details.
 For detailed documentation, see the README.md file and the tutorial notebooks/scripts.
 """
 
-__version__ = "0.4.8"
+__version__ = "0.4.51"
 
 # ============================================================================
 # PUBLIC API DEFINITION
@@ -79,7 +81,7 @@ __version__ = "0.4.8"
 # 2. High-level API: DFM, DDFM, module-level convenience functions
 # 3. Core utilities: TimeIndex, diagnostics
 # 4. Models: BaseFactorModel, DDFM (low-level)
-# 5. Data & Results: DFMResult
+# 5. Nowcasting: Nowcast, result classes, para_const
 # 6. Data & Results: DFMResult
 # ============================================================================
 
@@ -108,7 +110,16 @@ from .lightning import (
     EMAlgorithm,  # Module class
 )
 
-# Nowcasting removed - use src.nowcast instead
+# Nowcasting (from nowcast/ subpackage)
+from .nowcast import (
+    Nowcast,
+    NowcastResult,
+)
+from .nowcast.helpers import (
+    para_const,
+    NewsDecompResult,
+    BacktestResult,
+)
 
 # Model implementations
 from .models.base import BaseFactorModel
@@ -119,9 +130,11 @@ from .models.ddfm import DDFM, DDFMModel
 
 __all__ = [
     # Core classes
-    'DFM',
+    'DFM', 'Nowcast',
     # Model base and implementations
     'BaseFactorModel',
+    # Nowcast result classes
+    'NowcastResult', 'NewsDecompResult', 'BacktestResult',
     # Constants
     'DEFAULT_BLOCK_NAME',
     # Config sources
@@ -129,6 +142,7 @@ __all__ = [
     'MergedConfigSource', 'make_config_source',
     # Low-level API (functional interface - advanced usage)
     'BaseResult', 'DFMResult', 'DDFMResult', 'calculate_rmse', 'diagnose_series', 'print_series_diagnosis',
+    'para_const',  # Internal utility for nowcasting
 ]
 
 # DDFM high-level API (PyTorch is mandatory)

dfm_python/config/adapter.py

@@ -214,7 +214,8 @@ class YamlSource:
                         frequency=series_data.get('frequency', 'm'),
                         transformation=series_data.get('transformation', 'lin'),
                         blocks=series_data.get('blocks', []),
-                        release_date=release_date
+                        release_date=release_date,
+                        scaler=series_data.get('scaler', None)  # Optional, for per-series scaling
                     ))
         
         # If no series loaded from separate files, try to get from main config

dfm_python/config/schema.py

@@ -200,6 +200,11 @@ class SeriesConfig:
         - Positive value (1-31): Day of month when data is released
         - Negative value: Days before end of previous month when data is released
         Example: 25 = released on 25th of each month, -5 = released 5 days before end of previous month
+    scaler : str, optional
+        Scaler type for this series: 'standard', 'robust', 'minmax', 'maxabs', 
+        'quantile', or None/null (no scaling). Used by create_scaling_transformer_from_config()
+        to automatically create per-series scaling transformers. If None, uses default
+        scaling strategy (typically 'standard').
     """
     # Required fields (no defaults)
     frequency: str
@@ -210,6 +215,7 @@ class SeriesConfig:
     series_name: Optional[str] = None  # Optional metadata for display
     units: Optional[str] = None  # Optional metadata for display only (used in news.py output)
     release_date: Optional[int] = None  # Release date for pseudo real-time nowcasting
+    scaler: Optional[str] = None  # Scaler type: 'standard', 'robust', 'minmax', 'maxabs', 'quantile', or None
     
     def __post_init__(self):
         """Validate fields after initialization."""
@@ -302,7 +308,6 @@ class BaseModelConfig:
     nan_method: int = 2  # Missing data handling method (1-5). Preprocessing step before Kalman Filter-based handling
     nan_k: int = 3  # Spline parameter for NaN interpolation (cubic spline)
     clock: str = 'm'  # Base frequency for nowcasting (global clock): 'd', 'w', 'm', 'q', 'sa', 'a' (defaults to 'm' for monthly)
-    scaler: Optional[str] = 'standard'  # Unified scaler type for all series: 'standard', 'robust', 'minmax', 'maxabs', 'quantile', or None (no scaling). Default: 'standard' for unified scaling.
     
     # ========================================================================
     # Internal cache (not user-configurable)
@@ -655,7 +660,6 @@ class DFMConfig(BaseModelConfig):
             'nan_method': data.get('nan_method', 2),
             'nan_k': data.get('nan_k', 3),
             'clock': data.get('clock', 'm'),
-            'scaler': data.get('scaler', 'standard'),  # Unified scaler for all series (default: 'standard')
         }
     
     @classmethod
@@ -712,11 +716,11 @@ class DDFMConfig(BaseModelConfig):
     # ========================================================================
     encoder_layers: Optional[List[int]] = None  # Hidden layer dimensions for encoder (default: [64, 32])
     num_factors: Optional[int] = None  # Number of factors (inferred from config if None)
-    activation: str = 'relu'  # Activation function ('tanh', 'relu', 'sigmoid', default: 'relu' to match original DDFM)
+    activation: str = 'tanh'  # Activation function ('tanh', 'relu', 'sigmoid', default: 'tanh')
     use_batch_norm: bool = True  # Use batch normalization in encoder (default: True)
     learning_rate: float = 0.001  # Learning rate for Adam optimizer (default: 0.001)
     epochs: int = 100  # Number of training epochs (default: 100)
-    batch_size: int = 100  # Batch size for training (default: 100 to match original DDFM)
+    batch_size: int = 32  # Batch size for training (default: 32)
     factor_order: int = 1  # VAR lag order for factor dynamics (1 or 2, default: 1)
     use_idiosyncratic: bool = True  # Model idio components with AR(1) dynamics (default: True)
     min_obs_idio: int = 5  # Minimum observations for idio AR(1) estimation (default: 5)
@@ -746,15 +750,15 @@ class DDFMConfig(BaseModelConfig):
     def _extract_ddfm(cls, data: Dict[str, Any]) -> Dict[str, Any]:
         """Extract DDFM-specific parameters from config dict."""
         base_params = cls._extract_base(data)
-        # Handle both direct keys and ddfm_ prefix format
+        # Handle both direct keys and ddfm_ prefix format (for backward compatibility)
         base_params.update({
             'encoder_layers': data.get('encoder_layers') or data.get('ddfm_encoder_layers', None),
             'num_factors': data.get('num_factors') or data.get('ddfm_num_factors', None),
-            'activation': data.get('activation') or data.get('ddfm_activation', 'relu'),
+            'activation': data.get('activation') or data.get('ddfm_activation', 'tanh'),
             'use_batch_norm': data.get('use_batch_norm', data.get('ddfm_use_batch_norm', True)),
             'learning_rate': data.get('learning_rate', data.get('ddfm_learning_rate', 0.001)),
             'epochs': data.get('epochs', data.get('ddfm_epochs', 100)),
-            'batch_size': data.get('batch_size', data.get('ddfm_batch_size', 100)),
+            'batch_size': data.get('batch_size', data.get('ddfm_batch_size', 32)),
             'factor_order': data.get('factor_order', data.get('ddfm_factor_order', 1)),
             'use_idiosyncratic': data.get('use_idiosyncratic', data.get('ddfm_use_idiosyncratic', True)),
             'min_obs_idio': data.get('min_obs_idio', data.get('ddfm_min_obs_idio', 5)),
@@ -828,7 +832,8 @@ class DDFMConfig(BaseModelConfig):
                     transformation=series_cfg.get('transformation', 'lin'),
                     blocks=series_blocks,
                     units=series_cfg.get('units', None),  # Optional, for display only
-                    release_date=series_cfg.get('release_date', None)  # Optional, for nowcasting
+                    release_date=series_cfg.get('release_date', None),  # Optional, for nowcasting
+                    scaler=series_cfg.get('scaler', None)  # Optional, for per-series scaling
                 ))
         
         # Convert blocks_dict to dict of block properties

dfm_python/data/dataloader.py

@@ -101,7 +101,7 @@ def create_dfm_dataloader(
 
 def create_ddfm_dataloader(
     dataset: DDFMDataset,
-    batch_size: int = 100,
+    batch_size: int = 32,
     shuffle: bool = True,
     num_workers: int = 0,
     pin_memory: bool = True
@@ -115,8 +115,8 @@ def create_ddfm_dataloader(
     ----------
     dataset : DDFMDataset
         DDFM dataset instance with windowed sequences
-    batch_size : int, default 100
-        Batch size for training (matches original DDFM)
+    batch_size : int, default 32
+        Batch size for training
     shuffle : bool, default True
         Whether to shuffle samples (typically True for training)
     num_workers : int, default 0

dfm_python/data/utils.py

@@ -209,7 +209,7 @@ def load_data(
     Time : TimeIndex
         Time index for the data (aligned to clock frequency)
     Z : np.ndarray
-        Original untransformed data (T x N), same as X
+        Original untransformed data (T x N), same as X (for backward compatibility)
         
     Raises
     ------

dfm_python/encoder/vae.py

@@ -454,21 +454,6 @@ def extract_decoder_params(decoder) -> Tuple[np.ndarray, np.ndarray]:
     # Decoder weight is already (N x m), so no transpose needed
     C = weight
     
-    # Check for NaN in extracted C matrix (indicates numerical instability during training)
-    if np.any(np.isnan(C)):
-        nan_count = np.sum(np.isnan(C))
-        nan_ratio = nan_count / C.size
-        from ..logger import get_logger
-        _logger = get_logger(__name__)
-        _logger.warning(
-            f"extract_decoder_params: C matrix contains {nan_count}/{C.size} NaN values ({nan_ratio:.1%}). "
-            f"This indicates the decoder weights contain NaN, likely due to numerical instability during training. "
-            f"Possible causes: (1) learning rate too high, (2) gradient explosion, (3) unstable training."
-        )
-        # Replace NaN with zeros to prevent further issues
-        C = np.nan_to_num(C, nan=0.0)
-        _logger.warning("Replaced NaN values in C matrix with zeros.")
-    
     return C, bias
 
 

dfm_python/lightning/__init__.py

@@ -28,14 +28,15 @@ from .scaling import (
 )
 
 # DFMTrainingState is defined in models.dfm and exported here for convenience
+# Note: dfm_module.py has been removed - DFM class implements EM directly
 from ..models.dfm import DFMTrainingState
 
 __all__ = [
     # Kalman filter
-    'KalmanFilter',
+    'KalmanFilter',  # New module class
     'KalmanFilterState',
     # EM algorithm
-    'EMAlgorithm',
+    'EMAlgorithm',  # New module class
     'EMStepParams',
     # Data handling
     'DFMDataModule',
@@ -49,5 +50,7 @@ __all__ = [
     'NoScalingStrategy',
     # Training state (defined in models.dfm)
     'DFMTrainingState',
+    # DDFMLightningModule removed: deprecated and unused (DDFM uses DDFMModel directly)
+    # DDFMTrainingState removed: duplicate (also defined in models.ddfm)
 ]
 

dfm_python/lightning/data_module.py

@@ -43,11 +43,13 @@ def _get_scaler(transformer: Any) -> Optional[Any]:
     
     This function depends on sktime's pipeline structure to traverse
     TransformerPipeline and sklearn transformers (StandardScaler, etc.).
+    Note: TabularToSeriesAdaptor support is for backward compatibility only.
     
     Parameters
     ----------
     transformer : Any
-        Transformer to search (StandardScaler, TransformerPipeline, sklearn Pipeline, etc.)
+        Transformer to search (can be any scaler, StandardScaler directly, or TabularToSeriesAdaptor for backward compatibility). 
+        TransformerPipeline, sklearn Pipeline, etc.)
         
     Returns
     -------
@@ -58,7 +60,9 @@ def _get_scaler(transformer: Any) -> Optional[Any]:
     if transformer is None:
         return None
     
-    # Check if transformer is wrapped (TabularToSeriesAdaptor or similar)
+    # Check if transformer is TabularToSeriesAdaptor (backward compatibility only)
+    # Note: New code should use StandardScaler() directly per sktime docs
+    # This check is kept for backward compatibility with old code that may still use TabularToSeriesAdaptor
     if hasattr(transformer, 'transformer'):
         # Recursively search the wrapped transformer
         wrapped = transformer.transformer
@@ -74,7 +78,8 @@ def _get_scaler(transformer: Any) -> Optional[Any]:
             if scaler is not None:
                 return scaler
     
-    # Check if transformer is ColumnEnsembleTransformer (or ColumnTransformer)
+    # Check if transformer is ColumnTransformer (backward compatibility only - not recommended for new code)
+    # Unified scaling with StandardScaler is preferred per sktime docs
     if hasattr(transformer, 'transformers'):
         for name, trans, cols in transformer.transformers:
             scaler = _get_scaler(trans)
@@ -256,17 +261,15 @@ class DFMDataModule(lightning_pl.LightningDataModule):
     
     This DataModule handles data loading for DFM/DDFM models.
     
-    **Important**: DFM and DDFM can handle missing data (NaN values) implicitly:
-    - **DFM**: Uses Kalman filter's `handle_missing_data()` method to skip NaN observations
-    - **DDFM**: Uses state-space model and MCMC procedure to handle missing data through
-      idiosyncratic component estimation
+    **Important**: This package expects preprocessed data. All preprocessing (imputation, 
+    scaling, feature engineering, etc.) must be done by the user before passing data to 
+    this DataModule. Users are responsible for creating their own preprocessing pipelines 
+    using sktime or other tools.
     
     **Usage Pattern**:
-    - Data can contain NaN values - models will handle them implicitly
+    - Provide already-preprocessed data (standardized, no missing values, feature-engineered)
     - If `pipeline=None`, a passthrough transformer is used by default (no-op)
     - Users can optionally provide their preprocessing pipeline to extract statistics (Mx/Wx)
-    - For better performance, users can preprocess data (imputation, scaling) before passing,
-      but it's not required - models will handle missing data automatically
     
     For linear DFM, this uses DFMDataset which returns full sequences.
     For DDFM, use DDFMDataModule which uses DDFMDataset with windowing.
@@ -308,10 +311,9 @@ class DFMDataModule(lightning_pl.LightningDataModule):
     data_path : str or Path, optional
         Path to data file (CSV). If None, data must be provided.
     data : np.ndarray or pd.DataFrame, optional
-        Data array or DataFrame. Can contain NaN values - DFM/DDFM will handle them:
-        - DFM: Uses Kalman filter to implicitly handle missing data
-        - DDFM: Uses state-space model and MCMC to handle missing data
-        - Standardized/scaled data (mean=0, std=1) is recommended for better performance
+        Preprocessed data array or DataFrame. Data must be:
+        - Standardized/scaled (mean=0, std=1 recommended for DFM/DDFM)
+        - No missing values (NaN-free)
         - Feature-engineered if needed
         If None, data_path must be provided.
     time_index : TimeIndex, optional
@@ -415,22 +417,20 @@ class DFMDataModule(lightning_pl.LightningDataModule):
         This method is called by Lightning to set up the data module.
         It loads preprocessed data and extracts statistics from the pipeline for forecasting/nowcasting.
         
-        **Important**: DFM and DDFM can handle missing data (NaN values) implicitly:
-        - **DFM**: Uses Kalman filter's `handle_missing_data()` method
-        - **DDFM**: Uses state-space model and MCMC procedure
+        **Important**: Data must be fully preprocessed by the user before passing to this DataModule.
+        All preprocessing (imputation, scaling, feature engineering, etc.) is the user's responsibility.
         
         **Pipeline Purpose**:
         - The pipeline is used to extract statistics (e.g., Mx/Wx from StandardScaler) needed for
           forecasting and nowcasting operations, not to preprocess the data
+        - Data is already preprocessed - the pipeline is fitted to extract standardization parameters
         - The pipeline is fitted on the **entire dataset** to extract statistics
         - If `val_split` is provided, it's used for validation during training (e.g., DDFM neural network)
         
         **Usage**:
-        - Data can contain NaN values - models will handle them automatically
+        - Provide preprocessed data (standardized, no missing values)
         - Optionally provide pipeline (e.g., TransformerPipeline with StandardScaler) to extract Mx/Wx for predictions
         - If pipeline=None, uses passthrough (no statistics extracted, Mx/Wx computed from data)
-        - For better performance, users can preprocess data (imputation, scaling) before passing,
-          but it's not required
         """
         # Load data if not already provided
         if self.data is None:
@@ -451,9 +451,6 @@ class DFMDataModule(lightning_pl.LightningDataModule):
             self.time_index = Time
         
         # Convert to pandas DataFrame if needed
-        # Note: DFM/DDFM can handle NaN values implicitly via Kalman filter
-        # (DFM uses handle_missing_data() in Kalman filter, DDFM uses state-space model)
-        # So we don't validate NaN here - let the models handle it
         if isinstance(self.data, np.ndarray):
             series_ids = self.config.get_series_ids()
             X_df = pd.DataFrame(self.data, columns=series_ids)
@@ -508,10 +505,7 @@ class DFMDataModule(lightning_pl.LightningDataModule):
                 f"automatically extracted from the pipeline."
             ) from e
         
-        # Note: DFM/DDFM can handle NaN values implicitly via Kalman filter
-        # So we don't validate NaN here - let the models handle it
-        
-        # Ensure output is pandas DataFrame with compatible index
+        # Ensure output is pandas DataFrame
         if not isinstance(X_transformed, pd.DataFrame):
             # If transformer returned numpy array, convert to pandas
             if isinstance(X_transformed, np.ndarray):
@@ -538,45 +532,6 @@ class DFMDataModule(lightning_pl.LightningDataModule):
                         # Create generic column names
                         X_transformed = pd.DataFrame(X_transformed, 
                             columns=[f'feature_{i}' for i in range(n_cols)])
-                
-                # Ensure index is compatible (DatetimeIndex, PeriodIndex, or RangeIndex)
-                # Use input DataFrame index if length matches
-                if len(X_transformed) == len(X_df):
-                    if isinstance(X_df.index, (pd.DatetimeIndex, pd.PeriodIndex, pd.RangeIndex)):
-                        X_transformed.index = X_df.index
-                    else:
-                        # Try to convert to DatetimeIndex
-                        try:
-                            X_transformed.index = pd.to_datetime(X_df.index)
-                        except (ValueError, TypeError):
-                            # Fallback to RangeIndex
-                            X_transformed.index = pd.RangeIndex(start=0, stop=len(X_transformed))
-                else:
-                    # Length doesn't match - use RangeIndex
-                    X_transformed.index = pd.RangeIndex(start=0, stop=len(X_transformed))
-        
-        # Ensure DataFrame index is compatible (DatetimeIndex, PeriodIndex, or RangeIndex)
-        # This handles cases where pipeline output has incompatible index
-        if isinstance(X_transformed, pd.DataFrame):
-            if not isinstance(X_transformed.index, (pd.DatetimeIndex, pd.PeriodIndex, pd.RangeIndex)):
-                # Try to use input DataFrame index if length matches
-                if len(X_transformed) == len(X_df):
-                    if isinstance(X_df.index, (pd.DatetimeIndex, pd.PeriodIndex, pd.RangeIndex)):
-                        X_transformed.index = X_df.index
-                    else:
-                        # Try to convert to DatetimeIndex
-                        try:
-                            X_transformed.index = pd.to_datetime(X_df.index)
-                        except (ValueError, TypeError):
-                            # Fallback to RangeIndex
-                            X_transformed.index = pd.RangeIndex(start=0, stop=len(X_transformed))
-                else:
-                    # Try to convert existing index
-                    try:
-                        X_transformed.index = pd.to_datetime(X_transformed.index)
-                    except (ValueError, TypeError):
-                        # Fallback to RangeIndex
-                        X_transformed.index = pd.RangeIndex(start=0, stop=len(X_transformed))
             elif hasattr(X_transformed, 'to_numpy'):
                 # Has to_numpy method (pandas DataFrame) - convert to numpy then back to DataFrame
                 # Try to preserve column names if available
@@ -617,7 +572,9 @@ class DFMDataModule(lightning_pl.LightningDataModule):
         # This is optional - some pipelines may not have standardization
         # Mx and Wx are already initialized in __init__
         try:
-            # Extract scaler from pipeline (supports TransformerPipeline, StandardScaler, etc.)
+            # Extract scaler from pipeline (works with TransformerPipeline, StandardScaler directly, or TabularToSeriesAdaptor for backward compatibility)
+            # Supports any scaler type: StandardScaler, MinMaxScaler, RobustScaler, etc.
+            # Note: New code should use StandardScaler() directly per sktime docs (unified scaling)
             scaler = _get_scaler(pipeline_to_use)
             
             if scaler is not None:

dfm_python/lightning/scaling.py

@@ -63,7 +63,7 @@ class ScalingStrategy(Protocol):
         class MyScalingStrategy:
             def get_scaler(self, series: SeriesConfig, series_index: int, 
                           column_name: str) -> Optional[str]:
-                # Custom logic (unified scaling is typically preferred)
+                # Custom logic (not recommended - use unified scaling instead)
                 if 'volatility' in column_name.lower():
                     return 'robust'
                 elif 'return' in column_name.lower():
@@ -191,25 +191,23 @@ def create_scaling_transformer_from_config(
     strategy: Optional[ScalingStrategy] = None,
     column_names: Optional[List[str]] = None
 ) -> Any:
-    """Create a unified scaling transformer from model-level scaler configuration.
+    """Create a unified scaling transformer (StandardScaler for all series).
     
-    This function returns a raw sklearn scaler (StandardScaler, RobustScaler, etc.)
-    that can be used directly in TransformerPipeline. Per sktime docs, sklearn 
-    transformers are automatically applied per series instance when used in 
-    TransformerPipeline.
+    This function returns a raw sklearn StandardScaler that can be used directly
+    in TransformerPipeline. Per sktime docs, sklearn transformers are automatically
+    applied per series instance when used in TransformerPipeline.
     
-    **Unified scaling**: The scaler type is now specified at the model level
-    (in model config YAML) rather than per-series. This ensures all series use
-    the same scaling method, which is the recommended approach for factor models
-    as it ensures all series contribute proportionally to factor extraction.
+    **Default behavior**: Unified scaling (StandardScaler for all series) is the
+    recommended approach for factor models as it ensures all series contribute
+    proportionally to factor extraction.
     
     Parameters
     ----------
     config : DFMConfig
-        DFM configuration containing model-level scaler setting (config.scaler).
-        The scaler type is read from config.scaler (default: 'standard').
+        DFM configuration containing series definitions (used for validation)
     strategy : Optional[ScalingStrategy], default None
-        Custom scaling strategy. If None, uses the scaler type from config.scaler.
+        Custom scaling strategy. If None, uses DefaultScalingStrategy which
+        returns 'standard' for unified scaling.
     column_names : Optional[List[str]], default None
         Column names in data (used for validation). If None, uses
         config.get_series_ids().
@@ -217,9 +215,9 @@ def create_scaling_transformer_from_config(
     Returns
     -------
     Any
-        Raw sklearn scaler (StandardScaler, RobustScaler, etc.) that can be used
-        directly in TransformerPipeline. Per sktime docs, sklearn transformers
-        are applied per series instance automatically when used in TransformerPipeline.
+        Raw sklearn StandardScaler (can be used directly in TransformerPipeline).
+        Per sktime docs, sklearn transformers are applied per series instance
+        automatically when used in TransformerPipeline.
         
     Examples
     --------
@@ -267,25 +265,21 @@ def create_scaling_transformer_from_config(
     """
     _check_sklearn()
     
-    # Get scaler type from model-level config (config.scaler)
-    # Unified scaling: all series use the same scaler specified at model level
-    if hasattr(config, 'scaler') and config.scaler is not None:
-        scaler_type = config.scaler
-    elif strategy is not None:
-        # Fallback to strategy if config.scaler not available
-        if len(config.series) > 0:
-            first_series = config.series[0]
-            first_column_name = config.get_series_ids()[0] if config.series else "series_0"
-            scaler_type = strategy.get_scaler(first_series, 0, first_column_name)
-        else:
-            scaler_type = 'standard'
+    if strategy is None:
+        strategy = DefaultScalingStrategy()
+    
+    # Get scaler type from strategy (default: 'standard' for unified scaling)
+    # For unified scaling, all series use the same scaler
+    if len(config.series) > 0:
+        first_series = config.series[0]
+        first_column_name = config.get_series_ids()[0] if config.series else "series_0"
+        scaler_type = strategy.get_scaler(first_series, 0, first_column_name)
     else:
-        # Default to 'standard' for unified scaling
-        scaler_type = 'standard'
+        scaler_type = 'standard'  # Default if no series
     
     # Return raw sklearn scaler (works directly in TransformerPipeline per sktime docs)
     # Per sktime: sklearn transformers are applied per series instance automatically
-    if scaler_type is None or scaler_type == 'null':
+    if scaler_type is None:
         # No scaling - return passthrough
         from sktime.transformations.series.func_transform import FunctionTransformer
         return FunctionTransformer(func=lambda x: x, inverse_func=lambda x: x)
@@ -295,7 +289,7 @@ def create_scaling_transformer_from_config(
 
 
 # ============================================================================
-# Convenience Function: Simple Uniform Scaling (No ColumnEnsembleTransformer/ColumnTransformer)
+# Convenience Function: Simple Uniform Scaling (No ColumnTransformer)
 # ============================================================================
 
 def create_uniform_scaling_transformer(

dfm_python/logger/inference_logger.py

@@ -207,7 +207,7 @@ class InferenceLogger:
             _logger.info("")
 
 
-# Convenience functions for simpler usage
+# Convenience functions for backward compatibility and simpler usage
 
 def log_inference_start(
     model_name: str = "DFM",

dfm_python/logger/logger.py

@@ -62,7 +62,7 @@ def setup_logging(
 ) -> None:
     """Setup package-wide logging configuration.
     
-    Alias for configure_logging().
+    This is an alias for configure_logging() for backward compatibility.
     
     Parameters
     ----------

dfm_python/logger/train_logger.py

@@ -328,7 +328,7 @@ class TrainLogger:
             _logger.info("")
 
 
-# Convenience functions for simpler usage
+# Convenience functions for backward compatibility and simpler usage
 
 def log_training_start(
     model_name: str = "DFM",

dfm_python/models/base.py

@@ -91,6 +91,7 @@ class BaseFactorModel(pl.LightningModule):
         self._result: Optional[BaseResult] = None
         self.training_state: Optional[Any] = None
         self._data_module: Optional[Any] = None
+        self._nowcast: Optional[Any] = None
     
     @property
     def config(self) -> DFMConfig:
@@ -493,6 +494,7 @@ class BaseFactorModel(pl.LightningModule):
         self._config = None
         self._data_module = None
         self._result = None
+        self._nowcast = None
         if hasattr(self, 'training_state'):
             self.training_state = None
         return self