dfm-python 0.4.5__py3-none-any.whl → 0.4.7__py3-none-any.whl

dfm_python/__init__.py

@@ -6,7 +6,6 @@ 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 
@@ -23,7 +22,6 @@ 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
@@ -67,7 +65,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.5"
+__version__ = "0.4.7"
 
 # ============================================================================
 # PUBLIC API DEFINITION
@@ -81,7 +79,7 @@ __version__ = "0.4.5"
 # 2. High-level API: DFM, DDFM, module-level convenience functions
 # 3. Core utilities: TimeIndex, diagnostics
 # 4. Models: BaseFactorModel, DDFM (low-level)
-# 5. Nowcasting: Nowcast, result classes, para_const
+# 5. Data & Results: DFMResult
 # 6. Data & Results: DFMResult
 # ============================================================================
 
@@ -110,16 +108,7 @@ from .lightning import (
     EMAlgorithm,  # Module class
 )
 
-# Nowcasting (from nowcast/ subpackage)
-from .nowcast import (
-    Nowcast,
-    NowcastResult,
-)
-from .nowcast.helpers import (
-    para_const,
-    NewsDecompResult,
-    BacktestResult,
-)
+# Nowcasting removed - use src.nowcast instead
 
 # Model implementations
 from .models.base import BaseFactorModel
@@ -130,11 +119,9 @@ from .models.ddfm import DDFM, DDFMModel
 
 __all__ = [
     # Core classes
-    'DFM', 'Nowcast',
+    'DFM',
     # Model base and implementations
     'BaseFactorModel',
-    # Nowcast result classes
-    'NowcastResult', 'NewsDecompResult', 'BacktestResult',
     # Constants
     'DEFAULT_BLOCK_NAME',
     # Config sources
@@ -142,7 +129,6 @@ __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,8 +214,7 @@ class YamlSource:
                         frequency=series_data.get('frequency', 'm'),
                         transformation=series_data.get('transformation', 'lin'),
                         blocks=series_data.get('blocks', []),
-                        release_date=release_date,
-                        scaler=series_data.get('scaler', None)  # Optional, for per-series scaling
+                        release_date=release_date
                     ))
         
         # If no series loaded from separate files, try to get from main config

dfm_python/config/schema.py

@@ -200,11 +200,6 @@ 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
@@ -215,7 +210,6 @@ 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."""
@@ -308,6 +302,7 @@ 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)
@@ -660,6 +655,7 @@ 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
@@ -716,11 +712,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 = 'tanh'  # Activation function ('tanh', 'relu', 'sigmoid', default: 'tanh')
+    activation: str = 'relu'  # Activation function ('tanh', 'relu', 'sigmoid', default: 'relu' to match original DDFM)
     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 = 32  # Batch size for training (default: 32)
+    batch_size: int = 100  # Batch size for training (default: 100 to match original DDFM)
     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)
@@ -750,15 +746,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 (for backward compatibility)
+        # Handle both direct keys and ddfm_ prefix format
         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', 'tanh'),
+            'activation': data.get('activation') or data.get('ddfm_activation', 'relu'),
             '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', 32)),
+            'batch_size': data.get('batch_size', data.get('ddfm_batch_size', 100)),
             '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)),
@@ -832,8 +828,7 @@ 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
-                    scaler=series_cfg.get('scaler', None)  # Optional, for per-series scaling
+                    release_date=series_cfg.get('release_date', None)  # Optional, for nowcasting
                 ))
         
         # 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 = 32,
+    batch_size: int = 100,
     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 32
-        Batch size for training
+    batch_size : int, default 100
+        Batch size for training (matches original DDFM)
     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 (for backward compatibility)
+        Original untransformed data (T x N), same as X
         
     Raises
     ------

dfm_python/encoder/vae.py

@@ -454,6 +454,21 @@ 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,15 +28,14 @@ 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',  # New module class
+    'KalmanFilter',
     'KalmanFilterState',
     # EM algorithm
-    'EMAlgorithm',  # New module class
+    'EMAlgorithm',
     'EMStepParams',
     # Data handling
     'DFMDataModule',
@@ -50,7 +49,5 @@ __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,13 +43,11 @@ 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 (can be any scaler, StandardScaler directly, or TabularToSeriesAdaptor for backward compatibility). 
-        TransformerPipeline, sklearn Pipeline, etc.)
+        Transformer to search (StandardScaler, TransformerPipeline, sklearn Pipeline, etc.)
         
     Returns
     -------
@@ -60,9 +58,7 @@ def _get_scaler(transformer: Any) -> Optional[Any]:
     if transformer is None:
         return None
     
-    # 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
+    # Check if transformer is wrapped (TabularToSeriesAdaptor or similar)
     if hasattr(transformer, 'transformer'):
         # Recursively search the wrapped transformer
         wrapped = transformer.transformer
@@ -78,8 +74,7 @@ def _get_scaler(transformer: Any) -> Optional[Any]:
             if scaler is not None:
                 return scaler
     
-    # Check if transformer is ColumnTransformer (backward compatibility only - not recommended for new code)
-    # Unified scaling with StandardScaler is preferred per sktime docs
+    # Check if transformer is ColumnEnsembleTransformer (or ColumnTransformer)
     if hasattr(transformer, 'transformers'):
         for name, trans, cols in transformer.transformers:
             scaler = _get_scaler(trans)
@@ -261,15 +256,17 @@ class DFMDataModule(lightning_pl.LightningDataModule):
     
     This DataModule handles data loading for DFM/DDFM models.
     
-    **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.
+    **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
     
     **Usage Pattern**:
-    - Provide already-preprocessed data (standardized, no missing values, feature-engineered)
+    - Data can contain NaN values - models will handle them implicitly
     - 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.
@@ -311,9 +308,10 @@ 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
-        Preprocessed data array or DataFrame. Data must be:
-        - Standardized/scaled (mean=0, std=1 recommended for DFM/DDFM)
-        - No missing values (NaN-free)
+        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
         - Feature-engineered if needed
         If None, data_path must be provided.
     time_index : TimeIndex, optional
@@ -417,20 +415,22 @@ 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**: 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.
+        **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
         
         **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**:
-        - Provide preprocessed data (standardized, no missing values)
+        - Data can contain NaN values - models will handle them automatically
         - 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,6 +451,9 @@ 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)
@@ -505,7 +508,10 @@ class DFMDataModule(lightning_pl.LightningDataModule):
                 f"automatically extracted from the pipeline."
             ) from e
         
-        # Ensure output is pandas DataFrame
+        # 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
         if not isinstance(X_transformed, pd.DataFrame):
             # If transformer returned numpy array, convert to pandas
             if isinstance(X_transformed, np.ndarray):
@@ -532,6 +538,45 @@ 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
@@ -572,9 +617,7 @@ 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 (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)
+            # Extract scaler from pipeline (supports TransformerPipeline, StandardScaler, etc.)
             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 (not recommended - use unified scaling instead)
+                # Custom logic (unified scaling is typically preferred)
                 if 'volatility' in column_name.lower():
                     return 'robust'
                 elif 'return' in column_name.lower():
@@ -191,23 +191,25 @@ def create_scaling_transformer_from_config(
     strategy: Optional[ScalingStrategy] = None,
     column_names: Optional[List[str]] = None
 ) -> Any:
-    """Create a unified scaling transformer (StandardScaler for all series).
+    """Create a unified scaling transformer from model-level scaler configuration.
     
-    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.
+    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.
     
-    **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.
+    **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.
     
     Parameters
     ----------
     config : DFMConfig
-        DFM configuration containing series definitions (used for validation)
+        DFM configuration containing model-level scaler setting (config.scaler).
+        The scaler type is read from config.scaler (default: 'standard').
     strategy : Optional[ScalingStrategy], default None
-        Custom scaling strategy. If None, uses DefaultScalingStrategy which
-        returns 'standard' for unified scaling.
+        Custom scaling strategy. If None, uses the scaler type from config.scaler.
     column_names : Optional[List[str]], default None
         Column names in data (used for validation). If None, uses
         config.get_series_ids().
@@ -215,9 +217,9 @@ def create_scaling_transformer_from_config(
     Returns
     -------
     Any
-        Raw sklearn StandardScaler (can be used directly in TransformerPipeline).
-        Per sktime docs, sklearn transformers are applied per series instance
-        automatically when used in TransformerPipeline.
+        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.
         
     Examples
     --------
@@ -265,21 +267,25 @@ def create_scaling_transformer_from_config(
     """
     _check_sklearn()
     
-    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)
+    # 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'
     else:
-        scaler_type = 'standard'  # Default if no series
+        # Default to 'standard' for unified scaling
+        scaler_type = 'standard'
     
     # 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:
+    if scaler_type is None or scaler_type == 'null':
         # No scaling - return passthrough
         from sktime.transformations.series.func_transform import FunctionTransformer
         return FunctionTransformer(func=lambda x: x, inverse_func=lambda x: x)
@@ -289,7 +295,7 @@ def create_scaling_transformer_from_config(
 
 
 # ============================================================================
-# Convenience Function: Simple Uniform Scaling (No ColumnTransformer)
+# Convenience Function: Simple Uniform Scaling (No ColumnEnsembleTransformer/ColumnTransformer)
 # ============================================================================
 
 def create_uniform_scaling_transformer(

dfm_python/logger/inference_logger.py

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

dfm_python/logger/logger.py

@@ -14,6 +14,11 @@ def get_logger(name: str) -> logging.Logger:
     This is the standard way to get a logger in the DFM package.
     All modules should use: _logger = get_logger(__name__)
     
+    The logger uses hierarchical configuration:
+    - Child loggers (e.g., 'dfm_python.models.dfm') inherit from parent logger ('dfm_python')
+    - Parent logger ('dfm_python') is configured once with handlers
+    - Child loggers propagate to parent (default behavior)
+    
     Parameters
     ----------
     name : str
@@ -26,21 +31,27 @@ def get_logger(name: str) -> logging.Logger:
     """
     logger = logging.getLogger(name)
     
-    # Only configure if not already configured
-    if not logger.handlers:
-        # Use package-level logger configuration
-        package_logger = logging.getLogger('dfm_python')
-        if not package_logger.handlers:
-            # Configure root logger for dfm_python package
-            handler = logging.StreamHandler(sys.stdout)
-            handler.setFormatter(
-                logging.Formatter(
-                    '%(asctime)s - %(name)s - %(levelname)s - %(message)s',
-                    datefmt='%Y-%m-%d %H:%M:%S'
-                )
+    # Ensure package-level logger is configured (only once)
+    package_logger = logging.getLogger('dfm_python')
+    
+    # Configure package logger if not already configured
+    # Use a flag to avoid re-configuring if already done
+    if not hasattr(package_logger, '_dfm_configured'):
+        # Configure root logger for dfm_python package
+        handler = logging.StreamHandler(sys.stdout)
+        handler.setFormatter(
+            logging.Formatter(
+                '%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+                datefmt='%Y-%m-%d %H:%M:%S'
             )
-            package_logger.addHandler(handler)
-            package_logger.setLevel(logging.INFO)
+        )
+        package_logger.addHandler(handler)
+        package_logger.setLevel(logging.INFO)
+        # Mark as configured to avoid duplicate handlers
+        package_logger._dfm_configured = True
+    
+    # Ensure child logger propagates to parent (default, but explicit for clarity)
+    logger.propagate = True
     
     return logger
 
@@ -51,7 +62,7 @@ def setup_logging(
 ) -> None:
     """Setup package-wide logging configuration.
     
-    This is an alias for configure_logging() for backward compatibility.
+    Alias for configure_logging().
     
     Parameters
     ----------
@@ -93,8 +104,11 @@ def configure_logging(
     logger = logging.getLogger('dfm_python')
     logger.setLevel(level)
     
-    # Remove existing handlers
+    # Remove existing handlers to avoid duplicates
     logger.handlers.clear()
+    # Clear the configuration flag so it can be reconfigured
+    if hasattr(logger, '_dfm_configured'):
+        delattr(logger, '_dfm_configured')
     
     # Add console handler
     console_handler = logging.StreamHandler(sys.stdout)

dfm_python/logger/train_logger.py

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

dfm_python/models/base.py

@@ -91,7 +91,6 @@ 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:
@@ -494,7 +493,6 @@ 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