dfm-python 0.4.2__py3-none-any.whl → 0.4.3__py3-none-any.whl

dfm_python/config/schema.py

@@ -19,7 +19,7 @@ Blocks are defined as Dict[str, Dict[str, Any]] where each block is a dict with:
 - ar_lag: int (AR lag order)
 - clock: str (block clock frequency)
 
-For loading configurations from files (YAML, Spec CSV) or other sources,
+For loading configurations from files (YAML) or other sources,
 see the config.adapter module which provides source adapters.
 """
 
@@ -89,7 +89,7 @@ def _parse_blocks_dict(blocks_data: Dict[str, Any]) -> Dict[str, Dict[str, Any]]
     return blocks_dict
 
 
-def _infer_blocks_from_series(
+def _infer_blocks(
     series_list: List['SeriesConfig'],
     data: Dict[str, Any]
 ) -> Dict[str, Dict[str, Any]]:
@@ -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."""
@@ -648,7 +654,7 @@ class DFMConfig(BaseModelConfig):
     # ========================================================================
     
     @classmethod
-    def _extract_base_params(cls, data: Dict[str, Any]) -> Dict[str, Any]:
+    def _extract_base(cls, data: Dict[str, Any]) -> Dict[str, Any]:
         """Extract shared base parameters from config dict."""
         return {
             'nan_method': data.get('nan_method', 2),
@@ -659,7 +665,7 @@ class DFMConfig(BaseModelConfig):
     @classmethod
     def _extract_dfm_params(cls, data: Dict[str, Any]) -> Dict[str, Any]:
         """Extract DFM-specific parameters from config dict."""
-        base_params = cls._extract_base_params(data)
+        base_params = cls._extract_base(data)
         base_params.update({
             'ar_lag': data.get('ar_lag', 1),
             'threshold': data.get('threshold', 1e-5),
@@ -731,50 +737,19 @@ class DDFMConfig(BaseModelConfig):
     # ========================================================================
     
     @classmethod
-    def _extract_base_params(cls, data: Dict[str, Any]) -> Dict[str, Any]:
-        """Extract shared base parameters from config dict."""
-        return {
-            'nan_method': data.get('nan_method', 2),
-            'nan_k': data.get('nan_k', 3),
-            'clock': data.get('clock', 'm'),
-        }
+    def _extract_base(cls, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Extract shared base parameters from config dict (delegates to DFMConfig)."""
+        return DFMConfig._extract_base(data)
     
     @classmethod
     def _extract_dfm_params(cls, data: Dict[str, Any]) -> Dict[str, Any]:
-        """Extract DFM-specific parameters from config dict."""
-        base_params = cls._extract_base_params(data)
-        base_params.update({
-            'ar_lag': data.get('ar_lag', 1),
-            'threshold': data.get('threshold', 1e-5),
-            'max_iter': data.get('max_iter', 5000),
-            # Numerical stability parameters
-            'clip_ar_coefficients': data.get('clip_ar_coefficients', True),
-            'ar_clip_min': data.get('ar_clip_min', -0.99),
-            'ar_clip_max': data.get('ar_clip_max', 0.99),
-            'warn_on_ar_clip': data.get('warn_on_ar_clip', True),
-            'clip_data_values': data.get('clip_data_values', True),
-            'data_clip_threshold': data.get('data_clip_threshold', 100.0),
-            'warn_on_data_clip': data.get('warn_on_data_clip', True),
-            'use_regularization': data.get('use_regularization', True),
-            'regularization_scale': data.get('regularization_scale', 1e-5),
-            'min_eigenvalue': data.get('min_eigenvalue', 1e-8),
-            'max_eigenvalue': data.get('max_eigenvalue', 1e6),
-            'warn_on_regularization': data.get('warn_on_regularization', True),
-            'use_damped_updates': data.get('use_damped_updates', True),
-            'damping_factor': data.get('damping_factor', 0.8),
-            'warn_on_damped_update': data.get('warn_on_damped_update', True),
-            # Idiosyncratic component augmentation
-            'augment_idio': data.get('augment_idio', True),
-            'augment_idio_slow': data.get('augment_idio_slow', True),
-            'idio_rho0': data.get('idio_rho0', 0.1),
-            'idio_min_var': data.get('idio_min_var', 1e-8),
-        })
-        return base_params
+        """Extract DFM-specific parameters from config dict (delegates to DFMConfig)."""
+        return DFMConfig._extract_dfm_params(data)
     
     @classmethod
-    def _extract_ddfm_params(cls, data: Dict[str, Any]) -> Dict[str, Any]:
+    def _extract_ddfm(cls, data: Dict[str, Any]) -> Dict[str, Any]:
         """Extract DDFM-specific parameters from config dict."""
-        base_params = cls._extract_base_params(data)
+        base_params = cls._extract_base(data)
         # 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),
@@ -810,7 +785,7 @@ class DDFMConfig(BaseModelConfig):
             factors_per_block = data.get('factors_per_block', None)
         
         # If block_names is still empty, try to infer from series blocks
-        if not block_names and 'series' in data:
+        if not block_names and 'series' in data and isinstance(data['series'], dict):
             # Collect all unique block names from series
             all_blocks = set()
             for series_cfg in data['series'].values():
@@ -856,7 +831,9 @@ class DDFMConfig(BaseModelConfig):
                     frequency=series_cfg.get('frequency', 'm'),
                     transformation=series_cfg.get('transformation', 'lin'),
                     blocks=series_blocks,
-                    units=series_cfg.get('units', None)  # Optional, for display only
+                    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
                 ))
         
         # Convert blocks_dict to dict of block properties
@@ -893,7 +870,7 @@ class DDFMConfig(BaseModelConfig):
             return DDFMConfig(
                 series=series_list,
                 blocks=blocks_dict_final,
-                **DDFMConfig._extract_ddfm_params(data)
+                **DDFMConfig._extract_ddfm(data)
             )
         else:
             return DFMConfig(
@@ -930,7 +907,7 @@ class DDFMConfig(BaseModelConfig):
                     raise ValueError(f"blocks must be a dict, got {type(blocks_data)}")
             else:
                 # If no blocks provided, infer from series using helper
-                blocks_dict = _infer_blocks_from_series(series_list, data)
+                blocks_dict = _infer_blocks(series_list, data)
             
             # Determine config type using helper function
             config_type = _detect_config_type(data)
@@ -939,7 +916,7 @@ class DDFMConfig(BaseModelConfig):
                 return DDFMConfig(
                     series=series_list,
                     blocks=blocks_dict,
-                    **DDFMConfig._extract_ddfm_params(data)
+                    **DDFMConfig._extract_ddfm(data)
                 )
             else:
                 return DFMConfig(
@@ -1016,7 +993,7 @@ def _dfm_from_dict(cls, data: Dict[str, Any]) -> Union['DFMConfig', 'DDFMConfig'
             return DDFMConfig(
                 series=series_list,
                 blocks=blocks_dict,
-                **DDFMConfig._extract_ddfm_params(data)
+                **DDFMConfig._extract_ddfm(data)
             )
         else:
             return DFMConfig(
@@ -1033,8 +1010,8 @@ def _dfm_from_dict(cls, data: Dict[str, Any]) -> Union['DFMConfig', 'DDFMConfig'
     else:
         return DFMConfig(**data)
 
-def _dfm_from_hydra(cls, cfg: Any) -> 'DFMConfig':
-    """Create DFMConfig from Hydra config."""
+def _from_hydra(cls, cfg: Any) -> Union['DFMConfig', 'DDFMConfig']:
+    """Create config from Hydra DictConfig (auto-detects DFM/DDFM)."""
     try:
         from omegaconf import DictConfig, OmegaConf
         if isinstance(cfg, DictConfig):
@@ -1043,10 +1020,10 @@ def _dfm_from_hydra(cls, cfg: Any) -> 'DFMConfig':
         pass
     if not isinstance(cfg, dict):
         raise TypeError("from_hydra expects a DictConfig or dict.")
-    return DFMConfig.from_dict(cfg)
+    return cls.from_dict(cfg)
 
 DFMConfig.from_dict = classmethod(_dfm_from_dict)
-DFMConfig.from_hydra = classmethod(_dfm_from_hydra)
+DFMConfig.from_hydra = classmethod(_from_hydra)
 
 # Add factory methods to DDFMConfig class
 def _ddfm_from_dict(cls, data: Dict[str, Any]) -> Union['DFMConfig', 'DDFMConfig']:
@@ -1083,7 +1060,7 @@ def _ddfm_from_dict(cls, data: Dict[str, Any]) -> Union['DFMConfig', 'DDFMConfig
             return DDFMConfig(
                 series=series_list,
                 blocks=blocks_dict,
-                **DDFMConfig._extract_ddfm_params(data)
+                **DDFMConfig._extract_ddfm(data)
             )
         else:
             return DFMConfig(
@@ -1105,19 +1082,7 @@ def _ddfm_from_dict(cls, data: Dict[str, Any]) -> Union['DFMConfig', 'DDFMConfig
     else:
         return DFMConfig(**data)
 
-def _ddfm_from_hydra(cls, cfg: Any) -> 'DDFMConfig':
-    """Create DDFMConfig from Hydra config."""
-    try:
-        from omegaconf import DictConfig, OmegaConf
-        if isinstance(cfg, DictConfig):
-            cfg = OmegaConf.to_container(cfg, resolve=True)
-    except Exception:
-        pass
-    if not isinstance(cfg, dict):
-        raise TypeError("from_hydra expects a DictConfig or dict.")
-    return DDFMConfig.from_dict(cfg)
-
 DDFMConfig.from_dict = classmethod(_ddfm_from_dict)
-DDFMConfig.from_hydra = classmethod(_ddfm_from_hydra)
+DDFMConfig.from_hydra = classmethod(_from_hydra)
 
 

dfm_python/config/utils.py

@@ -3,8 +3,8 @@
 This module provides:
 1. Validation functions: validate_frequency, validate_transformation
 2. Frequency hierarchy and period calculations: FREQUENCY_HIERARCHY, PERIODS_PER_YEAR, get_periods_per_year, get_annual_factor
-3. Tent kernel utilities: generate_tent_weights, generate_R_mat, get_tent_weights_for_pair
-4. Aggregation structure: get_aggregation_structure, group_series_by_frequency, compute_idio_chain_lengths
+3. Tent kernel utilities: generate_tent_weights, generate_R_mat, get_tent_weights
+4. Aggregation structure: get_agg_structure, group_by_freq, compute_idio_lengths
 5. Transformation mappings: TRANSFORM_UNITS_MAP
 """
 
@@ -299,7 +299,7 @@ def generate_R_mat(tent_weights: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
     return R_mat, q
 
 
-def get_tent_weights_for_pair(slower_freq: str, faster_freq: str) -> Optional[np.ndarray]:
+def get_tent_weights(slower_freq: str, faster_freq: str) -> Optional[np.ndarray]:
     """Get deterministic tent weights for a frequency pair.
     
     Parameters:
@@ -316,16 +316,16 @@ def get_tent_weights_for_pair(slower_freq: str, faster_freq: str) -> Optional[np
         
     Examples:
     --------
-    >>> get_tent_weights_for_pair('q', 'm')
+    >>> get_tent_weights('q', 'm')
     array([1, 2, 3, 2, 1])  # Quarterly -> monthly
     
-    >>> get_tent_weights_for_pair('m', 'd')
+    >>> get_tent_weights('m', 'd')
     None  # Not supported (too large gap)
     """
     return TENT_WEIGHTS_LOOKUP.get((slower_freq, faster_freq))
 
 
-def get_aggregation_structure(
+def get_agg_structure(
     config: 'DFMConfig', 
     clock: str = 'm'
 ) -> Dict[str, Any]:
@@ -366,7 +366,7 @@ def get_aggregation_structure(
     --------
     >>> from dfm_python import load_config
     >>> config = load_config('config.yaml')
-    >>> agg_info = get_aggregation_structure(config, clock='m')
+    >>> agg_info = get_agg_structure(config, clock='m')
     >>> # Check which frequencies need tent kernels
     >>> print(agg_info['tent_weights'])
     {'q': array([1, 2, 3, 2, 1]), 'sa': array([1, 2, 3, 4, 3, 2, 1])}
@@ -382,7 +382,7 @@ def get_aggregation_structure(
     for freq in frequencies:
         if FREQUENCY_HIERARCHY.get(freq, 999) > FREQUENCY_HIERARCHY.get(clock, 0):
             # This frequency is slower than clock, check if tent kernel is available
-            tent_w = get_tent_weights_for_pair(freq, clock)
+            tent_w = get_tent_weights(freq, clock)
             if tent_w is not None and len(tent_w) <= MAX_TENT_SIZE:
                 # Tent kernel available and within size limit
                 tent_weights[freq] = tent_w
@@ -400,7 +400,7 @@ def get_aggregation_structure(
     }
 
 
-def group_series_by_frequency(
+def group_by_freq(
     idx_i: np.ndarray,
     frequencies: np.ndarray,
     clock: str
@@ -477,7 +477,7 @@ def group_series_by_frequency(
     return {freq: np.array(indices, dtype=int) for freq, indices in freq_groups.items()}
 
 
-def compute_idio_chain_lengths(
+def compute_idio_lengths(
     config: 'DFMConfig',
     clock: str,
     tent_weights_dict: Optional[Dict[str, np.ndarray]] = None
@@ -496,7 +496,7 @@ def compute_idio_chain_lengths(
         Clock frequency ('d', 'w', 'm', 'q', 'sa', 'a')
     tent_weights_dict : Dict[str, np.ndarray], optional
         Dictionary mapping frequency strings to tent weight arrays.
-        If None, will be computed from config using get_aggregation_structure.
+        If None, will be computed from config using get_agg_structure.
         
     Returns
     -------
@@ -510,7 +510,7 @@ def compute_idio_chain_lengths(
     --------
     >>> from dfm_python import load_config
     >>> config = load_config('config.yaml')
-    >>> lengths = compute_idio_chain_lengths(config, clock='m')
+    >>> lengths = compute_idio_lengths(config, clock='m')
     >>> # Returns array with 1 for monthly series, 5 for quarterly, etc.
     """
     if not config.augment_idio:
@@ -523,7 +523,7 @@ def compute_idio_chain_lengths(
     
     # Get tent weights if not provided
     if tent_weights_dict is None:
-        agg_structure = get_aggregation_structure(config, clock=clock)
+        agg_structure = get_agg_structure(config, clock=clock)
         tent_weights_dict = agg_structure.get('tent_weights', {})
     
     lengths = np.zeros(len(config.series), dtype=int)

dfm_python/data/__init__.py

@@ -1,29 +1,18 @@
-"""Data loading, transformation, and dataset utilities for DFM.
+"""Data loading and dataset utilities for DFM.
 
 This module provides:
 - Dataset classes: DFMDataset (linear DFM), DDFMDataset (deep DDFM)
 - DataLoader factories: create_dfm_dataloader, create_ddfm_dataloader
 - Data reading: read_data, load_data
-- Transformation functions: pch_transform, pc1_transform, etc.
+
+Note: Transformation functions are application-specific and should be provided
+by users in their preprocessing pipelines. The package does not include
+transformation utilities to remain generic.
 """
 
 from .dataset import DFMDataset, DDFMDataset
 from .dataloader import create_dfm_dataloader, create_ddfm_dataloader
 from .utils import read_data, load_data
-from .transformation import (
-    pch_transform,
-    pc1_transform,
-    pca_transform,
-    cch_transform,
-    cca_transform,
-    log_transform,
-    identity_transform,
-    make_pch_transformer,
-    make_pc1_transformer,
-    make_pca_transformer,
-    make_cch_transformer,
-    make_cca_transformer,
-)
 
 __all__ = [
     # Datasets
@@ -35,18 +24,5 @@ __all__ = [
     # Data reading
     'read_data',
     'load_data',
-    # Transformations
-    'pch_transform',
-    'pc1_transform',
-    'pca_transform',
-    'cch_transform',
-    'cca_transform',
-    'log_transform',
-    'identity_transform',
-    'make_pch_transformer',
-    'make_pc1_transformer',
-    'make_pca_transformer',
-    'make_cch_transformer',
-    'make_cca_transformer',
 ]
 

dfm_python/data/dataloader.py

@@ -7,13 +7,56 @@ DDFM uses a standard DataLoader with batching for neural network training.
 
 import torch
 from torch.utils.data import DataLoader
-from typing import Optional
+from typing import Optional, Union
 from .dataset import DFMDataset, DDFMDataset
 from ..logger import get_logger
 
 _logger = get_logger(__name__)
 
 
+def _create_dataloader(
+    dataset: Union[DFMDataset, DDFMDataset],
+    batch_size: int,
+    shuffle: bool,
+    num_workers: int,
+    pin_memory: bool,
+    auto_pin_memory: bool = False
+) -> DataLoader:
+    """Create DataLoader (shared helper).
+    
+    Parameters
+    ----------
+    dataset : DFMDataset or DDFMDataset
+        Dataset instance
+    batch_size : int
+        Batch size
+    shuffle : bool
+        Whether to shuffle data
+    num_workers : int
+        Number of worker processes
+    pin_memory : bool
+        Whether to pin memory for faster GPU transfer
+    auto_pin_memory : bool, default False
+        If True, automatically disable pin_memory if CUDA is not available
+        
+    Returns
+    -------
+    DataLoader
+        PyTorch DataLoader
+    """
+    if auto_pin_memory and not torch.cuda.is_available():
+        pin_memory = False
+    
+    return DataLoader(
+        dataset,
+        batch_size=batch_size,
+        shuffle=shuffle,
+        num_workers=num_workers,
+        pin_memory=pin_memory,
+        drop_last=False
+    )
+
+
 def create_dfm_dataloader(
     dataset: DFMDataset,
     batch_size: Optional[int] = None,
@@ -44,15 +87,15 @@ def create_dfm_dataloader(
         Configured DataLoader for DFM
     """
     if batch_size is None:
-        batch_size = len(dataset)  # Typically 1 for full sequence
+        batch_size = len(dataset)
     
-    return DataLoader(
+    return _create_dataloader(
         dataset,
         batch_size=batch_size,
-        shuffle=False,  # No shuffle for full sequence
+        shuffle=False,
         num_workers=num_workers,
         pin_memory=pin_memory,
-        drop_last=False
+        auto_pin_memory=False
     )
 
 
@@ -86,12 +129,12 @@ def create_ddfm_dataloader(
     DataLoader
         Configured DataLoader for DDFM
     """
-    return DataLoader(
+    return _create_dataloader(
         dataset,
         batch_size=batch_size,
         shuffle=shuffle,
         num_workers=num_workers,
-        pin_memory=pin_memory if torch.cuda.is_available() else False,
-        drop_last=False
+        pin_memory=pin_memory,
+        auto_pin_memory=True
     )
 

dfm_python/data/utils.py

@@ -11,14 +11,14 @@ from typing import List, Optional, Tuple, Union
 from datetime import datetime
 
 import numpy as np
-import polars as pl
+import pandas as pd
 
 from ..config import DFMConfig
 from ..config.utils import FREQUENCY_HIERARCHY
 from ..utils.time import TimeIndex, parse_timestamp
 from ..utils.helpers import (
     safe_get_attr,
-    get_frequencies_from_config,
+    get_frequencies,
     get_series_ids,
 )
 from ..config.utils import get_periods_per_year
@@ -63,9 +63,8 @@ def read_data(datafile: Union[str, Path]) -> Tuple[np.ndarray, TimeIndex, List[s
     
     # Read data file
     try:
-        # Use infer_schema_length=None to infer all rows, and try_parse_dates=False
-        # to avoid parsing issues with mixed numeric/string columns
-        df = pl.read_csv(datafile, infer_schema_length=None, try_parse_dates=False)
+        # Use pandas read_csv with low_memory=False to infer all columns properly
+        df = pd.read_csv(datafile, low_memory=False)
     except Exception as e:
         raise ValueError(f"Failed to read data file {datafile}: {e}")
     
@@ -87,7 +86,7 @@ def read_data(datafile: Union[str, Path]) -> Tuple[np.ndarray, TimeIndex, List[s
     # Skip this check if first column is integer (likely date_id) - treat as standard format
     if not is_date_first:
         first_col_type = df[first_col].dtype
-        is_integer_id = first_col_type in [pl.Int64, pl.Int32, pl.Int16, pl.Int8, pl.UInt64, pl.UInt32, pl.UInt16, pl.UInt8]
+        is_integer_id = pd.api.types.is_integer_dtype(first_col_type)
         
         # Only check for long format if first column is not an integer ID
         if not is_integer_id:
@@ -95,16 +94,16 @@ def read_data(datafile: Union[str, Path]) -> Tuple[np.ndarray, TimeIndex, List[s
             date_cols = []
             for col in df.columns:
                 try:
-                    parse_timestamp(str(df[col][0]))
+                    parse_timestamp(str(df[col].iloc[0]))
                     date_cols.append(col)
-                except (ValueError, TypeError):
+                except (ValueError, TypeError, IndexError):
                     pass
             
             if len(date_cols) > 0:
                 # Long format: transpose and use first date column as index
                 first_date_col = date_cols[0]
-                date_col_idx = df.columns.index(first_date_col)
-                date_cols_all = df.columns[date_col_idx:]
+                date_col_idx = df.columns.get_loc(first_date_col)
+                date_cols_all = df.columns[date_col_idx:].tolist()
                 
                 # Extract dates from column names (they are dates in long format)
                 dates = []
@@ -117,10 +116,10 @@ def read_data(datafile: Union[str, Path]) -> Tuple[np.ndarray, TimeIndex, List[s
                 
                 # Transpose: rows become series, columns become time
                 # Select date columns and transpose
-                date_data = df.select(date_cols_all)
+                date_data = df[date_cols_all]
                 Z = date_data.to_numpy().T.astype(float)
                 Time = TimeIndex(dates)
-                mnemonics = df[first_col].to_list() if first_col in df.columns else [f"series_{i}" for i in range(len(df))]
+                mnemonics = df[first_col].tolist() if first_col in df.columns else [f"series_{i}" for i in range(len(df))]
                 
                 return Z, Time, mnemonics
     
@@ -129,31 +128,30 @@ def read_data(datafile: Union[str, Path]) -> Tuple[np.ndarray, TimeIndex, List[s
     try:
         # Check if first column is integer (date_id format)
         first_col_type = df[first_col].dtype
-        if first_col_type in [pl.Int64, pl.Int32, pl.Int16, pl.Int8, pl.UInt64, pl.UInt32, pl.UInt16, pl.UInt8]:
+        if pd.api.types.is_integer_dtype(first_col_type):
             # Integer date_id: use as sequential index, generate synthetic dates
             n_periods = len(df)
             from datetime import timedelta
             # Start from a default date and increment by day
             start_date = datetime(2000, 1, 1)
-            dates = [start_date + timedelta(days=int(df[first_col][i])) for i in range(n_periods)]
+            dates = [start_date + timedelta(days=int(df[first_col].iloc[i])) for i in range(n_periods)]
             Time = TimeIndex(dates)
         else:
-            # Try to parse as date
-            time_series = df[first_col].cast(pl.Utf8).str.strptime(pl.Datetime, "%Y-%m-%d", strict=False)
-            # If that fails, try other formats
-            if time_series.null_count() > 0:
-                # Try parsing as string first
-                time_series = df[first_col].str.strptime(pl.Datetime, strict=False)
+            # Try to parse as date using pandas
+            time_series = pd.to_datetime(df[first_col], errors='coerce', format='%Y-%m-%d')
+            # If that fails, try without format
+            if time_series.isna().any():
+                time_series = pd.to_datetime(df[first_col], errors='coerce')
             Time = TimeIndex(time_series)
     except (ValueError, TypeError) as e:
         # If date parsing fails, treat first column as integer date_id
         try:
             first_col_type = df[first_col].dtype
-            if first_col_type in [pl.Int64, pl.Int32, pl.Int16, pl.Int8, pl.UInt64, pl.UInt32, pl.UInt16, pl.UInt8]:
+            if pd.api.types.is_integer_dtype(first_col_type):
                 n_periods = len(df)
                 from datetime import timedelta
                 start_date = datetime(2000, 1, 1)
-                dates = [start_date + timedelta(days=int(df[first_col][i])) for i in range(n_periods)]
+                dates = [start_date + timedelta(days=int(df[first_col].iloc[i])) for i in range(n_periods)]
                 Time = TimeIndex(dates)
             else:
                 raise ValueError(f"Failed to parse date column '{first_col}': {e}")
@@ -162,7 +160,7 @@ def read_data(datafile: Union[str, Path]) -> Tuple[np.ndarray, TimeIndex, List[s
     
     # Extract series data (all columns except first)
     series_cols = [col for col in df.columns if col != first_col]
-    series_data = df.select(series_cols)
+    series_data = df[series_cols]
     Z = series_data.to_numpy().astype(float)
     mnemonics = series_cols
     
@@ -240,8 +238,8 @@ def load_data(
         if isinstance(sample_start, str):
             sample_start = parse_timestamp(sample_start)
         mask = Time >= sample_start
-        if isinstance(mask, pl.Series):
-            mask = mask.to_numpy()
+        if isinstance(mask, pd.Series):
+            mask = mask.values
         elif not isinstance(mask, np.ndarray):
             # Convert to numpy array if needed
             mask = np.asarray(mask)
@@ -254,8 +252,8 @@ def load_data(
         if isinstance(sample_end, str):
             sample_end = parse_timestamp(sample_end)
         mask = Time <= sample_end
-        if isinstance(mask, pl.Series):
-            mask = mask.to_numpy()
+        if isinstance(mask, pd.Series):
+            mask = mask.values
         elif not isinstance(mask, np.ndarray):
             # Convert to numpy array if needed
             mask = np.asarray(mask)
@@ -272,7 +270,7 @@ def load_data(
     clock = safe_get_attr(config, 'clock', 'm')
     clock_hierarchy = FREQUENCY_HIERARCHY.get(clock, 3)
     
-    frequencies = get_frequencies_from_config(config)
+    frequencies = get_frequencies(config)
     series_ids = get_series_ids(config)
     warnings_list = []
     
@@ -314,8 +312,8 @@ def load_data(
     extreme_missing_series = []
     for i, ratio in enumerate(missing_ratios):
         if ratio > 0.9:
-            from ..utils.helpers import get_series_id_by_index
-            series_id = get_series_id_by_index(config, i)
+            from ..utils.helpers import get_series_id
+            series_id = get_series_id(config, i)
             extreme_missing_series.append((series_id, ratio))
     
     if len(extreme_missing_series) > 0:

dfm_python/encoder/vae.py

@@ -173,7 +173,7 @@ if _has_torch:
             
             Note: VAE encoders are typically trained via autoencoder training
             (encoder + decoder) before being used for factor extraction.
-            This method is a placeholder for the BaseEncoder interface.
+            This method satisfies the BaseEncoder interface but does nothing.
             
             Parameters
             ----------
@@ -476,7 +476,8 @@ def convert_decoder_to_numpy(
     has_bias : bool
         Whether the decoder has a bias term
     factor_order : int
-        Lag order for common factors (1 for VAR(1), 2 for VAR(2))
+        Lag order for common factors. Only VAR(1) and VAR(2) are supported.
+        Higher orders will raise NotImplementedError.
         
     Returns
     -------