Resume SynthData0523 main/c18 batch 5

.gitattributes

@@ -2592,3 +2592,34 @@ SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/_efvfm_runtime/ef
 SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/_efvfm_runtime/ef_vfm/result/pipeline_c18/adapter_efvfm/100/shapes.csv filter=lfs diff=lfs merge=lfs -text
 SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/_efvfm_runtime/ef_vfm/result/pipeline_c18/adapter_efvfm/100/trends.csv filter=lfs diff=lfs merge=lfs -text
 SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/_efvfm_runtime/pyproject.toml filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/_efvfm_runtime/synthetic/pipeline_c18/real.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/_efvfm_runtime/synthetic/pipeline_c18/test.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/_efvfm_runtime/synthetic/pipeline_c18/val.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/gen_20260510_220650.log filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/input_snapshot.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/models_tabbyflow/trained.pt filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/public_gate/normalized_schema_snapshot.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/public_gate/public_gate_report.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/public_gate/staged_input_manifest.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/run_config.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/runtime_result.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/staged/public/staged_features.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/staged/public/test.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/staged/public/train.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/staged/public/val.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/staged/tabbyflow/adapter_report.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/staged/tabbyflow/adapter_transforms_applied.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/staged/tabbyflow/model_input_manifest.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/tabbyflow-c18-103976-20260510_220650.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/tabbyflow_train_meta.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/tabular_bundle/pipeline_c18/X_cat_test.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/tabular_bundle/pipeline_c18/X_cat_train.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/tabular_bundle/pipeline_c18/X_cat_val.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/tabular_bundle/pipeline_c18/X_num_test.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/tabular_bundle/pipeline_c18/X_num_train.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/tabular_bundle/pipeline_c18/X_num_val.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/tabular_bundle/pipeline_c18/info.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/tabular_bundle/pipeline_c18/real.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/tabular_bundle/pipeline_c18/staged_features.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/tabular_bundle/pipeline_c18/test.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/tabular_bundle/pipeline_c18/train.csv filter=lfs diff=lfs merge=lfs -text

SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/_efvfm_runtime/src/__init__.py

@@ -0,0 +1,11 @@
+import torch
+from icecream import install
+
+torch.set_num_threads(1)
+install()
+
+from . import env  # noqa
+from .data import *  # noqa
+from .env import *  # noqa
+from .metrics import *  # noqa
+from .util import *  # noqa

SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/_efvfm_runtime/src/data.py

@@ -0,0 +1,780 @@
+import hashlib
+from collections import Counter
+from copy import deepcopy
+from dataclasses import astuple, dataclass, replace
+from importlib.resources import path
+from pathlib import Path
+from typing import Any, Literal, Optional, Union, cast, Tuple, Dict, List
+
+import numpy as np
+import pandas as pd
+from sklearn.model_selection import train_test_split
+from sklearn.pipeline import make_pipeline
+import sklearn.preprocessing
+import torch
+import os
+from category_encoders import LeaveOneOutEncoder
+from sklearn.impute import SimpleImputer
+from sklearn.preprocessing import StandardScaler
+from scipy.spatial.distance import cdist
+
+from . import env, util
+from .metrics import calculate_metrics as calculate_metrics_
+from .util import TaskType, load_json
+
+ArrayDict = Dict[str, np.ndarray]
+TensorDict = Dict[str, torch.Tensor]
+
+
+CAT_MISSING_VALUE = 'nan'
+CAT_RARE_VALUE = '__rare__'
+Normalization = Literal['standard', 'quantile', 'minmax']
+NumNanPolicy = Literal['drop-rows', 'mean']
+CatNanPolicy = Literal['most_frequent']
+CatEncoding = Literal['one-hot', 'counter']
+YPolicy = Literal['default']
+DEQUANT_DIST = Literal['uniform', 'beta', 'round', 'none']
+
+
+class StandardScaler1d(StandardScaler):
+    def partial_fit(self, X, *args, **kwargs):
+        assert X.ndim == 1
+        return super().partial_fit(X[:, None], *args, **kwargs)
+
+    def transform(self, X, *args, **kwargs):
+        assert X.ndim == 1
+        return super().transform(X[:, None], *args, **kwargs).squeeze(1)
+
+    def inverse_transform(self, X, *args, **kwargs):
+        assert X.ndim == 1
+        return super().inverse_transform(X[:, None], *args, **kwargs).squeeze(1)
+
+
+def get_category_sizes(X: Union[torch.Tensor, np.ndarray]) -> List[int]:
+    XT = X.T.cpu().tolist() if isinstance(X, torch.Tensor) else X.T.tolist()
+    return [len(set(x)) for x in XT]
+
+
+@dataclass(frozen=False)
+class Dataset:
+    X_num: Optional[ArrayDict]
+    X_cat: Optional[ArrayDict]
+    y: ArrayDict
+    int_col_idx_wrt_num: list
+    y_info: Dict[str, Any]
+    task_type: TaskType
+    n_classes: Optional[int]
+
+    @classmethod
+    def from_dir(cls, dir_: Union[Path, str]) -> 'Dataset':
+        dir_ = Path(dir_)
+        splits = [k for k in ['train', 'test'] if dir_.joinpath(f'y_{k}.npy').exists()]
+
+        def load(item) -> ArrayDict:
+            return {
+                x: cast(np.ndarray, np.load(dir_ / f'{item}_{x}.npy', allow_pickle=True))  # type: ignore[code]
+                for x in splits
+            }
+
+        if Path(dir_ / 'info.json').exists():
+            info = util.load_json(dir_ / 'info.json')
+        else:
+            info = None
+        return Dataset(
+            load('X_num') if dir_.joinpath('X_num_train.npy').exists() else None,
+            load('X_cat') if dir_.joinpath('X_cat_train.npy').exists() else None,
+            load('y'),
+            {},
+            TaskType(info['task_type']),
+            info.get('n_classes'),
+        )
+
+    @property
+    def is_binclass(self) -> bool:
+        return self.task_type == TaskType.BINCLASS
+
+    @property
+    def is_multiclass(self) -> bool:
+        return self.task_type == TaskType.MULTICLASS
+
+    @property
+    def is_regression(self) -> bool:
+        return self.task_type == TaskType.REGRESSION
+
+    @property
+    def n_num_features(self) -> int:
+        return 0 if self.X_num is None else self.X_num['train'].shape[1]
+
+    @property
+    def n_cat_features(self) -> int:
+        return 0 if self.X_cat is None else self.X_cat['train'].shape[1]
+
+    @property
+    def n_features(self) -> int:
+        return self.n_num_features + self.n_cat_features
+
+    def size(self, part: Optional[str]) -> int:
+        return sum(map(len, self.y.values())) if part is None else len(self.y[part])
+
+    @property
+    def nn_output_dim(self) -> int:
+        if self.is_multiclass:
+            assert self.n_classes is not None
+            return self.n_classes
+        else:
+            return 1
+
+    def get_category_sizes(self, part: str) -> List[int]:
+        return [] if self.X_cat is None else get_category_sizes(self.X_cat[part])
+
+    def calculate_metrics(
+        self,
+        predictions: Dict[str, np.ndarray],
+        prediction_type: Optional[str],
+    ) -> Dict[str, Any]:
+        metrics = {
+            x: calculate_metrics_(
+                self.y[x], predictions[x], self.task_type, prediction_type, self.y_info
+            )
+            for x in predictions
+        }
+        if self.task_type == TaskType.REGRESSION:
+            score_key = 'rmse'
+            score_sign = -1
+        else:
+            score_key = 'accuracy'
+            score_sign = 1
+        for part_metrics in metrics.values():
+            part_metrics['score'] = score_sign * part_metrics[score_key]
+        return metrics
+
+def change_val(dataset: Dataset, val_size: float = 0.2):
+    # should be done before transformations
+
+    y = np.concatenate([dataset.y['train'], dataset.y['val']], axis=0)
+
+    ixs = np.arange(y.shape[0])
+    if dataset.is_regression:
+        train_ixs, val_ixs = train_test_split(ixs, test_size=val_size, random_state=777)
+    else:
+        train_ixs, val_ixs = train_test_split(ixs, test_size=val_size, random_state=777, stratify=y)
+
+    dataset.y['train'] = y[train_ixs]
+    dataset.y['val'] = y[val_ixs]
+
+    if dataset.X_num is not None:
+        X_num = np.concatenate([dataset.X_num['train'], dataset.X_num['val']], axis=0)
+        dataset.X_num['train'] = X_num[train_ixs]
+        dataset.X_num['val'] = X_num[val_ixs]
+
+    if dataset.X_cat is not None:
+        X_cat = np.concatenate([dataset.X_cat['train'], dataset.X_cat['val']], axis=0)
+        dataset.X_cat['train'] = X_cat[train_ixs]
+        dataset.X_cat['val'] = X_cat[val_ixs]
+
+    return dataset
+
+def num_process_nans(dataset: Dataset, policy: Optional[NumNanPolicy]) -> Dataset:
+
+    assert dataset.X_num is not None
+    nan_masks = {k: np.isnan(v) for k, v in dataset.X_num.items()}
+    if not any(x.any() for x in nan_masks.values()):  # type: ignore[code]
+        # assert policy is None
+        print('No NaNs in numerical features, skipping')
+        return dataset
+
+    assert policy is not None
+    if policy == 'drop-rows':
+        valid_masks = {k: ~v.any(1) for k, v in nan_masks.items()}
+        assert valid_masks[
+            'test'
+        ].all(), 'Cannot drop test rows, since this will affect the final metrics.'
+        new_data = {}
+        for data_name in ['X_num', 'X_cat', 'y']:
+            data_dict = getattr(dataset, data_name)
+            if data_dict is not None:
+                new_data[data_name] = {
+                    k: v[valid_masks[k]] for k, v in data_dict.items()
+                }
+        dataset = replace(dataset, **new_data)
+    elif policy == 'mean':
+        new_values = np.nanmean(dataset.X_num['train'], axis=0)
+        X_num = deepcopy(dataset.X_num)
+        for k, v in X_num.items():
+            num_nan_indices = np.where(nan_masks[k])
+            v[num_nan_indices] = np.take(new_values, num_nan_indices[1])
+        dataset = replace(dataset, X_num=X_num)
+    else:
+        assert util.raise_unknown('policy', policy)
+    return dataset
+
+
+# Inspired by: https://github.com/yandex-research/rtdl/blob/a4c93a32b334ef55d2a0559a4407c8306ffeeaee/lib/data.py#L20
+def normalize(
+    X: ArrayDict, normalization: Normalization, seed: Optional[int], return_normalizer : bool = False
+) -> ArrayDict:
+    X_train = X['train']
+    if normalization == 'standard':
+        normalizer = sklearn.preprocessing.StandardScaler()
+    elif normalization == 'minmax':
+        normalizer = sklearn.preprocessing.MinMaxScaler()
+    elif normalization == 'quantile':
+        normalizer = sklearn.preprocessing.QuantileTransformer(
+            output_distribution='normal',
+            n_quantiles=max(min(X['train'].shape[0] // 30, 1000), 10),
+            subsample=int(1e9),
+            random_state=seed,
+        )
+        # noise = 1e-3
+        # if noise > 0:
+        #     assert seed is not None
+        #     stds = np.std(X_train, axis=0, keepdims=True)
+        #     noise_std = noise / np.maximum(stds, noise)  # type: ignore[code]
+        #     X_train = X_train + noise_std * np.random.default_rng(seed).standard_normal(
+        #         X_train.shape
+        #     )
+    else:
+        util.raise_unknown('normalization', normalization)
+
+    normalizer.fit(X_train)
+    if return_normalizer:
+        return {k: normalizer.transform(v) for k, v in X.items()}, normalizer
+    return {k: normalizer.transform(v) for k, v in X.items()}
+
+class dequantizer:
+    def __init__(
+        self,
+        dequant_dist: DEQUANT_DIST,
+        int_col_idx_wrt_num: list,
+        int_dequant_factor: float,
+        # return_dequantizer: bool = False
+    ):
+        self.dequant_dist = dequant_dist
+        self.int_col_idx_wrt_num = int_col_idx_wrt_num
+        self.int_dequant_factor = int_dequant_factor
+    def transform(self, X):
+        X_int = X[:, self.int_col_idx_wrt_num]
+        if self.dequant_dist == 'uniform':
+            X[:, self.int_col_idx_wrt_num] = X_int+ np.random.uniform(size=X_int.shape) * self.int_dequant_factor
+        elif self.dequant_dist == 'beta':
+            X[:, self.int_col_idx_wrt_num] = X_int + np.random.beta(self.int_dequant_factor, self.int_dequant_factor, size=X_int.shape) - 0.5
+        elif self.dequant_dist in ['round', 'none']:
+            pass
+        return X
+    def inverse_transform(self, X):
+        X_int = X[:, self.int_col_idx_wrt_num]
+        if self.dequant_dist == 'uniform':
+            X[:, self.int_col_idx_wrt_num] = np.floor(X_int)
+        elif self.dequant_dist == 'beta':
+            X[:, self.int_col_idx_wrt_num] = np.rint(X_int)
+        elif self.dequant_dist == 'round':
+            X[:, self.int_col_idx_wrt_num] = np.rint(X_int)
+        elif self.dequant_dist == 'none':
+            pass
+        return X
+    
+    
+    # if return_dequantizer:
+    #     return {k: transform(v) for k, v in X.items()}, inverse_transform
+    # return {k: transform(v) for k, v in X.items()}
+
+def cat_process_nans(X: ArrayDict, policy: Optional[CatNanPolicy]) -> ArrayDict:
+    assert X is not None
+    nan_masks = {k: v == CAT_MISSING_VALUE for k, v in X.items()}
+    if any(x.any() for x in nan_masks.values()):  # type: ignore[code]
+        if policy is None:
+            X_new = X
+        elif policy == 'most_frequent':
+            imputer = SimpleImputer(missing_values=CAT_MISSING_VALUE, strategy=policy)  # type: ignore[code]
+            imputer.fit(X['train'])
+            X_new = {k: cast(np.ndarray, imputer.transform(v)) for k, v in X.items()}
+        else:
+            util.raise_unknown('categorical NaN policy', policy)
+    else:
+        assert policy is None
+        X_new = X
+    return X_new
+
+
+def cat_drop_rare(X: ArrayDict, min_frequency: float) -> ArrayDict:
+    assert 0.0 < min_frequency < 1.0
+    min_count = round(len(X['train']) * min_frequency)
+    X_new = {x: [] for x in X}
+    for column_idx in range(X['train'].shape[1]):
+        counter = Counter(X['train'][:, column_idx].tolist())
+        popular_categories = {k for k, v in counter.items() if v >= min_count}
+        for part in X_new:
+            X_new[part].append(
+                [
+                    (x if x in popular_categories else CAT_RARE_VALUE)
+                    for x in X[part][:, column_idx].tolist()
+                ]
+            )
+    return {k: np.array(v).T for k, v in X_new.items()}
+
+
+def cat_encode(
+    X: ArrayDict,
+    encoding: Optional[CatEncoding],
+    y_train: Optional[np.ndarray],
+    seed: Optional[int],
+    return_encoder : bool = False
+) -> Tuple[ArrayDict, bool, Optional[Any]]:  # (X, is_converted_to_numerical)
+    if encoding != 'counter':
+        y_train = None
+
+    # Step 1. Map strings to 0-based ranges
+
+    if encoding is None:
+        unknown_value = np.iinfo('int64').max - 3
+        oe = sklearn.preprocessing.OrdinalEncoder(
+            handle_unknown='use_encoded_value',  # type: ignore[code]
+            unknown_value=unknown_value,  # type: ignore[code]
+            dtype='int64',  # type: ignore[code]
+        ).fit(X['train'])
+        encoder = make_pipeline(oe)
+        encoder.fit(X['train'])
+        X = {k: encoder.transform(v) for k, v in X.items()}
+        max_values = X['train'].max(axis=0)
+        for part in X.keys():
+            if part == 'train': continue
+            for column_idx in range(X[part].shape[1]):
+                X[part][X[part][:, column_idx] == unknown_value, column_idx] = (
+                    max_values[column_idx] + 1
+                )
+        if return_encoder:
+            return (X, False, encoder)
+        return (X, False)
+
+    # Step 2. Encode.
+
+    elif encoding == 'one-hot':
+        ohe = sklearn.preprocessing.OneHotEncoder(
+            handle_unknown='ignore', sparse_output=False, dtype=np.float32 # type: ignore[code]
+        )
+        encoder = make_pipeline(ohe)
+
+        # encoder.steps.append(('ohe', ohe))
+        encoder.fit(X['train'])
+        X = {k: encoder.transform(v) for k, v in X.items()}
+
+    elif encoding == 'counter':
+        assert y_train is not None
+        assert seed is not None
+        loe = LeaveOneOutEncoder(sigma=0.1, random_state=seed, return_df=False)
+        encoder.steps.append(('loe', loe))
+        encoder.fit(X['train'], y_train)
+        X = {k: encoder.transform(v).astype('float32') for k, v in X.items()}  # type: ignore[code]
+        if not isinstance(X['train'], pd.DataFrame):
+            X = {k: v.values for k, v in X.items()}  # type: ignore[code]
+    else:
+        util.raise_unknown('encoding', encoding)
+    
+    if return_encoder:
+        return X, True, encoder # type: ignore[code]
+    return (X, True)
+
+
+def build_target(
+    y: ArrayDict, policy: Optional[YPolicy], task_type: TaskType
+) -> Tuple[ArrayDict, Dict[str, Any]]:
+    info: Dict[str, Any] = {'policy': policy}
+    if policy is None:
+        pass
+    elif policy == 'default':
+        if task_type == TaskType.REGRESSION:
+            mean, std = float(y['train'].mean()), float(y['train'].std())
+            y = {k: (v - mean) / std for k, v in y.items()}
+            info['mean'] = mean
+            info['std'] = std
+    else:
+        util.raise_unknown('policy', policy)
+    return y, info
+
+
+@dataclass(frozen=True)
+class Transformations:
+    seed: int = 0
+    normalization: Optional[Normalization] = None
+    num_nan_policy: Optional[NumNanPolicy] = None
+    cat_nan_policy: Optional[CatNanPolicy] = None
+    cat_min_frequency: Optional[float] = None
+    cat_encoding: Optional[CatEncoding] = None
+    y_policy: Optional[YPolicy] = 'default'
+    dequant_dist: Optional[DEQUANT_DIST] = None
+    int_dequant_factor: Optional[float] = 0.0
+
+
+def transform_dataset(
+    dataset: Dataset,
+    transformations: Transformations,
+    cache_dir: Optional[Path],
+    return_transforms: bool = False
+) -> Dataset:
+    # WARNING: the order of transformations matters. Moreover, the current
+    # implementation is not ideal in that sense.
+    if cache_dir is not None:
+        transformations_md5 = hashlib.md5(
+            str(transformations).encode('utf-8')
+        ).hexdigest()
+        transformations_str = '__'.join(map(str, astuple(transformations)))
+        cache_path = (
+            cache_dir / f'cache__{transformations_str}__{transformations_md5}.pickle'
+        )
+        if cache_path.exists():
+            cache_transformations, value = util.load_pickle(cache_path)
+            if transformations == cache_transformations:
+                print(
+                    f"Using cached features: {cache_dir.name + '/' + cache_path.name}"
+                )
+                return value
+            else:
+                raise RuntimeError(f'Hash collision for {cache_path}')
+    else:
+        cache_path = None
+
+    if dataset.X_num is not None:
+        dataset = num_process_nans(dataset, transformations.num_nan_policy)
+
+    num_transform = None
+    int_transform = None
+    cat_transform = None
+    X_num = dataset.X_num
+
+    int_col_idx_wrt_num = dataset.int_col_idx_wrt_num
+    if X_num is not None and int_col_idx_wrt_num and transformations.dequant_dist is not None:
+        int_transform = dequantizer(
+            transformations.dequant_dist,
+            int_col_idx_wrt_num, 
+            transformations.int_dequant_factor,
+        )
+        X_num = {k: int_transform.transform(v) for k, v in X_num.items()}
+    
+    if X_num is not None and transformations.normalization is not None:
+        has_num = all([x.shape[1]>0 for x in dataset.X_num.values()])
+        if has_num:
+            X_num, num_transform = normalize(
+                X_num,
+                transformations.normalization,
+                transformations.seed,
+                return_normalizer=True
+            )
+            num_transform = num_transform
+    
+    if dataset.X_cat is None:
+        assert transformations.cat_nan_policy is None
+        assert transformations.cat_min_frequency is None
+        # assert transformations.cat_encoding is None
+        X_cat = None
+    else:
+        has_cat = all([x.shape[1]>0 for x in dataset.X_cat.values()])
+        if not has_cat:
+            assert transformations.cat_nan_policy is None
+            assert transformations.cat_min_frequency is None
+            X_cat = dataset.X_cat
+            for split in X_cat.keys():   # a patch to make sure that the empty array is transformed into int dtype
+                X_cat[split] = X_cat[split].astype(np.int64)
+        else:
+            X_cat = cat_process_nans(dataset.X_cat, transformations.cat_nan_policy)
+    
+            if transformations.cat_min_frequency is not None:
+                X_cat = cat_drop_rare(X_cat, transformations.cat_min_frequency)
+            X_cat, is_num, cat_transform = cat_encode(
+                X_cat,
+                transformations.cat_encoding,
+                dataset.y['train'],
+                transformations.seed,
+                return_encoder=True
+            )
+
+            if is_num:
+                X_num = (
+                    X_cat
+                    if X_num is None
+                    else {x: np.hstack([X_num[x], X_cat[x]]) for x in X_num}
+                )
+                X_cat = None
+
+        
+    y, y_info = build_target(dataset.y, transformations.y_policy, dataset.task_type)
+
+    dataset = replace(dataset, X_num=X_num, X_cat=X_cat, y=y, y_info=y_info)
+    dataset.num_transform = num_transform
+    dataset.int_transform = int_transform
+    dataset.cat_transform = cat_transform
+
+    if cache_path is not None:
+        util.dump_pickle((transformations, dataset), cache_path)
+    # if return_transforms:
+        # return dataset, num_transform, cat_transform
+    return dataset
+
+
+def build_dataset(
+    path: Union[str, Path],
+    transformations: Transformations,
+    cache: bool
+) -> Dataset:
+    path = Path(path)
+    dataset = Dataset.from_dir(path)
+    return transform_dataset(dataset, transformations, path if cache else None)
+
+
+def prepare_tensors(
+    dataset: Dataset, device: Union[str, torch.device]
+) -> Tuple[Optional[TensorDict], Optional[TensorDict], TensorDict]:
+    X_num, X_cat, Y = (
+        None if x is None else {k: torch.as_tensor(v) for k, v in x.items()}
+        for x in [dataset.X_num, dataset.X_cat, dataset.y]
+    )
+    if device.type != 'cpu':
+        X_num, X_cat, Y = (
+            None if x is None else {k: v.to(device) for k, v in x.items()}
+            for x in [X_num, X_cat, Y]
+        )
+    assert X_num is not None
+    assert Y is not None
+    if not dataset.is_multiclass:
+        Y = {k: v.float() for k, v in Y.items()}
+    return X_num, X_cat, Y
+
+###############
+## DataLoader##
+###############
+
+class TabDataset(torch.utils.data.Dataset):
+    def __init__(
+        self, dataset : Dataset, split : Literal['train', 'val', 'test']
+    ):
+        super().__init__()
+        
+        self.X_num = torch.from_numpy(dataset.X_num[split]) if dataset.X_num is not None else None
+        self.X_cat = torch.from_numpy(dataset.X_cat[split]) if dataset.X_cat is not None else None
+        self.y = torch.from_numpy(dataset.y[split])
+
+        assert self.y is not None
+        assert self.X_num is not None or self.X_cat is not None 
+
+    def __len__(self):
+        return len(self.y)
+
+    def __getitem__(self, idx):
+        out_dict = {
+            'y': self.y[idx].long() if self.y is not None else None,
+        }
+
+        x = np.empty((0,))
+        if self.X_num is not None:
+            x = self.X_num[idx]
+        if self.X_cat is not None:
+            x = torch.cat([x, self.X_cat[idx]], dim=0)
+        return x.float(), out_dict
+
+def prepare_dataloader(
+    dataset : Dataset,
+    split : str,
+    batch_size: int,
+):
+
+    torch_dataset = TabDataset(dataset, split)
+    loader = torch.utils.data.DataLoader(
+        torch_dataset,
+        batch_size=batch_size,
+        shuffle=(split == 'train'),
+        num_workers=1,
+    )
+    while True:
+        yield from loader
+
+def prepare_torch_dataloader(
+    dataset : Dataset,
+    split : str,
+    shuffle : bool,
+    batch_size: int,
+) -> torch.utils.data.DataLoader:
+
+    torch_dataset = TabDataset(dataset, split)
+    loader = torch.utils.data.DataLoader(torch_dataset, batch_size=batch_size, shuffle=shuffle, num_workers=1)
+
+    return loader
+
+def dataset_from_csv(paths : Dict[str, str], cat_features, target, T):
+    assert 'train' in paths
+    y = {}
+    X_num = {}
+    X_cat = {} if len(cat_features) else None
+    for split in paths.keys():
+        df = pd.read_csv(paths[split])
+        y[split] = df[target].to_numpy().astype(float)
+        if X_cat is not None:
+            X_cat[split] = df[cat_features].to_numpy().astype(str)
+        X_num[split] = df.drop(cat_features + [target], axis=1).to_numpy().astype(float)
+
+    dataset = Dataset(X_num, X_cat, y, {}, None, len(np.unique(y['train'])))
+    return transform_dataset(dataset, T, None)
+
+class FastTensorDataLoader:
+    """
+    A DataLoader-like object for a set of tensors that can be much faster than
+    TensorDataset + DataLoader because dataloader grabs individual indices of
+    the dataset and calls cat (slow).
+    Source: https://discuss.pytorch.org/t/dataloader-much-slower-than-manual-batching/27014/6
+    """
+    def __init__(self, *tensors, batch_size=32, shuffle=False):
+        """
+        Initialize a FastTensorDataLoader.
+        :param *tensors: tensors to store. Must have the same length @ dim 0.
+        :param batch_size: batch size to load.
+        :param shuffle: if True, shuffle the data *in-place* whenever an
+            iterator is created out of this object.
+        :returns: A FastTensorDataLoader.
+        """
+        assert all(t.shape[0] == tensors[0].shape[0] for t in tensors)
+        self.tensors = tensors
+
+        self.dataset_len = self.tensors[0].shape[0]
+        self.batch_size = batch_size
+        self.shuffle = shuffle
+
+        # Calculate # batches
+        n_batches, remainder = divmod(self.dataset_len, self.batch_size)
+        if remainder > 0:
+            n_batches += 1
+        self.n_batches = n_batches
+    def __iter__(self):
+        if self.shuffle:
+            r = torch.randperm(self.dataset_len)
+            self.tensors = [t[r] for t in self.tensors]
+        self.i = 0
+        return self
+
+    def __next__(self):
+        if self.i >= self.dataset_len:
+            raise StopIteration
+        batch = tuple(t[self.i:self.i+self.batch_size] for t in self.tensors)
+        self.i += self.batch_size
+        return batch
+
+    def __len__(self):
+        return self.n_batches
+
+def prepare_fast_dataloader(
+    D : Dataset,
+    split : str,
+    batch_size: int
+):
+   
+    X = torch.from_numpy(np.concatenate([D.X_num[split], D.X_cat[split]], axis=1)).float()
+    dataloader = FastTensorDataLoader(X, batch_size=batch_size, shuffle=(split=='train'))
+    while True:
+        yield from dataloader
+
+def prepare_fast_torch_dataloader(
+    D : Dataset,
+    split : str,
+    batch_size: int
+):
+    if D.X_cat is not None:
+        X = torch.from_numpy(np.concatenate([D.X_num[split], D.X_cat[split]], axis=1)).float()
+    else:
+        X = torch.from_numpy(D.X_num[split]).float()
+    y = torch.from_numpy(D.y[split])
+    dataloader = FastTensorDataLoader(X, y, batch_size=batch_size, shuffle=(split=='train'))
+    return dataloader
+
+def round_columns(X_real, X_synth, columns):
+    for col in columns:
+        uniq = np.unique(X_real[:,col])
+        dist = cdist(X_synth[:, col][:, np.newaxis].astype(float), uniq[:, np.newaxis].astype(float))
+        X_synth[:, col] = uniq[dist.argmin(axis=1)]
+    return X_synth
+
+def concat_features(D : Dataset):
+    if D.X_num is None:
+        assert D.X_cat is not None
+        X = {k: pd.DataFrame(v, columns=range(D.n_features)) for k, v in D.X_cat.items()}
+    elif D.X_cat is None:
+        assert D.X_num is not None
+        X = {k: pd.DataFrame(v, columns=range(D.n_features)) for k, v in D.X_num.items()}
+    else:
+        X = {
+            part: pd.concat(
+                [
+                    pd.DataFrame(D.X_num[part], columns=range(D.n_num_features)),
+                    pd.DataFrame(
+                        D.X_cat[part],
+                        columns=range(D.n_num_features, D.n_features),
+                    ),
+                ],
+                axis=1,
+            )
+            for part in D.y.keys()
+        }
+
+    return X
+
+def concat_to_pd(X_num, X_cat, y):
+    if X_num is None:
+        return pd.concat([
+            pd.DataFrame(X_cat, columns=list(range(X_cat.shape[1]))),
+            pd.DataFrame(y, columns=['y'])
+        ], axis=1)
+    if X_cat is not None:
+        return pd.concat([
+            pd.DataFrame(X_num, columns=list(range(X_num.shape[1]))),
+            pd.DataFrame(X_cat, columns=list(range(X_num.shape[1], X_num.shape[1] + X_cat.shape[1]))),
+            pd.DataFrame(y, columns=['y'])
+        ], axis=1)
+    return pd.concat([
+            pd.DataFrame(X_num, columns=list(range(X_num.shape[1]))),
+            pd.DataFrame(y, columns=['y'])
+        ], axis=1)
+
+def read_pure_data(path, split='train'):
+    y = np.load(os.path.join(path, f'y_{split}.npy'), allow_pickle=True)
+    X_num = None
+    X_cat = None
+    if os.path.exists(os.path.join(path, f'X_num_{split}.npy')):
+        X_num = np.load(os.path.join(path, f'X_num_{split}.npy'), allow_pickle=True)
+    if os.path.exists(os.path.join(path, f'X_cat_{split}.npy')):
+        X_cat = np.load(os.path.join(path, f'X_cat_{split}.npy'), allow_pickle=True)
+
+    return X_num, X_cat, y
+
+def read_changed_val(path, val_size=0.2):
+    path = Path(path)
+    X_num_train, X_cat_train, y_train = read_pure_data(path, 'train')
+    X_num_val, X_cat_val, y_val = read_pure_data(path, 'val')
+    is_regression = load_json(path / 'info.json')['task_type'] == 'regression'
+
+    y = np.concatenate([y_train, y_val], axis=0)
+
+    ixs = np.arange(y.shape[0])
+    if is_regression:
+        train_ixs, val_ixs = train_test_split(ixs, test_size=val_size, random_state=777)
+    else:
+        train_ixs, val_ixs = train_test_split(ixs, test_size=val_size, random_state=777, stratify=y)
+    y_train = y[train_ixs]
+    y_val = y[val_ixs]
+
+    if X_num_train is not None:
+        X_num = np.concatenate([X_num_train, X_num_val], axis=0)
+        X_num_train = X_num[train_ixs]
+        X_num_val = X_num[val_ixs]
+
+    if X_cat_train is not None:
+        X_cat = np.concatenate([X_cat_train, X_cat_val], axis=0)
+        X_cat_train = X_cat[train_ixs]
+        X_cat_val = X_cat[val_ixs]
+    
+    return X_num_train, X_cat_train, y_train, X_num_val, X_cat_val, y_val
+
+#############
+
+def load_dataset_info(dataset_dir_name: str) -> Dict[str, Any]:
+    path = Path("data/" + dataset_dir_name)
+    info = util.load_json(path / 'info.json')
+    info['size'] = info['train_size'] + info['val_size'] + info['test_size']
+    info['n_features'] = info['n_num_features'] + info['n_cat_features']
+    info['path'] = path
+    return info

SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/_efvfm_runtime/src/env.py

@@ -0,0 +1,39 @@
+"""
+Have not used in TabDDPM project.
+"""
+
+import datetime
+import os
+import shutil
+import typing as ty
+from pathlib import Path
+
+PROJ = Path('tab-ddpm/').absolute().resolve()
+EXP = PROJ / 'exp'
+DATA = PROJ / 'data'
+
+
+def get_path(path: ty.Union[str, Path]) -> Path:
+    if isinstance(path, str):
+        path = Path(path)
+    if not path.is_absolute():
+        path = PROJ / path
+    return path.resolve()
+
+
+def get_relative_path(path: ty.Union[str, Path]) -> Path:
+    return get_path(path).relative_to(PROJ)
+
+
+def duplicate_path(
+    src: ty.Union[str, Path], alternative_project_dir: ty.Union[str, Path]
+) -> None:
+    src = get_path(src)
+    alternative_project_dir = get_path(alternative_project_dir)
+    dst = alternative_project_dir / src.relative_to(PROJ)
+    dst.parent.mkdir(parents=True, exist_ok=True)
+    if dst.exists():
+        dst = dst.with_name(
+            dst.name + '_' + datetime.datetime.now().strftime('%Y%m%dT%H%M%S')
+        )
+    (shutil.copytree if src.is_dir() else shutil.copyfile)(src, dst)

SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/_efvfm_runtime/src/metrics.py

@@ -0,0 +1,157 @@
+import enum
+from typing import Any, Optional, Tuple, Dict, Union, cast
+from functools import partial
+
+import numpy as np
+import scipy.special
+import sklearn.metrics as skm
+
+from . import util
+from .util import TaskType
+
+
+class PredictionType(enum.Enum):
+    LOGITS = 'logits'
+    PROBS = 'probs'
+
+class MetricsReport:
+    def __init__(self, report: dict, task_type: TaskType):
+        self._res = {k: {} for k in report.keys()}
+        if task_type in (TaskType.BINCLASS, TaskType.MULTICLASS):
+            self._metrics_names = ["acc", "f1"]
+            for k in report.keys():
+                self._res[k]["acc"] = report[k]["accuracy"]
+                self._res[k]["f1"] = report[k]["macro avg"]["f1-score"]
+                if task_type == TaskType.BINCLASS:
+                    self._res[k]["roc_auc"] = report[k]["roc_auc"]
+                    self._metrics_names.append("roc_auc")
+
+        elif task_type == TaskType.REGRESSION:
+            self._metrics_names = ["r2", "rmse"]
+            for k in report.keys():
+                self._res[k]["r2"] = report[k]["r2"]
+                self._res[k]["rmse"] = report[k]["rmse"]
+        else:
+            raise "Unknown TaskType!"
+
+    def get_splits_names(self) -> list[str]:
+        return self._res.keys()
+
+    def get_metrics_names(self) -> list[str]:
+        return self._metrics_names
+
+    def get_metric(self, split: str, metric: str) -> float:
+        return self._res[split][metric]
+
+    def get_val_score(self) -> float:
+        return self._res["val"]["r2"] if "r2" in self._res["val"] else self._res["val"]["f1"]
+    
+    def get_test_score(self) -> float:
+        return self._res["test"]["r2"] if "r2" in self._res["test"] else self._res["test"]["f1"]
+    
+    def print_metrics(self) -> None:
+        res = {
+            "val": {k: np.around(self._res["val"][k], 4) for k in self._res["val"]},
+            "test": {k: np.around(self._res["test"][k], 4) for k in self._res["test"]}
+        }
+    
+        print("*"*100)
+        print("[val]")
+        print(res["val"])
+        print("[test]")
+        print(res["test"])
+
+        return res
+
+class SeedsMetricsReport:
+    def __init__(self):
+        self._reports = []
+
+    def add_report(self, report: MetricsReport) -> None:
+        self._reports.append(report)
+    
+    def get_mean_std(self) -> dict:
+        res = {k: {} for k in ["train", "val", "test"]}
+        for split in self._reports[0].get_splits_names():
+            for metric in self._reports[0].get_metrics_names():
+                res[split][metric] = [x.get_metric(split, metric) for x in self._reports]
+
+        agg_res = {k: {} for k in ["train", "val", "test"]}
+        for split in self._reports[0].get_splits_names():
+            for metric in self._reports[0].get_metrics_names():
+                for k, f in [("count", len), ("mean", np.mean), ("std", np.std)]:
+                    agg_res[split][f"{metric}-{k}"] = f(res[split][metric])
+        self._res = res
+        self._agg_res = agg_res
+
+        return agg_res
+
+    def print_result(self) -> dict:
+        res = {split: {k: float(np.around(self._agg_res[split][k], 4)) for k in self._agg_res[split]} for split in ["val", "test"]}
+        print("="*100)
+        print("EVAL RESULTS:")
+        print("[val]")
+        print(res["val"])
+        print("[test]")
+        print(res["test"])
+        print("="*100)
+        return res
+
+def calculate_rmse(
+    y_true: np.ndarray, y_pred: np.ndarray, std = None) -> float:
+    rmse = skm.mean_squared_error(y_true, y_pred) ** 0.5
+    if std is not None:
+        rmse *= std
+    return rmse
+
+
+def _get_labels_and_probs(
+    y_pred: np.ndarray, task_type: TaskType, prediction_type: Optional[PredictionType]
+) -> Tuple[np.ndarray, Optional[np.ndarray]]:
+    assert task_type in (TaskType.BINCLASS, TaskType.MULTICLASS)
+
+    if prediction_type is None:
+        return y_pred, None
+
+    if prediction_type == PredictionType.LOGITS:
+        probs = (
+            scipy.special.expit(y_pred)
+            if task_type == TaskType.BINCLASS
+            else scipy.special.softmax(y_pred, axis=1)
+        )
+    elif prediction_type == PredictionType.PROBS:
+        probs = y_pred
+    else:
+        util.raise_unknown('prediction_type', prediction_type)
+
+    assert probs is not None
+    labels = np.round(probs) if task_type == TaskType.BINCLASS else probs.argmax(axis=1)
+    return labels.astype('int64'), probs
+
+
+def calculate_metrics(
+    y_true: np.ndarray,
+    y_pred: np.ndarray,
+    task_type: Union[str, TaskType],
+    prediction_type: Optional[Union[str, PredictionType]],
+    y_info: Dict[str, Any],
+) -> Dict[str, Any]:
+    # Example: calculate_metrics(y_true, y_pred, 'binclass', 'logits', {})
+    task_type = TaskType(task_type)
+    if prediction_type is not None:
+        prediction_type = PredictionType(prediction_type)
+
+    if task_type == TaskType.REGRESSION:
+        assert prediction_type is None
+        assert 'std' in y_info
+        rmse = calculate_rmse(y_true, y_pred, y_info['std'])
+        r2 = skm.r2_score(y_true, y_pred)
+        result = {'rmse': rmse, 'r2': r2}
+    else:
+        labels, probs = _get_labels_and_probs(y_pred, task_type, prediction_type)
+        result = cast(
+            Dict[str, Any], skm.classification_report(y_true, labels, output_dict=True)
+        )
+        if task_type == TaskType.BINCLASS:
+            result['roc_auc'] = skm.roc_auc_score(y_true, probs)
+    return result

SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/_efvfm_runtime/src/util.py

@@ -0,0 +1,347 @@
+import argparse
+import atexit
+import enum
+import json
+import os
+import pickle
+import shutil
+import sys
+import time
+import uuid
+from copy import deepcopy
+from dataclasses import asdict, fields, is_dataclass
+from pathlib import Path
+from pprint import pprint
+from typing import Any, Callable, List, Dict, Type, Optional, Tuple, TypeVar, Union, cast, get_args, get_origin
+
+import __main__
+import numpy as np
+import tomli
+import tomli_w
+import torch
+import typing as ty
+
+from . import env
+
+RawConfig = Dict[str, Any]
+Report = Dict[str, Any]
+T = TypeVar('T')
+
+
+class Part(enum.Enum):
+    TRAIN = 'train'
+    VAL = 'val'
+    TEST = 'test'
+
+    def __str__(self) -> str:
+        return self.value
+
+
+class TaskType(enum.Enum):
+    BINCLASS = 'binclass'
+    MULTICLASS = 'multiclass'
+    REGRESSION = 'regression'
+
+    def __str__(self) -> str:
+        return self.value
+
+
+
+def update_training_log(training_log, data, metrics):
+    def _update(log_part, data_part):
+        for k, v in data_part.items():
+            if isinstance(v, dict):
+                _update(log_part.setdefault(k, {}), v)
+            elif isinstance(v, list):
+                log_part.setdefault(k, []).extend(v)
+            else:
+                log_part.setdefault(k, []).append(v)
+
+    _update(training_log, data)
+    transposed_metrics = {}
+    for part, part_metrics in metrics.items():
+        for metric_name, value in part_metrics.items():
+            transposed_metrics.setdefault(metric_name, {})[part] = value
+    _update(training_log, transposed_metrics)
+
+
+def raise_unknown(unknown_what: str, unknown_value: Any):
+    raise ValueError(f'Unknown {unknown_what}: {unknown_value}')
+
+
+def _replace(data, condition, value):
+    def do(x):
+        if isinstance(x, dict):
+            return {k: do(v) for k, v in x.items()}
+        elif isinstance(x, list):
+            return [do(y) for y in x]
+        else:
+            return value if condition(x) else x
+
+    return do(data)
+
+
+_CONFIG_NONE = '__none__'
+
+
+def unpack_config(config: RawConfig) -> RawConfig:
+    config = cast(RawConfig, _replace(config, lambda x: x == _CONFIG_NONE, None))
+    return config
+
+
+def pack_config(config: RawConfig) -> RawConfig:
+    config = cast(RawConfig, _replace(config, lambda x: x is None, _CONFIG_NONE))
+    return config
+
+
+def load_config(path: Union[Path, str]) -> Any:
+    with open(path, 'rb') as f:
+        return unpack_config(tomli.load(f))
+
+
+def dump_config(config: Any, path: Union[Path, str]) -> None:
+    with open(path, 'wb') as f:
+        tomli_w.dump(pack_config(config), f)
+    # check that there are no bugs in all these "pack/unpack" things
+    assert config == load_config(path)
+
+
+def load_json(path: Union[Path, str], **kwargs) -> Any:
+    return json.loads(Path(path).read_text(), **kwargs)
+
+
+def dump_json(x: Any, path: Union[Path, str], **kwargs) -> None:
+    kwargs.setdefault('indent', 4)
+    Path(path).write_text(json.dumps(x, **kwargs) + '\n')
+
+
+def load_pickle(path: Union[Path, str], **kwargs) -> Any:
+    return pickle.loads(Path(path).read_bytes(), **kwargs)
+
+
+def dump_pickle(x: Any, path: Union[Path, str], **kwargs) -> None:
+    Path(path).write_bytes(pickle.dumps(x, **kwargs))
+
+
+def load(path: Union[Path, str], **kwargs) -> Any:
+    return globals()[f'load_{Path(path).suffix[1:]}'](Path(path), **kwargs)
+
+
+def dump(x: Any, path: Union[Path, str], **kwargs) -> Any:
+    return globals()[f'dump_{Path(path).suffix[1:]}'](x, Path(path), **kwargs)
+
+
+def _get_output_item_path(
+    path: Union[str, Path], filename: str, must_exist: bool
+) -> Path:
+    path = env.get_path(path)
+    if path.suffix == '.toml':
+        path = path.with_suffix('')
+    if path.is_dir():
+        path = path / filename
+    else:
+        assert path.name == filename
+    assert path.parent.exists()
+    if must_exist:
+        assert path.exists()
+    return path
+
+
+def load_report(path: Path) -> Report:
+    return load_json(_get_output_item_path(path, 'report.json', True))
+
+
+def dump_report(report: dict, path: Path) -> None:
+    dump_json(report, _get_output_item_path(path, 'report.json', False))
+
+
+def load_predictions(path: Path) -> Dict[str, np.ndarray]:
+    with np.load(_get_output_item_path(path, 'predictions.npz', True)) as predictions:
+        return {x: predictions[x] for x in predictions}
+
+
+def dump_predictions(predictions: Dict[str, np.ndarray], path: Path) -> None:
+    np.savez(_get_output_item_path(path, 'predictions.npz', False), **predictions)
+
+
+def dump_metrics(metrics: Dict[str, Any], path: Path) -> None:
+    dump_json(metrics, _get_output_item_path(path, 'metrics.json', False))
+
+
+def load_checkpoint(path: Path, *args, **kwargs) -> Dict[str, np.ndarray]:
+    return torch.load(
+        _get_output_item_path(path, 'checkpoint.pt', True), *args, **kwargs
+    )
+
+
+def get_device() -> torch.device:
+    if torch.cuda.is_available():
+        assert os.environ.get('CUDA_VISIBLE_DEVICES') is not None
+        return torch.device('cuda:0')
+    else:
+        return torch.device('cpu')
+
+
+def _print_sep(c, size=100):
+    print(c * size)
+
+
+_LAST_SNAPSHOT_TIME = None
+
+
+def backup_output(output_dir: Path) -> None:
+    backup_dir = os.environ.get('TMP_OUTPUT_PATH')
+    snapshot_dir = os.environ.get('SNAPSHOT_PATH')
+    if backup_dir is None:
+        assert snapshot_dir is None
+        return
+    assert snapshot_dir is not None
+
+    try:
+        relative_output_dir = output_dir.relative_to(env.PROJ)
+    except ValueError:
+        return
+
+    for dir_ in [backup_dir, snapshot_dir]:
+        new_output_dir = dir_ / relative_output_dir
+        prev_backup_output_dir = new_output_dir.with_name(new_output_dir.name + '_prev')
+        new_output_dir.parent.mkdir(exist_ok=True, parents=True)
+        if new_output_dir.exists():
+            new_output_dir.rename(prev_backup_output_dir)
+        shutil.copytree(output_dir, new_output_dir)
+        # the case for evaluate.py which automatically creates configs
+        if output_dir.with_suffix('.toml').exists():
+            shutil.copyfile(
+                output_dir.with_suffix('.toml'), new_output_dir.with_suffix('.toml')
+            )
+        if prev_backup_output_dir.exists():
+            shutil.rmtree(prev_backup_output_dir)
+
+    global _LAST_SNAPSHOT_TIME
+    if _LAST_SNAPSHOT_TIME is None or time.time() - _LAST_SNAPSHOT_TIME > 10 * 60:
+        import nirvana_dl.snapshot  # type: ignore[code]
+
+        nirvana_dl.snapshot.dump_snapshot()
+        _LAST_SNAPSHOT_TIME = time.time()
+        print('The snapshot was saved!')
+
+
+def _get_scores(metrics: Dict[str, Dict[str, Any]]) -> Optional[Dict[str, float]]:
+    return (
+        {k: v['score'] for k, v in metrics.items()}
+        if 'score' in next(iter(metrics.values()))
+        else None
+    )
+
+
+def format_scores(metrics: Dict[str, Dict[str, Any]]) -> str:
+    return ' '.join(
+        f"[{x}] {metrics[x]['score']:.3f}"
+        for x in ['test', 'val', 'train']
+        if x in metrics
+    )
+
+
+def finish(output_dir: Path, report: dict) -> None:
+    print()
+    _print_sep('=')
+
+    metrics = report.get('metrics')
+    if metrics is not None:
+        scores = _get_scores(metrics)
+        if scores is not None:
+            dump_json(scores, output_dir / 'scores.json')
+            print(format_scores(metrics))
+            _print_sep('-')
+
+    dump_report(report, output_dir)
+    json_output_path = os.environ.get('JSON_OUTPUT_FILE')
+    if json_output_path:
+        try:
+            key = str(output_dir.relative_to(env.PROJ))
+        except ValueError:
+            pass
+        else:
+            json_output_path = Path(json_output_path)
+            try:
+                json_data = json.loads(json_output_path.read_text())
+            except (FileNotFoundError, json.decoder.JSONDecodeError):
+                json_data = {}
+            json_data[key] = load_json(output_dir / 'report.json')
+            json_output_path.write_text(json.dumps(json_data, indent=4))
+        shutil.copyfile(
+            json_output_path,
+            os.path.join(os.environ['SNAPSHOT_PATH'], 'json_output.json'),
+        )
+
+    output_dir.joinpath('DONE').touch()
+    backup_output(output_dir)
+    print(f'Done! | {report.get("time")} | {output_dir}')
+    _print_sep('=')
+    print()
+
+
+def from_dict(datacls: Type[T], data: dict) -> T:
+    assert is_dataclass(datacls)
+    data = deepcopy(data)
+    for field in fields(datacls):
+        if field.name not in data:
+            continue
+        if is_dataclass(field.type):
+            data[field.name] = from_dict(field.type, data[field.name])
+        elif (
+            get_origin(field.type) is Union
+            and len(get_args(field.type)) == 2
+            and get_args(field.type)[1] is type(None)
+            and is_dataclass(get_args(field.type)[0])
+        ):
+            if data[field.name] is not None:
+                data[field.name] = from_dict(get_args(field.type)[0], data[field.name])
+    return datacls(**data)
+
+
+def replace_factor_with_value(
+    config: RawConfig,
+    key: str,
+    reference_value: int,
+    bounds: Tuple[float, float],
+) -> None:
+    factor_key = key + '_factor'
+    if factor_key not in config:
+        assert key in config
+    else:
+        assert key not in config
+        factor = config.pop(factor_key)
+        assert bounds[0] <= factor <= bounds[1]
+        config[key] = int(factor * reference_value)
+
+
+def get_temporary_copy(path: Union[str, Path]) -> Path:
+    path = env.get_path(path)
+    assert not path.is_dir() and not path.is_symlink()
+    tmp_path = path.with_name(
+        path.stem + '___' + str(uuid.uuid4()).replace('-', '') + path.suffix
+    )
+    shutil.copyfile(path, tmp_path)
+    atexit.register(lambda: tmp_path.unlink())
+    return tmp_path
+
+
+def get_python():
+    python = Path('python3.9')
+    return str(python) if python.exists() else 'python'
+
+def get_catboost_config(real_data_path, is_cv=False):
+    ds_name = Path(real_data_path).name
+    C = load_json(f'tuned_models/catboost/{ds_name}_cv.json')
+    return C
+
+def get_categories(X_train_cat):
+    return (
+        None
+        if X_train_cat is None
+        else [
+            len(set(X_train_cat[:, i]))
+            for i in range(X_train_cat.shape[1])
+        ]
+    )

SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/_efvfm_runtime/synthetic/pipeline_c18/real.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d36ba8fd95415355fed46a70cd71921339f0b4b8f05320279bef35443ce4cc16
+size 42317177

SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/_efvfm_runtime/synthetic/pipeline_c18/test.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f9b247fe90d1b3de687afbee0871f768b5b9b41d8974110c1a1a4be0a1581258
+size 5283050

SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/_efvfm_runtime/synthetic/pipeline_c18/val.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6368d0c3f97d7449830710d697fc67e7fb71fa7038bc480892279eb41c153f0b
+size 5289617

SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/_efvfm_runtime/tests/conftest.py

@@ -0,0 +1,193 @@
+import pytest
+import numpy as np
+import torch
+import torch.nn.functional as F
+from unittest.mock import MagicMock
+
+
+# --------------- dimension configs ---------------
+
+@pytest.fixture
+def dims():
+    """Standard mixed-data dimensions."""
+    return {"d_numerical": 4, "categories": np.array([3, 5, 2]), "batch_size": 8, "d_token": 16}
+
+
+@pytest.fixture
+def dims_numerical_only():
+    """Numerical-only scenario (no categorical features)."""
+    return {"d_numerical": 5, "categories": None, "batch_size": 8, "d_token": 16}
+
+
+@pytest.fixture
+def dims_single():
+    """Minimal scenario: 1 numerical, 1 categorical with 2 classes."""
+    return {"d_numerical": 1, "categories": np.array([2]), "batch_size": 4, "d_token": 8}
+
+
+# --------------- dummy input factory ---------------
+
+@pytest.fixture
+def make_dummy_inputs():
+    """Factory: returns (x_num, x_cat_onehot, x_cat_int, timesteps) from any dims."""
+    def _make(d_numerical, categories, batch_size):
+        torch.manual_seed(42)
+        x_num = torch.randn(batch_size, d_numerical)
+        if categories is not None and len(categories) > 0:
+            cat_parts = []
+            for k in categories:
+                indices = torch.randint(0, k, (batch_size,))
+                cat_parts.append(F.one_hot(indices, k).float())
+            x_cat_onehot = torch.cat(cat_parts, dim=1)
+            x_cat_int = torch.stack(
+                [torch.randint(0, k, (batch_size,)) for k in categories], dim=1
+            )
+        else:
+            x_cat_onehot = None
+            x_cat_int = None
+        timesteps = torch.rand(batch_size)
+        return x_num, x_cat_onehot, x_cat_int, timesteps
+    return _make
+
+
+# --------------- model factories ---------------
+
+@pytest.fixture
+def make_tokenizer():
+    from ef_vfm.modules.transformer import Tokenizer
+    def _make(d_numerical, categories, d_token, bias=True):
+        cats = list(categories) if categories is not None else None
+        return Tokenizer(d_numerical, cats, d_token, bias)
+    return _make
+
+
+@pytest.fixture
+def make_transformer():
+    from ef_vfm.modules.transformer import Transformer
+    def _make(d_token, n_layers=2, n_heads=1, d_ffn_factor=4, activation='gelu'):
+        return Transformer(n_layers, d_token, n_heads, d_token, d_ffn_factor, activation=activation)
+    return _make
+
+
+@pytest.fixture
+def make_reconstructor():
+    from ef_vfm.modules.transformer import Reconstructor
+    def _make(d_numerical, categories, d_token):
+        cats = list(categories) if categories is not None else []
+        return Reconstructor(d_numerical, cats, d_token)
+    return _make
+
+
+@pytest.fixture
+def make_mlp():
+    from ef_vfm.modules.main_modules import MLP
+    def _make(d_in, dim_t=128, use_mlp=True):
+        return MLP(d_in, dim_t=dim_t, use_mlp=use_mlp)
+    return _make
+
+
+@pytest.fixture
+def make_unimodmlp():
+    from ef_vfm.modules.main_modules import UniModMLP
+    def _make(d_numerical, categories, d_token=16, n_layers=1, n_head=1,
+              factor=4, dim_t=64, activation='gelu'):
+        cats = list(categories) if categories is not None else []
+        return UniModMLP(
+            d_numerical, cats, n_layers, d_token,
+            n_head=n_head, factor=factor, dim_t=dim_t, activation=activation,
+        )
+    return _make
+
+
+@pytest.fixture
+def make_flow_model():
+    from ef_vfm.modules.main_modules import UniModMLP
+    from ef_vfm.models.flow_model import ExpVFM
+    def _make(d_numerical, categories, d_token=16, n_layers=1, dim_t=64):
+        cats_list = list(categories) if categories is not None else []
+        cats_np = np.array(cats_list)
+        model = UniModMLP(
+            d_numerical, cats_list, n_layers, d_token,
+            n_head=1, factor=4, dim_t=dim_t, activation='gelu',
+        )
+        flow = ExpVFM(
+            num_classes=cats_np,
+            num_numerical_features=d_numerical,
+            vf_fn=model,
+            device=torch.device('cpu'),
+        )
+        return flow
+    return _make
+
+
+@pytest.fixture
+def make_trainer():
+    """Factory: creates a minimal Trainer with mocked external dependencies."""
+    from ef_vfm.modules.main_modules import UniModMLP
+    from ef_vfm.models.flow_model import ExpVFM
+    from ef_vfm.trainer import Trainer
+
+    def _make(d_numerical=4, categories=np.array([3, 5, 2]),
+              lr=0.001, max_grad_norm=1.0, warmup_epochs=0,
+              lr_scheduler='reduce_lr_on_plateau', steps=10, tmp_path=None):
+
+        cats_list = list(categories) if categories is not None else []
+        cats_np = np.array(cats_list)
+
+        model = UniModMLP(
+            d_numerical, cats_list, 1, 16,
+            n_head=1, factor=4, dim_t=64, activation='gelu',
+        )
+        flow = ExpVFM(
+            num_classes=cats_np,
+            num_numerical_features=d_numerical,
+            vf_fn=model,
+            device=torch.device('cpu'),
+        )
+
+        # Build a small synthetic dataset: [N, d_num + len(cats)] with int cat indices
+        n_samples = 32
+        x_num = torch.randn(n_samples, d_numerical)
+        if len(cats_list) > 0:
+            x_cat = torch.stack(
+                [torch.randint(0, k, (n_samples,)) for k in cats_list], dim=1
+            ).float()
+            data = torch.cat([x_num, x_cat], dim=1)
+        else:
+            data = x_num
+
+        dataset = torch.utils.data.TensorDataset(data)
+        train_iter = torch.utils.data.DataLoader(dataset, batch_size=8, shuffle=False)
+        # DataLoader wraps in tuples; Trainer expects raw tensors, so use a wrapper
+        class _UnwrapLoader:
+            def __init__(self, loader):
+                self._loader = loader
+            def __iter__(self):
+                for (batch,) in self._loader:
+                    yield batch
+            def __len__(self):
+                return len(self._loader)
+
+        save_path = str(tmp_path) if tmp_path else "/tmp"
+        trainer = Trainer(
+            flow=flow,
+            train_iter=_UnwrapLoader(train_iter),
+            dataset=MagicMock(),
+            test_dataset=MagicMock(),
+            metrics=MagicMock(),
+            logger=MagicMock(),
+            lr=lr,
+            weight_decay=0,
+            steps=steps,
+            batch_size=8,
+            check_val_every=steps + 1,  # never evaluate during test
+            sample_batch_size=8,
+            model_save_path=save_path,
+            result_save_path=save_path,
+            lr_scheduler=lr_scheduler,
+            max_grad_norm=max_grad_norm,
+            warmup_epochs=warmup_epochs,
+            device=torch.device('cpu'),
+        )
+        return trainer
+    return _make

SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/_efvfm_runtime/tests/test_attention.py

@@ -0,0 +1,51 @@
+import pytest
+import torch
+from ef_vfm.modules.transformer import MultiheadAttention
+
+
+def test_output_shape_single_head():
+    attn = MultiheadAttention(d=16, n_heads=1, dropout=0.0)
+    x = torch.randn(4, 5, 16)
+    out = attn(x, x)
+    assert out.shape == (4, 5, 16)
+
+
+def test_output_shape_multi_head():
+    attn = MultiheadAttention(d=16, n_heads=4, dropout=0.0)
+    x = torch.randn(4, 5, 16)
+    out = attn(x, x)
+    assert out.shape == (4, 5, 16)
+
+
+def test_no_W_out_single_head():
+    attn = MultiheadAttention(d=16, n_heads=1, dropout=0.0)
+    assert attn.W_out is None
+
+
+def test_W_out_exists_multi_head():
+    attn = MultiheadAttention(d=16, n_heads=4, dropout=0.0)
+    assert attn.W_out is not None
+
+
+def test_cross_attention_diff_seq_len():
+    attn = MultiheadAttention(d=16, n_heads=1, dropout=0.0)
+    x_q = torch.randn(4, 3, 16)
+    x_kv = torch.randn(4, 7, 16)
+    out = attn(x_q, x_kv)
+    assert out.shape == (4, 3, 16)  # output seq_len matches query
+
+
+def test_invalid_d_nheads_raises():
+    with pytest.raises(AssertionError):
+        MultiheadAttention(d=15, n_heads=4, dropout=0.0)
+
+
+def test_gradient_flows():
+    attn = MultiheadAttention(d=16, n_heads=2, dropout=0.0)
+    x = torch.randn(4, 5, 16, requires_grad=True)
+    out = attn(x, x)
+    out.sum().backward()
+    assert x.grad is not None and x.grad.abs().sum() > 0
+    for name in ['W_q', 'W_k', 'W_v']:
+        param = getattr(attn, name)
+        assert param.weight.grad is not None and param.weight.grad.abs().sum() > 0

SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/_efvfm_runtime/tests/test_config.py

@@ -0,0 +1,62 @@
+import os
+from pathlib import Path
+
+from src.util import load_config
+from ef_vfm.modules.main_modules import UniModMLP
+
+
+CONFIG_PATH = Path(__file__).resolve().parent.parent / "ef_vfm" / "configs" / "ef_vfm_configs.toml"
+
+
+def test_load_config_returns_dict():
+    config = load_config(CONFIG_PATH)
+    assert isinstance(config, dict)
+
+
+def test_config_has_expected_sections():
+    config = load_config(CONFIG_PATH)
+    for key in ['data', 'unimodmlp_params', 'train', 'sample']:
+        assert key in config, f"Missing section '{key}'"
+
+
+def test_unimodmlp_params_complete():
+    config = load_config(CONFIG_PATH)
+    params = config['unimodmlp_params']
+    required = ['num_layers', 'd_token', 'n_head', 'factor', 'bias', 'dim_t', 'use_mlp', 'activation']
+    for key in required:
+        assert key in params, f"Missing param '{key}' in unimodmlp_params"
+
+
+def test_activation_value_is_valid():
+    config = load_config(CONFIG_PATH)
+    activation = config['unimodmlp_params']['activation']
+    assert activation in ('relu', 'gelu', 'silu'), f"Invalid activation '{activation}'"
+
+
+def test_train_main_has_new_params():
+    """Verify the recently added config params are present."""
+    config = load_config(CONFIG_PATH)
+    train = config['train']['main']
+    assert 'max_grad_norm' in train
+    assert 'warmup_epochs' in train
+    assert isinstance(train['max_grad_norm'], (int, float))
+    assert isinstance(train['warmup_epochs'], (int, float))
+
+
+def test_config_values_create_model():
+    config = load_config(CONFIG_PATH)
+    params = config['unimodmlp_params']
+    # Use dummy dimensions; the point is that config params are valid for the constructor
+    model = UniModMLP(
+        d_numerical=4,
+        categories=[3, 5, 2],
+        num_layers=params['num_layers'],
+        d_token=params['d_token'],
+        n_head=params['n_head'],
+        factor=params['factor'],
+        bias=params['bias'],
+        dim_t=params['dim_t'],
+        use_mlp=params['use_mlp'],
+        activation=params['activation'],
+    )
+    assert model is not None

SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/_efvfm_runtime/tests/test_flow_model.py

@@ -0,0 +1,219 @@
+import torch
+import numpy as np
+from unittest.mock import patch
+
+from ef_vfm.models.flow_model import ExpVFM, Velocity
+from ef_vfm.modules.main_modules import UniModMLP
+
+
+# ---- mixed_loss tests ----
+
+def test_mixed_loss_returns_two_scalars(make_flow_model, make_dummy_inputs, dims):
+    d = dims
+    flow = make_flow_model(d["d_numerical"], d["categories"])
+    _, _, x_cat_int, _ = make_dummy_inputs(d["d_numerical"], d["categories"], d["batch_size"])
+    x_num = torch.randn(d["batch_size"], d["d_numerical"])
+    x = torch.cat([x_num, x_cat_int.float()], dim=1)
+    d_loss, c_loss = flow.mixed_loss(x)
+    assert d_loss.dim() == 0 or d_loss.numel() == 1
+    assert c_loss.dim() == 0 or c_loss.numel() == 1
+
+
+def test_mixed_loss_finite(make_flow_model, make_dummy_inputs, dims):
+    d = dims
+    flow = make_flow_model(d["d_numerical"], d["categories"])
+    _, _, x_cat_int, _ = make_dummy_inputs(d["d_numerical"], d["categories"], d["batch_size"])
+    x_num = torch.randn(d["batch_size"], d["d_numerical"])
+    x = torch.cat([x_num, x_cat_int.float()], dim=1)
+    d_loss, c_loss = flow.mixed_loss(x)
+    assert torch.isfinite(d_loss).all()
+    assert torch.isfinite(c_loss).all()
+
+
+def test_mixed_loss_gradients_flow(make_flow_model, make_dummy_inputs, dims):
+    d = dims
+    flow = make_flow_model(d["d_numerical"], d["categories"])
+    _, _, x_cat_int, _ = make_dummy_inputs(d["d_numerical"], d["categories"], d["batch_size"])
+    x_num = torch.randn(d["batch_size"], d["d_numerical"])
+    x = torch.cat([x_num, x_cat_int.float()], dim=1)
+    d_loss, c_loss = flow.mixed_loss(x)
+    total = d_loss + c_loss
+    total.backward()
+    grads = [p.grad for p in flow.parameters() if p.grad is not None]
+    assert len(grads) > 0
+
+
+def test_mixed_loss_numerical_only(make_flow_model, make_dummy_inputs, dims_numerical_only):
+    d = dims_numerical_only
+    flow = make_flow_model(d["d_numerical"], d["categories"])
+    x = torch.randn(d["batch_size"], d["d_numerical"])
+    d_loss, c_loss = flow.mixed_loss(x)
+    assert d_loss.item() == 0.0  # no discrete features
+    assert c_loss.item() > 0.0
+
+
+# ---- sample tests (with mocked odeint) ----
+
+def _make_flow(d_numerical, categories):
+    cats_list = list(categories) if categories is not None else []
+    cats_np = np.array(cats_list)
+    model = UniModMLP(d_numerical, cats_list, 1, 16, n_head=1, factor=4, dim_t=64, activation='gelu')
+    return ExpVFM(cats_np, d_numerical, model, device=torch.device('cpu'))
+
+
+def test_sample_output_shape(dims):
+    d = dims
+    flow = _make_flow(d["d_numerical"], d["categories"])
+    d_in = d["d_numerical"] + sum(d["categories"])
+    n = 5
+    fake_trajectory = torch.randn(2, n, d_in)
+    with patch("ef_vfm.models.flow_model.odeint", return_value=fake_trajectory):
+        result = flow.sample(n)
+    d_out = d["d_numerical"] + len(d["categories"])
+    assert result.shape == (n, d_out)
+
+
+def test_sample_categorical_in_range(dims):
+    d = dims
+    flow = _make_flow(d["d_numerical"], d["categories"])
+    d_in = d["d_numerical"] + sum(d["categories"])
+    n = 16
+    fake_trajectory = torch.randn(2, n, d_in)
+    with patch("ef_vfm.models.flow_model.odeint", return_value=fake_trajectory):
+        result = flow.sample(n)
+    for i, k in enumerate(d["categories"]):
+        col = d["d_numerical"] + i
+        assert (result[:, col] >= 0).all()
+        assert (result[:, col] < k).all()
+
+
+def test_sample_returns_cpu(dims):
+    d = dims
+    flow = _make_flow(d["d_numerical"], d["categories"])
+    d_in = d["d_numerical"] + sum(d["categories"])
+    fake_trajectory = torch.randn(2, 4, d_in)
+    with patch("ef_vfm.models.flow_model.odeint", return_value=fake_trajectory):
+        result = flow.sample(4)
+    assert result.device == torch.device('cpu')
+
+
+def test_sample_single_sample(dims):
+    d = dims
+    flow = _make_flow(d["d_numerical"], d["categories"])
+    d_in = d["d_numerical"] + sum(d["categories"])
+    fake_trajectory = torch.randn(2, 1, d_in)
+    with patch("ef_vfm.models.flow_model.odeint", return_value=fake_trajectory):
+        result = flow.sample(1)
+    d_out = d["d_numerical"] + len(d["categories"])
+    assert result.shape == (1, d_out)
+
+
+# ---- to_one_hot tests ----
+
+def test_to_one_hot_shape(dims):
+    d = dims
+    flow = _make_flow(d["d_numerical"], d["categories"])
+    cats = d["categories"]
+    x_cat = torch.stack([torch.randint(0, k, (8,)) for k in cats], dim=1)
+    oh = flow.to_one_hot(x_cat)
+    assert oh.shape == (8, sum(cats))
+
+
+def test_to_one_hot_roundtrip(dims):
+    d = dims
+    flow = _make_flow(d["d_numerical"], d["categories"])
+    cats = d["categories"]
+    x_cat = torch.stack([torch.randint(0, k, (8,)) for k in cats], dim=1)
+    oh = flow.to_one_hot(x_cat)
+    # Recover indices via argmax per category slice
+    idx = 0
+    for i, k in enumerate(cats):
+        recovered = oh[:, idx:idx + k].argmax(dim=1)
+        assert torch.equal(recovered, x_cat[:, i])
+        idx += k
+
+
+def test_to_one_hot_binary_values(dims):
+    d = dims
+    flow = _make_flow(d["d_numerical"], d["categories"])
+    cats = d["categories"]
+    x_cat = torch.stack([torch.randint(0, k, (8,)) for k in cats], dim=1)
+    oh = flow.to_one_hot(x_cat)
+    assert set(oh.unique().tolist()).issubset({0, 1})
+
+
+# ---- Regression tests ----
+
+def test_regression_d_in_no_extra_len():
+    """d_in must be num_numerical + sum(num_classes), NOT + len(num_classes)."""
+    d_numerical = 4
+    categories = np.array([3, 5, 2])
+    flow = _make_flow(d_numerical, categories)
+    expected_d_in = d_numerical + sum(categories)  # 14, not 17
+    assert flow.num_numerical_features + sum(flow.num_classes) == expected_d_in
+
+
+def test_regression_sampling_indices_correct():
+    """Categorical argmax must go to columns [d_num, d_num+1, ...], not [0, 1, ...]."""
+    d_numerical = 4
+    categories = np.array([3, 5, 2])
+    n = 10
+    d_in = d_numerical + sum(categories)
+    d_out = d_numerical + len(categories)
+
+    # Simulate the post-processing from sample()
+    out = torch.randn(n, d_in)
+    sample = torch.zeros(n, d_out)
+    sample[:, :d_numerical] = out[:, :d_numerical]
+
+    idx = d_numerical  # correct starting index
+    for i, val in enumerate(categories):
+        col = d_numerical + i  # correct column
+        sample[:, col] = torch.argmax(out[:, idx:idx + val], dim=1)
+        idx += val
+
+    # Numerical columns must be untouched
+    assert torch.allclose(sample[:, :d_numerical], out[:, :d_numerical])
+    # Categorical columns at correct positions
+    for i, val in enumerate(categories):
+        col = d_numerical + i
+        assert (sample[:, col] >= 0).all()
+        assert (sample[:, col] < val).all()
+
+
+def test_regression_d_out_correct():
+    """d_out must be d_num + len(categories)."""
+    d_numerical = 4
+    categories = np.array([3, 5, 2])
+    flow = _make_flow(d_numerical, categories)
+    expected_d_out = d_numerical + len(categories)  # 7
+    assert expected_d_out == 7
+
+
+# ---- Velocity tests ----
+
+def test_velocity_output_shape(dims):
+    d = dims
+    cats_list = list(d["categories"])
+    model = UniModMLP(d["d_numerical"], cats_list, 1, d["d_token"],
+                      n_head=1, factor=4, dim_t=64, activation='gelu')
+    vel = Velocity(model)
+    d_in = d["d_numerical"] + sum(d["categories"])
+    x = torch.randn(d["batch_size"], d_in)
+    t = torch.tensor(0.5)
+    out = vel(t, x)
+    assert out.shape == (d["batch_size"], d_in)
+
+
+def test_velocity_scalar_t_broadcast(dims):
+    d = dims
+    cats_list = list(d["categories"])
+    model = UniModMLP(d["d_numerical"], cats_list, 1, d["d_token"],
+                      n_head=1, factor=4, dim_t=64, activation='gelu')
+    vel = Velocity(model)
+    d_in = d["d_numerical"] + sum(d["categories"])
+    x = torch.randn(d["batch_size"], d_in)
+    # Scalar t should work (gets broadcast internally)
+    t = torch.tensor(0.3)
+    out = vel(t, x)
+    assert out.shape == x.shape

SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/_efvfm_runtime/tests/test_mlp.py

@@ -0,0 +1,85 @@
+import torch
+import torch.nn as nn
+from ef_vfm.modules.main_modules import MLP, PositionalEmbedding
+
+
+# ---- PositionalEmbedding tests ----
+
+def test_positional_embedding_shape():
+    pe = PositionalEmbedding(num_channels=64)
+    x = torch.rand(8)
+    out = pe(x)
+    assert out.shape == (8, 64)
+
+
+def test_positional_embedding_bounded():
+    pe = PositionalEmbedding(num_channels=64)
+    x = torch.rand(8)
+    out = pe(x)
+    assert out.min() >= -1.0
+    assert out.max() <= 1.0
+
+
+def test_positional_embedding_deterministic():
+    pe = PositionalEmbedding(num_channels=64)
+    x = torch.tensor([0.1, 0.5, 0.9])
+    out1 = pe(x)
+    out2 = pe(x)
+    assert torch.equal(out1, out2)
+
+
+def test_positional_embedding_different_timesteps():
+    pe = PositionalEmbedding(num_channels=64)
+    t1 = torch.tensor([0.1])
+    t2 = torch.tensor([0.9])
+    assert not torch.allclose(pe(t1), pe(t2))
+
+
+# ---- MLP tests ----
+
+def test_mlp_output_shape(make_mlp):
+    mlp = make_mlp(d_in=32, dim_t=64)
+    x = torch.randn(8, 32)
+    t = torch.rand(8)
+    out = mlp(x, t)
+    assert out.shape == (8, 32)
+
+
+def test_mlp_use_mlp_true(make_mlp):
+    mlp = make_mlp(d_in=32, dim_t=64, use_mlp=True)
+    assert isinstance(mlp.mlp, nn.Sequential)
+
+
+def test_mlp_use_mlp_false(make_mlp):
+    mlp = make_mlp(d_in=32, dim_t=64, use_mlp=False)
+    assert isinstance(mlp.mlp, nn.Linear)
+
+
+def test_mlp_time_conditioning(make_mlp):
+    mlp = make_mlp(d_in=32, dim_t=64)
+    mlp.eval()
+    x = torch.randn(4, 32)
+    t1 = torch.zeros(4)
+    t2 = torch.ones(4)
+    out1 = mlp(x, t1)
+    out2 = mlp(x, t2)
+    assert not torch.allclose(out1, out2)
+
+
+def test_mlp_gradient_flows(make_mlp):
+    mlp = make_mlp(d_in=32, dim_t=64)
+    x = torch.randn(4, 32)
+    t = torch.rand(4)
+    out = mlp(x, t)
+    out.sum().backward()
+    assert mlp.proj.weight.grad is not None and mlp.proj.weight.grad.abs().sum() > 0
+    assert mlp.map_noise.num_channels == 64  # sanity check on PE config
+
+
+def test_mlp_different_dim_t(make_mlp):
+    for dim_t in [32, 128, 256]:
+        mlp = make_mlp(d_in=16, dim_t=dim_t)
+        x = torch.randn(4, 16)
+        t = torch.rand(4)
+        out = mlp(x, t)
+        assert out.shape == (4, 16)

SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/_efvfm_runtime/tests/test_reconstructor.py

@@ -0,0 +1,51 @@
+import torch
+import numpy as np
+from ef_vfm.modules.transformer import Reconstructor
+
+
+def test_output_shapes_mixed(make_reconstructor, dims):
+    d = dims
+    r = make_reconstructor(d["d_numerical"], d["categories"], d["d_token"])
+    seq_len = d["d_numerical"] + len(d["categories"])
+    h = torch.randn(d["batch_size"], seq_len, d["d_token"])
+    x_num, x_cat = r(h)
+    assert x_num.shape == (d["batch_size"], d["d_numerical"])
+    assert len(x_cat) == len(d["categories"])
+    for i, k in enumerate(d["categories"]):
+        assert x_cat[i].shape == (d["batch_size"], k)
+
+
+def test_categorical_count(make_reconstructor, dims):
+    d = dims
+    r = make_reconstructor(d["d_numerical"], d["categories"], d["d_token"])
+    seq_len = d["d_numerical"] + len(d["categories"])
+    h = torch.randn(d["batch_size"], seq_len, d["d_token"])
+    _, x_cat = r(h)
+    assert len(x_cat) == len(d["categories"])
+
+
+def test_empty_categories(make_reconstructor):
+    r = make_reconstructor(4, np.array([]), 16)
+    h = torch.randn(8, 4, 16)
+    x_num, x_cat = r(h)
+    assert x_num.shape == (8, 4)
+    assert len(x_cat) == 0
+
+
+def test_weight_shape(make_reconstructor, dims):
+    d = dims
+    r = make_reconstructor(d["d_numerical"], d["categories"], d["d_token"])
+    assert r.weight.shape == (d["d_numerical"], d["d_token"])
+
+
+def test_gradient_flows(make_reconstructor, dims):
+    d = dims
+    r = make_reconstructor(d["d_numerical"], d["categories"], d["d_token"])
+    seq_len = d["d_numerical"] + len(d["categories"])
+    h = torch.randn(d["batch_size"], seq_len, d["d_token"])
+    x_num, x_cat = r(h)
+    loss = x_num.sum() + sum(c.sum() for c in x_cat)
+    loss.backward()
+    assert r.weight.grad is not None and r.weight.grad.abs().sum() > 0
+    for recon in r.cat_recons:
+        assert recon.weight.grad is not None

SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/_efvfm_runtime/tests/test_tokenizer.py

@@ -0,0 +1,85 @@
+import torch
+import numpy as np
+
+
+def test_forward_shape_mixed(make_tokenizer, make_dummy_inputs, dims):
+    tok = make_tokenizer(dims["d_numerical"], dims["categories"], dims["d_token"])
+    x_num, x_cat_oh, _, _ = make_dummy_inputs(dims["d_numerical"], dims["categories"], dims["batch_size"])
+    out = tok(x_num, x_cat_oh)
+    expected_seq = 1 + dims["d_numerical"] + len(dims["categories"])
+    assert out.shape == (dims["batch_size"], expected_seq, dims["d_token"])
+
+
+def test_forward_shape_numerical_only(make_tokenizer, make_dummy_inputs, dims_numerical_only):
+    d = dims_numerical_only
+    tok = make_tokenizer(d["d_numerical"], d["categories"], d["d_token"])
+    x_num, _, _, _ = make_dummy_inputs(d["d_numerical"], d["categories"], d["batch_size"])
+    out = tok(x_num, None)
+    expected_seq = 1 + d["d_numerical"]
+    assert out.shape == (d["batch_size"], expected_seq, d["d_token"])
+
+
+def test_forward_shape_single_feature(make_tokenizer, make_dummy_inputs, dims_single):
+    d = dims_single
+    tok = make_tokenizer(d["d_numerical"], d["categories"], d["d_token"])
+    x_num, x_cat_oh, _, _ = make_dummy_inputs(d["d_numerical"], d["categories"], d["batch_size"])
+    out = tok(x_num, x_cat_oh)
+    expected_seq = 1 + d["d_numerical"] + len(d["categories"])
+    assert out.shape == (d["batch_size"], expected_seq, d["d_token"])
+
+
+def test_n_tokens_property(make_tokenizer, dims):
+    tok = make_tokenizer(dims["d_numerical"], dims["categories"], dims["d_token"])
+    expected = dims["d_numerical"] + 1 + len(dims["categories"])
+    assert tok.n_tokens == expected
+
+
+def test_n_tokens_numerical_only(make_tokenizer, dims_numerical_only):
+    d = dims_numerical_only
+    tok = make_tokenizer(d["d_numerical"], d["categories"], d["d_token"])
+    assert tok.n_tokens == d["d_numerical"] + 1
+
+
+def test_cls_token_position(make_tokenizer, make_dummy_inputs, dims):
+    tok = make_tokenizer(dims["d_numerical"], dims["categories"], dims["d_token"], bias=False)
+    x_num, x_cat_oh, _, _ = make_dummy_inputs(dims["d_numerical"], dims["categories"], dims["batch_size"])
+    out = tok(x_num, x_cat_oh)
+    # CLS token: ones * weight[0], so all batch rows should have the same CLS token
+    cls_tokens = out[:, 0, :]
+    assert torch.allclose(cls_tokens[0], cls_tokens[1])
+    assert torch.allclose(cls_tokens[0], tok.weight[0])
+
+
+def test_bias_vs_no_bias(make_tokenizer, make_dummy_inputs, dims):
+    d = dims
+    tok_bias = make_tokenizer(d["d_numerical"], d["categories"], d["d_token"], bias=True)
+    tok_no_bias = make_tokenizer(d["d_numerical"], d["categories"], d["d_token"], bias=False)
+    assert tok_bias.bias is not None
+    assert tok_no_bias.bias is None
+
+
+def test_category_offsets_values(make_tokenizer):
+    cats = np.array([3, 5, 2])
+    tok = make_tokenizer(4, cats, 16)
+    assert torch.equal(tok.category_offsets, torch.tensor([0, 3, 8]))
+    assert torch.equal(tok.category_ends, torch.tensor([3, 8, 10]))
+
+
+def test_cat_weight_shape(make_tokenizer, dims):
+    tok = make_tokenizer(dims["d_numerical"], dims["categories"], dims["d_token"])
+    assert tok.cat_weight.shape == (sum(dims["categories"]), dims["d_token"])
+
+
+def test_weight_shape(make_tokenizer, dims):
+    tok = make_tokenizer(dims["d_numerical"], dims["categories"], dims["d_token"])
+    assert tok.weight.shape == (dims["d_numerical"] + 1, dims["d_token"])
+
+
+def test_gradient_flows(make_tokenizer, make_dummy_inputs, dims):
+    tok = make_tokenizer(dims["d_numerical"], dims["categories"], dims["d_token"])
+    x_num, x_cat_oh, _, _ = make_dummy_inputs(dims["d_numerical"], dims["categories"], dims["batch_size"])
+    out = tok(x_num, x_cat_oh)
+    out.sum().backward()
+    assert tok.weight.grad is not None and tok.weight.grad.abs().sum() > 0
+    assert tok.cat_weight.grad is not None and tok.cat_weight.grad.abs().sum() > 0
+    assert tok.bias.grad is not None and tok.bias.grad.abs().sum() > 0

SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/_efvfm_runtime/tests/test_trainer.py

@@ -0,0 +1,98 @@
+import torch
+import numpy as np
+
+
+# ---- Gradient clipping tests ----
+
+def test_grad_clipping_applied(make_trainer, tmp_path):
+    trainer = make_trainer(max_grad_norm=0.5, tmp_path=tmp_path)
+    batch = next(iter(trainer.train_iter))
+    trainer._run_step(batch, closs_weight=1.0, dloss_weight=1.0)
+    # After clipping, total gradient norm should be <= max_grad_norm (with tolerance)
+    total_norm = torch.nn.utils.clip_grad_norm_(trainer.flow.parameters(), float('inf'))
+    # Gradients were already clipped in _run_step, then optimizer.step() zeroed them.
+    # So we re-run to check: do a fresh forward-backward without step
+    trainer.optimizer.zero_grad()
+    dloss, closs = trainer.flow.mixed_loss(batch.to(trainer.device))
+    (dloss + closs).backward()
+    torch.nn.utils.clip_grad_norm_(trainer.flow.parameters(), 0.5)
+    total_norm = 0.0
+    for p in trainer.flow.parameters():
+        if p.grad is not None:
+            total_norm += p.grad.data.norm(2).item() ** 2
+    total_norm = total_norm ** 0.5
+    assert total_norm <= 0.5 + 1e-6
+
+
+def test_grad_clipping_disabled(make_trainer, tmp_path):
+    trainer = make_trainer(max_grad_norm=0, tmp_path=tmp_path)
+    assert trainer.max_grad_norm == 0
+
+
+def test_run_step_returns_losses(make_trainer, tmp_path):
+    trainer = make_trainer(tmp_path=tmp_path)
+    batch = next(iter(trainer.train_iter))
+    dloss, closs = trainer._run_step(batch, closs_weight=1.0, dloss_weight=1.0)
+    assert isinstance(dloss, torch.Tensor)
+    assert isinstance(closs, torch.Tensor)
+    assert torch.isfinite(dloss)
+    assert torch.isfinite(closs)
+
+
+# ---- LR warmup tests ----
+
+def test_warmup_lr_linear_ramp(make_trainer, tmp_path):
+    init_lr = 0.01
+    warmup = 5
+    trainer = make_trainer(lr=init_lr, warmup_epochs=warmup, tmp_path=tmp_path)
+    # Simulate warmup epochs
+    for epoch in range(warmup):
+        expected_lr = init_lr * (epoch + 1) / warmup
+        if trainer.warmup_epochs > 0 and (epoch + 1) <= trainer.warmup_epochs:
+            warmup_lr = trainer.init_lr * (epoch + 1) / trainer.warmup_epochs
+            for pg in trainer.optimizer.param_groups:
+                pg["lr"] = warmup_lr
+        actual_lr = trainer.optimizer.param_groups[0]["lr"]
+        assert abs(actual_lr - expected_lr) < 1e-8, f"Epoch {epoch}: expected {expected_lr}, got {actual_lr}"
+
+
+def test_warmup_overrides_scheduler(make_trainer, tmp_path):
+    trainer = make_trainer(warmup_epochs=10, lr_scheduler='reduce_lr_on_plateau', tmp_path=tmp_path)
+    initial_lr = trainer.optimizer.param_groups[0]["lr"]
+    # During warmup, scheduler.step should NOT be called (we just set LR directly)
+    # Simulate epoch 1 warmup
+    warmup_lr = trainer.init_lr * 1 / trainer.warmup_epochs
+    for pg in trainer.optimizer.param_groups:
+        pg["lr"] = warmup_lr
+    assert trainer.optimizer.param_groups[0]["lr"] == warmup_lr
+    assert warmup_lr < initial_lr  # warmup starts lower
+
+
+def test_no_warmup_when_zero(make_trainer, tmp_path):
+    trainer = make_trainer(warmup_epochs=0, tmp_path=tmp_path)
+    assert trainer.warmup_epochs == 0
+    # LR should be the init_lr from the start
+    assert trainer.optimizer.param_groups[0]["lr"] == trainer.init_lr
+
+
+# ---- LR scheduler tests ----
+
+def test_anneal_lr(make_trainer, tmp_path):
+    trainer = make_trainer(lr=0.01, steps=100, lr_scheduler='anneal', tmp_path=tmp_path)
+    trainer._anneal_lr(50)
+    expected = 0.01 * (1 - 50 / 100)
+    assert abs(trainer.optimizer.param_groups[0]["lr"] - expected) < 1e-8
+
+
+# ---- EMA tests ----
+
+def test_ema_model_created(make_trainer, tmp_path):
+    trainer = make_trainer(tmp_path=tmp_path)
+    # EMA model should exist and have same structure as flow._vf_fn
+    assert trainer.ema_model is not None
+    ema_params = list(trainer.ema_model.parameters())
+    model_params = list(trainer.flow._vf_fn.parameters())
+    assert len(ema_params) == len(model_params)
+    # EMA params should be detached (requires_grad=False)
+    for p in ema_params:
+        assert not p.requires_grad

SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/_efvfm_runtime/tests/test_transformer.py

@@ -0,0 +1,73 @@
+import pytest
+import torch
+from ef_vfm.modules.transformer import Transformer
+
+
+def test_output_shape_preserved(make_transformer):
+    t = make_transformer(d_token=16, n_layers=2)
+    x = torch.randn(4, 5, 16)
+    out = t(x)
+    assert out.shape == x.shape
+
+
+def test_activation_gelu(make_transformer):
+    t = make_transformer(d_token=16, activation='gelu')
+    x = torch.randn(4, 5, 16)
+    out = t(x)
+    assert out.shape == x.shape
+
+
+def test_activation_silu(make_transformer):
+    t = make_transformer(d_token=16, activation='silu')
+    x = torch.randn(4, 5, 16)
+    out = t(x)
+    assert out.shape == x.shape
+
+
+def test_activation_relu(make_transformer):
+    t = make_transformer(d_token=16, activation='relu')
+    x = torch.randn(4, 5, 16)
+    out = t(x)
+    assert out.shape == x.shape
+
+
+def test_invalid_activation_raises():
+    with pytest.raises(ValueError, match="Unknown activation"):
+        Transformer(2, 16, 1, 16, 4, activation='bad')
+
+
+def test_prenorm_first_layer_no_norm0():
+    t = Transformer(2, 16, 1, 16, 4, prenormalization=True)
+    assert 'norm0' not in t.layers[0]
+    # Second layer should have norm0
+    assert 'norm0' in t.layers[1]
+
+
+def test_no_prenorm_all_layers_have_norm0():
+    t = Transformer(2, 16, 1, 16, 4, prenormalization=False)
+    for layer in t.layers:
+        assert 'norm0' in layer
+
+
+def test_single_layer():
+    t = Transformer(1, 16, 1, 16, 4)
+    x = torch.randn(4, 5, 16)
+    out = t(x)
+    assert out.shape == x.shape
+
+
+def test_multi_layer():
+    t = Transformer(4, 16, 1, 16, 4)
+    x = torch.randn(4, 5, 16)
+    out = t(x)
+    assert out.shape == x.shape
+
+
+def test_gradient_flows(make_transformer):
+    t = make_transformer(d_token=16, n_layers=2)
+    x = torch.randn(4, 5, 16, requires_grad=True)
+    out = t(x)
+    out.sum().backward()
+    assert x.grad is not None and x.grad.abs().sum() > 0
+    # Check gradients through at least the first layer's linear0
+    assert t.layers[0]['linear0'].weight.grad is not None

SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/_efvfm_runtime/tests/test_unimodmlp.py

@@ -0,0 +1,72 @@
+import torch
+import numpy as np
+
+
+def test_forward_shapes_mixed(make_unimodmlp, make_dummy_inputs, dims):
+    d = dims
+    model = make_unimodmlp(d["d_numerical"], d["categories"], d_token=d["d_token"])
+    x_num, x_cat_oh, _, t = make_dummy_inputs(d["d_numerical"], d["categories"], d["batch_size"])
+    x_num_pred, x_cat_pred = model(x_num, x_cat_oh, t)
+    assert x_num_pred.shape == (d["batch_size"], d["d_numerical"])
+    assert x_cat_pred.shape == (d["batch_size"], sum(d["categories"]))
+
+
+def test_forward_shapes_numerical_only(make_unimodmlp, make_dummy_inputs, dims_numerical_only):
+    d = dims_numerical_only
+    model = make_unimodmlp(d["d_numerical"], d["categories"], d_token=d["d_token"])
+    x_num, _, _, t = make_dummy_inputs(d["d_numerical"], d["categories"], d["batch_size"])
+    x_cat = torch.zeros(d["batch_size"], 0)
+    x_num_pred, x_cat_pred = model(x_num, x_cat, t)
+    assert x_num_pred.shape == (d["batch_size"], d["d_numerical"])
+    # When no categories, cat_pred should be zeros with shape matching x_cat
+    assert x_cat_pred.shape[0] == d["batch_size"]
+    assert torch.all(x_cat_pred == 0)
+
+
+def test_forward_shapes_single_feature(make_unimodmlp, make_dummy_inputs, dims_single):
+    d = dims_single
+    model = make_unimodmlp(d["d_numerical"], d["categories"], d_token=d["d_token"])
+    x_num, x_cat_oh, _, t = make_dummy_inputs(d["d_numerical"], d["categories"], d["batch_size"])
+    x_num_pred, x_cat_pred = model(x_num, x_cat_oh, t)
+    assert x_num_pred.shape == (d["batch_size"], d["d_numerical"])
+    assert x_cat_pred.shape == (d["batch_size"], sum(d["categories"]))
+
+
+def test_d_in_computation(make_unimodmlp, dims):
+    d = dims
+    model = make_unimodmlp(d["d_numerical"], d["categories"], d_token=d["d_token"])
+    expected = d["d_token"] * (d["d_numerical"] + len(d["categories"]))
+    assert model.mlp.proj.in_features == expected
+
+
+def test_output_dtypes(make_unimodmlp, make_dummy_inputs, dims):
+    d = dims
+    model = make_unimodmlp(d["d_numerical"], d["categories"], d_token=d["d_token"])
+    x_num, x_cat_oh, _, t = make_dummy_inputs(d["d_numerical"], d["categories"], d["batch_size"])
+    x_num_pred, x_cat_pred = model(x_num, x_cat_oh, t)
+    assert x_num_pred.dtype == torch.float32
+    assert x_cat_pred.dtype == torch.float32
+
+
+def test_gradient_flows_end_to_end(make_unimodmlp, make_dummy_inputs, dims):
+    d = dims
+    model = make_unimodmlp(d["d_numerical"], d["categories"], d_token=d["d_token"])
+    x_num, x_cat_oh, _, t = make_dummy_inputs(d["d_numerical"], d["categories"], d["batch_size"])
+    x_num_pred, x_cat_pred = model(x_num, x_cat_oh, t)
+    loss = x_num_pred.sum() + x_cat_pred.sum()
+    loss.backward()
+    params_with_grad = sum(1 for p in model.parameters() if p.grad is not None and p.grad.abs().sum() > 0)
+    total_params = sum(1 for _ in model.parameters())
+    # Transformer.head is defined but unused in forward(), so not all params get gradients
+    assert params_with_grad > total_params * 0.8, f"Only {params_with_grad}/{total_params} params got gradients"
+
+
+def test_different_activations(make_unimodmlp, make_dummy_inputs, dims):
+    d = dims
+    x_num, x_cat_oh, _, t = make_dummy_inputs(d["d_numerical"], d["categories"], d["batch_size"])
+    for act in ['relu', 'gelu', 'silu']:
+        model = make_unimodmlp(d["d_numerical"], d["categories"], d_token=d["d_token"], activation=act)
+        x_num_pred, x_cat_pred = model(x_num, x_cat_oh, t)
+        assert x_num_pred.shape == (d["batch_size"], d["d_numerical"])
+        assert torch.isfinite(x_num_pred).all()
+        assert torch.isfinite(x_cat_pred).all()

SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/_efvfm_runtime/tests/test_utils.py

@@ -0,0 +1,49 @@
+import torch
+import numpy as np
+
+from utils_train import update_ema, concat_y_to_X
+
+
+# ---- update_ema tests ----
+
+def test_update_ema_basic():
+    target = [torch.tensor([1.0, 2.0])]
+    source = [torch.tensor([3.0, 4.0])]
+    target[0].requires_grad_(False)
+    rate = 0.9
+    update_ema(target, source, rate=rate)
+    expected = 0.9 * torch.tensor([1.0, 2.0]) + 0.1 * torch.tensor([3.0, 4.0])
+    assert torch.allclose(target[0], expected)
+
+
+def test_update_ema_rate_zero():
+    target = [torch.tensor([1.0, 2.0])]
+    source = [torch.tensor([3.0, 4.0])]
+    target[0].requires_grad_(False)
+    update_ema(target, source, rate=0.0)
+    assert torch.allclose(target[0], torch.tensor([3.0, 4.0]))
+
+
+def test_update_ema_rate_one():
+    target = [torch.tensor([1.0, 2.0])]
+    source = [torch.tensor([3.0, 4.0])]
+    target[0].requires_grad_(False)
+    update_ema(target, source, rate=1.0)
+    assert torch.allclose(target[0], torch.tensor([1.0, 2.0]))
+
+
+# ---- concat_y_to_X tests ----
+
+def test_concat_y_to_X_with_X():
+    X = np.array([[1, 2], [3, 4]])
+    y = np.array([10, 20])
+    result = concat_y_to_X(X, y)
+    expected = np.array([[10, 1, 2], [20, 3, 4]])
+    np.testing.assert_array_equal(result, expected)
+
+
+def test_concat_y_to_X_without_X():
+    y = np.array([10, 20, 30])
+    result = concat_y_to_X(None, y)
+    expected = np.array([[10], [20], [30]])
+    np.testing.assert_array_equal(result, expected)

SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/_efvfm_runtime/utils_train.py

@@ -0,0 +1,183 @@
+import numpy as np
+import os
+
+import src
+from torch.utils.data import Dataset
+
+import torch
+
+
+class TabularDataset(Dataset):
+    def __init__(self, X_num, X_cat):
+        self.X_num = X_num
+        self.X_cat = X_cat
+
+    def __getitem__(self, index):
+        this_num = self.X_num[index]
+        this_cat = self.X_cat[index]
+
+        sample = (this_num, this_cat)
+
+        return sample
+
+    def __len__(self):
+        return self.X_num.shape[0]
+    
+class EFVFMDataset(Dataset):
+    def __init__(self, dataname, data_dir, info, isTrain=True, dequant_dist='none', int_dequant_factor=0.0):
+        self.dataname = dataname
+        self.data_dir = data_dir
+        self.info = info
+        self.isTrain = isTrain
+
+        X_num, X_cat, categories, d_numerical, num_inverse, int_inverse, cat_inverse = preprocess(data_dir, dequant_dist, int_dequant_factor, task_type = info['task_type'], inverse=True)
+        categories = np.array(categories)
+
+        X_train_num, _ = X_num
+        X_train_cat, _ = X_cat
+
+        X_train_num, X_test_num = X_num
+        X_train_cat, X_test_cat = X_cat
+
+        X_train_num, X_test_num = torch.tensor(X_train_num).float(), torch.tensor(X_test_num).float()
+        X_train_cat, X_test_cat =  torch.tensor(X_train_cat), torch.tensor(X_test_cat)
+
+        self.X = torch.cat((X_train_num, X_train_cat), dim=1) if isTrain else torch.cat((X_test_num, X_test_cat), dim=1)
+        self.num_inverse = num_inverse
+        self.int_inverse = int_inverse
+        self.cat_inverse = cat_inverse
+        self.d_numerical = d_numerical
+        self.categories = categories
+
+    def __getitem__(self, index):
+        return self.X[index]
+
+    def __len__(self):
+        return self.X.shape[0]
+
+def preprocess(dataset_path, dequant_dist='none', int_dequant_factor=0.0, task_type = 'binclass', inverse = False, cat_encoding = None, concat = True):
+    
+    T_dict = {}
+
+    T_dict['normalization'] = "quantile"
+    T_dict['num_nan_policy'] = 'mean'
+    T_dict['cat_nan_policy'] =  None
+    T_dict['cat_min_frequency'] = None
+    T_dict['cat_encoding'] = cat_encoding
+    T_dict['y_policy'] = "default"
+    T_dict['dequant_dist'] = dequant_dist
+    T_dict['int_dequant_factor'] = int_dequant_factor
+
+    T = src.Transformations(**T_dict)
+
+    dataset = make_dataset(
+        data_path = dataset_path,
+        T = T,
+        task_type = task_type,
+        change_val = False,
+        concat = concat,
+    )
+
+    if cat_encoding is None:
+        X_num = dataset.X_num
+        X_cat = dataset.X_cat
+
+        X_train_num, X_test_num = X_num['train'], X_num['test']
+        X_train_cat, X_test_cat = X_cat['train'], X_cat['test']
+        
+        categories = src.get_categories(X_train_cat)
+        d_numerical = X_train_num.shape[1]
+
+        X_num = (X_train_num, X_test_num)
+        X_cat = (X_train_cat, X_test_cat)
+
+
+        if inverse:
+            num_inverse = dataset.num_transform.inverse_transform if dataset.num_transform is not None else lambda x: x
+            int_inverse = dataset.int_transform.inverse_transform if dataset.int_transform is not None else lambda x: x
+            cat_inverse = dataset.cat_transform.inverse_transform if dataset.cat_transform is not None else lambda x: x
+
+            return X_num, X_cat, categories, d_numerical, num_inverse, int_inverse, cat_inverse
+        else:
+            return X_num, X_cat, categories, d_numerical
+    else:
+        return dataset
+
+
+def update_ema(target_params, source_params, rate=0.999):
+    """
+    Update target parameters to be closer to those of source parameters using
+    an exponential moving average.
+    :param target_params: the target parameter sequence.
+    :param source_params: the source parameter sequence.
+    :param rate: the EMA rate (closer to 1 means slower).
+    """
+    for target, source in zip(target_params, source_params):
+        target.detach().mul_(rate).add_(source.detach(), alpha=1 - rate)
+
+
+
+def concat_y_to_X(X, y):
+    if X is None:
+        return y.reshape(-1, 1)
+    return np.concatenate([y.reshape(-1, 1), X], axis=1)
+
+
+def make_dataset(
+    data_path: str,
+    T: src.Transformations,
+    task_type,
+    change_val: bool,
+    concat = True,
+):
+
+    # classification
+    if task_type == 'binclass' or task_type == 'multiclass':
+        X_cat = {} if os.path.exists(os.path.join(data_path, 'X_cat_train.npy'))  else None
+        X_num = {} if os.path.exists(os.path.join(data_path, 'X_num_train.npy')) else None
+        y = {} if os.path.exists(os.path.join(data_path, 'y_train.npy')) else None
+
+        for split in ['train', 'test']:
+            X_num_t, X_cat_t, y_t = src.read_pure_data(data_path, split)
+            if X_num is not None:
+                X_num[split] = X_num_t
+            if X_cat is not None:
+                if concat:
+                    X_cat_t = concat_y_to_X(X_cat_t, y_t)
+                X_cat[split] = X_cat_t  
+            if y is not None:
+                y[split] = y_t
+    else:
+        # regression
+        X_cat = {} if os.path.exists(os.path.join(data_path, 'X_cat_train.npy')) else None
+        X_num = {} if os.path.exists(os.path.join(data_path, 'X_num_train.npy')) else None
+        y = {} if os.path.exists(os.path.join(data_path, 'y_train.npy')) else None
+
+        for split in ['train', 'test']:
+            X_num_t, X_cat_t, y_t = src.read_pure_data(data_path, split)
+            if X_num is not None:
+                if concat:
+                    X_num_t = concat_y_to_X(X_num_t, y_t)
+                X_num[split] = X_num_t
+            if X_cat is not None:
+                X_cat[split] = X_cat_t
+            if y is not None:
+                y[split] = y_t
+
+    info = src.load_json(os.path.join(data_path, 'info.json'))
+    int_col_idx_wrt_num = info['int_col_idx_wrt_num']
+
+    D = src.Dataset(
+        X_num,
+        X_cat,
+        y,
+        int_col_idx_wrt_num,
+        y_info={},
+        task_type=src.TaskType(info['task_type']),
+        n_classes=info.get('n_classes')
+    )
+
+    if change_val:
+        D = src.change_val(D)
+
+    return src.transform_dataset(D, T, None)

SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/_tabbyflow_gen.py

@@ -0,0 +1,43 @@
+
+import os, shutil, subprocess, sys
+root = r"/workspace/ef-vfm"
+rt = r"/work/output-Benchmark-trainonly-v1/c18/tabbyflow/tabbyflow-c18-20260510_213427/_efvfm_runtime"
+name = r"pipeline_c18"
+src = r"/work/output-Benchmark-trainonly-v1/c18/tabbyflow/tabbyflow-c18-20260510_213427/tabular_bundle/pipeline_c18"
+
+if not os.path.exists(rt):
+    def _ignore(_, names):
+        skip = {"__pycache__", "data", "synthetic", "result", "results", "ckpt"}
+        return [n for n in names if n in skip or n.endswith(".pyc")]
+    shutil.copytree(root, rt, ignore=_ignore)
+
+dst_data = os.path.join(rt, "data", name)
+shutil.rmtree(dst_data, ignore_errors=True)
+os.makedirs(os.path.dirname(dst_data), exist_ok=True)
+shutil.copytree(src, dst_data)
+dst_syn = os.path.join(rt, "synthetic", name)
+os.makedirs(dst_syn, exist_ok=True)
+for fn in ("real.csv", "test.csv", "val.csv"):
+    shutil.copy(os.path.join(src, fn), os.path.join(dst_syn, fn))
+os.chdir(rt)
+os.environ["PYTHONPATH"] = rt + os.pathsep + os.environ.get("PYTHONPATH", "")
+os.environ.setdefault("EFVFM_SAMPLE_BATCH_SIZE", "128")
+subprocess.check_call([
+    sys.executable, os.path.join(rt, "main.py"),
+    "--dataname", name, "--mode", "test", "--gpu", "0",
+    "--no_wandb", "--exp_name", r"adapter_efvfm",
+    "--ckpt_path", r"/work/output-Benchmark-trainonly-v1/c18/tabbyflow/tabbyflow-c18-20260510_213427/_efvfm_runtime/ef_vfm/ckpt/pipeline_c18/adapter_efvfm/model_100.pt",
+    "--num_samples_to_generate", str(int(103976)),
+])
+base = os.path.join(rt, "ef_vfm", "result", name, r"adapter_efvfm")
+best = None
+best_t = -1.0
+for r, _, files in os.walk(base):
+    if "samples.csv" in files:
+        p = os.path.join(r, "samples.csv")
+        t = os.path.getmtime(p)
+        if t > best_t:
+            best_t, best = t, p
+if not best:
+    raise SystemExit("tabbyflow: no samples.csv in " + base)
+shutil.copy(best, r"/work/output-Benchmark-trainonly-v1/c18/tabbyflow/tabbyflow-c18-20260510_213427/tabbyflow-c18-103976-20260510_220650.csv")

SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/_tabbyflow_train.py

@@ -0,0 +1,33 @@
+
+import os, shutil, subprocess, sys
+root = r"/workspace/ef-vfm"
+rt = r"/work/output-Benchmark-trainonly-v1/c18/tabbyflow/tabbyflow-c18-20260510_213427/_efvfm_runtime"
+name = r"pipeline_c18"
+src = r"/work/output-Benchmark-trainonly-v1/c18/tabbyflow/tabbyflow-c18-20260510_213427/tabular_bundle/pipeline_c18"
+
+shutil.rmtree(rt, ignore_errors=True)
+
+def _ignore(_, names):
+    skip = {"__pycache__", "data", "synthetic", "result", "results", "ckpt"}
+    return [n for n in names if n in skip or n.endswith(".pyc")]
+
+shutil.copytree(root, rt, ignore=_ignore)
+dst_data = os.path.join(rt, "data", name)
+dst_syn = os.path.join(rt, "synthetic", name)
+shutil.rmtree(dst_data, ignore_errors=True)
+os.makedirs(os.path.dirname(dst_data), exist_ok=True)
+shutil.copytree(src, dst_data)
+os.makedirs(dst_syn, exist_ok=True)
+for fn in ("real.csv", "test.csv", "val.csv"):
+    shutil.copy(os.path.join(src, fn), os.path.join(dst_syn, fn))
+os.chdir(rt)
+os.environ["PYTHONPATH"] = rt + os.pathsep + os.environ.get("PYTHONPATH", "")
+os.environ["EFVFM_SMOKE_STEPS"] = "100"
+os.environ["EFVFM_ADAPTER_TRAIN"] = "1"
+os.environ.setdefault("EFVFM_SAMPLE_BATCH_SIZE", "128")
+os.environ.setdefault("EFVFM_EVAL_NUM_SAMPLES", "512")
+subprocess.check_call([
+    sys.executable, os.path.join(rt, "main.py"),
+    "--dataname", name, "--mode", "train", "--gpu", "0",
+    "--no_wandb", "--exp_name", r"adapter_efvfm",
+])

SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/gen_20260510_220650.log

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:60272411cd2686623ae07edfd4ba2c01bd33a786f63b3817d7ebc8f09d09510e
+size 29448

SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/input_snapshot.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f5787b2a7ff2d4a3a4b9d3f1e29377a29d2609332bc4f856299d02f07732fe21
+size 1365

SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/models_tabbyflow/trained.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:adb734fec12f2251befd371dca69e481b19464aded2a6823105a01b4be6ddbe5
+size 40

SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/public_gate/normalized_schema_snapshot.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ca33a02c28873c5ec5fec52da747d206cd9e461100244e401a7a2e5ef3cba096
+size 8391

SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/public_gate/public_gate_report.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:27f1ca3c2a10e936a41ba26048d2f0bc62addbfac55033a559ba761621c8ed22
+size 921

SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/public_gate/staged_input_manifest.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:720f40b40d96d695fde092864e53c06f47f9bbf3fb57183f896d5f062a348bd4
+size 9227

SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/run_config.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:97657dae1fff5f36133843b732bf0117da8414dd222a3812c3fc446496e4cdd8
+size 2128

SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/runtime_result.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e8f92fa48876ca53589a236b3bf3ab835406cc1080d078144c9cce9c78e26675
+size 935

SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/staged/public/staged_features.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:632cd1c583d7dfd3107947bb9a317b8bb4bc567040e03ec88232c59e6f87a161
+size 1350

SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/staged/public/test.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f9b247fe90d1b3de687afbee0871f768b5b9b41d8974110c1a1a4be0a1581258
+size 5283050

SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/staged/public/train.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d36ba8fd95415355fed46a70cd71921339f0b4b8f05320279bef35443ce4cc16
+size 42317177

SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/staged/public/val.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6368d0c3f97d7449830710d697fc67e7fb71fa7038bc480892279eb41c153f0b
+size 5289617

SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/staged/tabbyflow/adapter_report.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3f1774bb5d3e85d324dbe2510c9f94443456083d64a2f25259abc461db871d5b
+size 329

SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/staged/tabbyflow/adapter_transforms_applied.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945
+size 2

SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/staged/tabbyflow/model_input_manifest.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b2d15db7f1d7784813d4c6abad7ba2e408afa0ebb54d24499f5cc7499f0df04d
+size 9432

SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/tabbyflow-c18-103976-20260510_220650.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0cd55106209868b55641ed2104ef5ca8075465c06301d4042187e452a163ba0d
+size 9090047

SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/tabbyflow_train_meta.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b0de645964eb3d9fabeaede2e9d29f34382e022a0b1b83a46bd42b05d714e47a
+size 421

SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/tabular_bundle/pipeline_c18/X_cat_test.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:522e91773b610a4bcec0addfe70d39b7729fffda5ceea974d89d9c029c58a87a
+size 1039968

SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/tabular_bundle/pipeline_c18/X_cat_train.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fcdf602ae63c4060f515006dea8e1eb9760f340895595ff4633756fd6cad46f6
+size 8318208

SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/tabular_bundle/pipeline_c18/X_cat_val.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:846aaac9c59ba2304d6108d84adb274ccdfb010aaaa2511e4638e283ac5512ec
+size 1039888

SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/tabular_bundle/pipeline_c18/X_num_test.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0253fa1c6392e29e00501296d74d33b6e49670cdf3168b442642c1ab9a3b8778
+size 156104

SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/tabular_bundle/pipeline_c18/X_num_train.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c62b331fc153f5bc92690d5e809441dacf9a2514aa1beb6fe565a8ab09679589
+size 1247840

SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/tabular_bundle/pipeline_c18/X_num_val.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1179a8861b392c9ddd6295a9a744e2444a7f561b72b12dbfab1b8c16e1da7aa6
+size 156092

SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/tabular_bundle/pipeline_c18/info.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d99f30b28b7d90954953e48be4de88c479fcff1fd0a0f154e73f663333ddea01
+size 2360

SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/tabular_bundle/pipeline_c18/real.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d36ba8fd95415355fed46a70cd71921339f0b4b8f05320279bef35443ce4cc16
+size 42317177

SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/tabular_bundle/pipeline_c18/staged_features.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:632cd1c583d7dfd3107947bb9a317b8bb4bc567040e03ec88232c59e6f87a161
+size 1350

SynthData0523/main/c18/tabbyflow/tabbyflow-c18-20260510_213427/tabular_bundle/pipeline_c18/test.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f9b247fe90d1b3de687afbee0871f768b5b9b41d8974110c1a1a4be0a1581258
+size 5283050