Resume SynthData0523 hyper_parameter_tuning/n11/tabdiff batch 4

.gitattributes

@@ -18065,3 +18065,69 @@ SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_04595
 SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_045956/train_20260521_045956.log filter=lfs diff=lfs merge=lfs -text
 SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/_tabdiff_runtime/images/tabdiff_demo.gif filter=lfs diff=lfs merge=lfs -text
 SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/_tabdiff_runtime/images/tabdiff_demo.mp4 filter=lfs diff=lfs merge=lfs -text
+SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/_tabdiff_runtime/tabdiff/configs/tabdiff_configs.toml filter=lfs diff=lfs merge=lfs -text
+SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/bo_combo.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/gen_20260521_053144.log filter=lfs diff=lfs merge=lfs -text
+SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/input_snapshot.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/models_tabdiff/trained.pt filter=lfs diff=lfs merge=lfs -text
+SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/public_gate/normalized_schema_snapshot.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/public_gate/public_gate_report.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/public_gate/staged_input_manifest.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/run_config.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/runtime_result.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/staged/public/staged_features.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/staged/public/test.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/staged/public/train.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/staged/public/val.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/staged/tabdiff/adapter_report.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/staged/tabdiff/adapter_transforms_applied.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/staged/tabdiff/model_input_manifest.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/tabdiff-n11-15215-20260521_053144.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/tabdiff_train_meta.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/tabular_bundle/pipeline_n11/X_num_test.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/tabular_bundle/pipeline_n11/X_num_train.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/tabular_bundle/pipeline_n11/X_num_val.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/tabular_bundle/pipeline_n11/info.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/tabular_bundle/pipeline_n11/real.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/tabular_bundle/pipeline_n11/staged_features.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/tabular_bundle/pipeline_n11/test.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/tabular_bundle/pipeline_n11/train.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/tabular_bundle/pipeline_n11/val.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/tabular_bundle/pipeline_n11/y_test.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/tabular_bundle/pipeline_n11/y_train.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/tabular_bundle/pipeline_n11/y_val.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/train_20260521_051643.log filter=lfs diff=lfs merge=lfs -text
+SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_053348/_tabdiff_runtime/images/tabdiff_demo.gif filter=lfs diff=lfs merge=lfs -text
+SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_053348/_tabdiff_runtime/images/tabdiff_demo.mp4 filter=lfs diff=lfs merge=lfs -text
+SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_053348/_tabdiff_runtime/tabdiff/configs/tabdiff_configs.toml filter=lfs diff=lfs merge=lfs -text
+SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_053348/bo_combo.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_053348/gen_20260521_054153.log filter=lfs diff=lfs merge=lfs -text
+SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_053348/input_snapshot.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_053348/models_tabdiff/trained.pt filter=lfs diff=lfs merge=lfs -text
+SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_053348/public_gate/normalized_schema_snapshot.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_053348/public_gate/public_gate_report.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_053348/public_gate/staged_input_manifest.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_053348/run_config.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_053348/runtime_result.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_053348/staged/public/staged_features.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_053348/staged/public/test.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_053348/staged/public/train.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_053348/staged/public/val.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_053348/staged/tabdiff/adapter_report.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_053348/staged/tabdiff/adapter_transforms_applied.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_053348/staged/tabdiff/model_input_manifest.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_053348/tabdiff-n11-15215-20260521_054153.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_053348/tabdiff_train_meta.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_053348/tabular_bundle/pipeline_n11/X_num_test.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_053348/tabular_bundle/pipeline_n11/X_num_train.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_053348/tabular_bundle/pipeline_n11/X_num_val.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_053348/tabular_bundle/pipeline_n11/info.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_053348/tabular_bundle/pipeline_n11/real.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_053348/tabular_bundle/pipeline_n11/staged_features.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_053348/tabular_bundle/pipeline_n11/test.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_053348/tabular_bundle/pipeline_n11/train.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_053348/tabular_bundle/pipeline_n11/val.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_053348/tabular_bundle/pipeline_n11/y_test.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_053348/tabular_bundle/pipeline_n11/y_train.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_053348/tabular_bundle/pipeline_n11/y_val.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_053348/train_20260521_053348.log filter=lfs diff=lfs merge=lfs -text

SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/_tabdiff_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/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/_tabdiff_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=int(os.environ.get('TABDIFF_NUM_WORKERS', '0')),
+    )
+    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=int(os.environ.get('TABDIFF_NUM_WORKERS', '0')))
+
+    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/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/_tabdiff_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/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/_tabdiff_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/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/_tabdiff_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/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/_tabdiff_runtime/synthcity.yaml

@@ -0,0 +1,11 @@
+name: synthcity
+channels:
+  - pytorch
+  - nvidia
+  - defaults
+dependencies:
+  - python=3.10
+  - pip
+  - pip:
+      - synthcity
+      - category_encoders

SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/_tabdiff_runtime/tabdiff.yaml

@@ -0,0 +1,35 @@
+name: tabdiff
+channels:
+  - pytorch
+  - nvidia
+  - defaults
+dependencies:
+  - python=3.10
+  - pytorch=2.0.1
+  - torchvision==0.15.2
+  - torchaudio==2.0.2
+  - pytorch-cuda=11.7
+  - numpy<2
+  - pip
+  - pip:
+    - pandas
+    - scikit-learn
+    - scipy
+    - icecream
+    - xlrd
+    - tomli-w
+    - tomli==2.0.1
+    - category_encoders
+    - imbalanced-learn
+    - kaggle
+    - transformers
+    - datasets
+    - peft==0.9.0
+    - ml_collections
+    - sdmetrics
+    - prdc
+    - rdt
+    - openpyxl
+    - xgboost
+    - wandb==0.17.3
+    - kaleido

SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/_tabdiff_runtime/tabdiff/configs/tabdiff_configs.toml

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

SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/_tabdiff_runtime/tabdiff/main.py

@@ -0,0 +1,344 @@
+import glob
+import json
+import os
+import pickle
+import random
+
+import numpy as np
+from tabdiff.metrics import TabMetrics
+from tabdiff.modules.main_modules import UniModMLP
+from tabdiff.modules.main_modules import Model
+from tabdiff.models.unified_ctime_diffusion import UnifiedCtimeDiffusion
+from tabdiff.trainer import Trainer
+import src
+import torch
+
+from torch.utils.data import DataLoader
+import argparse
+import warnings
+
+import wandb
+
+from copy import deepcopy
+
+from utils_train import TabDiffDataset
+
+warnings.filterwarnings('ignore')
+
+
+def main(args):
+    device = args.device
+
+    ## Disable scientific numerical format
+    np.set_printoptions(suppress=True)
+    torch.set_printoptions(sci_mode=False)
+
+    ## Get data info
+    dataname = args.dataname
+    data_dir = f'data/{dataname}'
+    info_path = f'data/{dataname}/info.json'
+    with open(info_path, 'r') as f:
+        info = json.load(f)
+    
+    ## Set up flags
+    is_dcr = 'dcr' in dataname
+
+    ## Set experiment name
+    exp_name = args.exp_name
+    if args.exp_name is None:
+        exp_name = 'non_learnable_schedule' if args.non_learnable_schedule else 'learnable_schedule'
+    exp_name += '_y_only' if args.y_only else ''
+    
+    ## Load configs
+    curr_dir = os.path.dirname(os.path.abspath(__file__))
+    config_path = f'{curr_dir}/configs/tabdiff_configs.toml'
+    raw_config = src.load_config(config_path)
+    
+    print(f"{args.mode.capitalize()} Mode is Enabled")
+    num_samples_to_generate = None
+    ckpt_path = None
+    if args.mode == 'train':
+        print("NEW training is started")
+    elif args.mode == 'test':
+        num_samples_to_generate = args.num_samples_to_generate
+        ckpt_path = args.ckpt_path
+        if ckpt_path is None:
+            ckpt_parent_path = f"{curr_dir}/ckpt/{dataname}/{exp_name}"
+            ckpt_path_arr = glob.glob(f"{ckpt_parent_path}/best_ema_model*")
+            assert ckpt_path_arr, f"Cannot not infer ckpt_path from {ckpt_parent_path}, please make sure that you first train a model before testing!"
+            ckpt_path = ckpt_path_arr[0]
+        config_path = os.path.join(os.path.dirname(ckpt_path), 'config.pkl')
+        if os.path.exists(config_path):
+            with open(config_path, 'rb') as f:
+                cached_raw_config = pickle.load(f)
+                print(f"Found cached config at {config_path}")
+        raw_config = cached_raw_config
+    
+    
+    ## Creat model_save and result paths
+    model_save_path, result_save_path = None, None
+    if args.mode == 'train':
+        model_save_path = 'debug/ckpt' if args.debug else f'{curr_dir}/ckpt/{dataname}/{exp_name}'
+        result_save_path = model_save_path.replace('ckpt', 'result')  #i.e., f'{curr_dir}/results/{dataname}/{exp_name}'
+    elif args.mode == 'test':
+        if args.report:
+            result_save_path = f"eval/report_runs/{exp_name}/{dataname}"
+        else:
+            result_save_path = os.path.dirname(ckpt_path).replace('ckpt', 'result')    # infer the exp_name from the ckpt_name
+    raw_config['model_save_path'] = model_save_path
+    raw_config['result_save_path'] = result_save_path
+    if model_save_path is not None:
+        if not os.path.exists(model_save_path):
+            os.makedirs(model_save_path)
+    if result_save_path is not None:
+        if not os.path.exists(result_save_path):
+            os.makedirs(result_save_path)
+    
+    ## Make everything determinstic if needed
+    raw_config['deterministic'] = args.deterministic
+    if args.deterministic:
+        print("DETERMINISTIC MODE is enabled!!!")
+        ## Set global random seeds
+        torch.manual_seed(0)
+        random.seed(0)
+        np.random.seed(0)
+
+        ## Ensure deterministic CUDA operations
+        os.environ['PYTHONHASHSEED'] = '0'
+        os.environ['CUBLAS_WORKSPACE_CONFIG'] = ':4096:8'  # or ':16:8'
+        torch.use_deterministic_algorithms(True)
+        if torch.cuda.is_available():
+            torch.cuda.manual_seed(0)
+            torch.cuda.manual_seed_all(0)
+            torch.backends.cudnn.deterministic = True
+            torch.backends.cudnn.benchmark = False
+    
+    ## Set debug mode parameters
+    if args.debug:  # fast eval for DEBUG mode
+        raw_config['train']['main']['check_val_every'] = 2
+        raw_config['diffusion_params']['num_timesteps'] = 4
+        raw_config['train']['main']['batch_size'] = 4096
+        raw_config['sample']['batch_size'] = 10000
+
+    # CI /镜像冒烟：覆盖训练步数（默认不设置）
+    _smoke_steps = os.environ.get("TABDIFF_SMOKE_STEPS", "").strip()
+    if _smoke_steps and args.mode == "train":
+        n = max(1, int(_smoke_steps))
+        raw_config["train"]["main"]["steps"] = n
+        raw_config["train"]["main"]["check_val_every"] = max(1, min(n, raw_config["train"]["main"]["check_val_every"]))
+    # Pipeline 适配器：避免小步数训练时在中途频繁做生成评测；仅在最后一轮 checkpoint
+    if os.environ.get("TABDIFF_ADAPTER_TRAIN", "").strip() and args.mode == "train":
+        raw_config["train"]["main"]["check_val_every"] = int(raw_config["train"]["main"]["steps"])
+
+    _train_batch = os.environ.get("TABDIFF_BATCH_SIZE", "").strip() or os.environ.get("TABDIFF_TRAIN_BATCH_SIZE", "").strip()
+    if _train_batch:
+        raw_config["train"]["main"]["batch_size"] = max(1, int(_train_batch))
+    _sample_batch = os.environ.get("TABDIFF_SAMPLE_BATCH_SIZE", "").strip()
+    if _sample_batch:
+        raw_config["sample"]["batch_size"] = max(1, int(_sample_batch))
+    _train_lr = os.environ.get("TABDIFF_LR", "").strip() or os.environ.get("TABDIFF_LEARNING_RATE", "").strip()
+    if _train_lr:
+        raw_config["train"]["main"]["lr"] = float(_train_lr)
+    _num_timesteps = os.environ.get("TABDIFF_NUM_TIMESTEPS", "").strip() or os.environ.get("TABDIFF_TIMESTEPS", "").strip()
+    if _num_timesteps:
+        raw_config["diffusion_params"]["num_timesteps"] = max(1, int(_num_timesteps))
+
+    ## Load training data
+    batch_size = raw_config['train']['main']['batch_size']
+
+    train_data = TabDiffDataset(dataname, data_dir, info, y_only=args.y_only, isTrain=True, dequant_dist=raw_config['data']['dequant_dist'], int_dequant_factor=raw_config['data']['int_dequant_factor'])
+    train_loader = DataLoader(
+        train_data,
+        batch_size = batch_size,
+        shuffle = True,
+        num_workers = int(os.environ.get('TABDIFF_NUM_WORKERS', '0')),
+    )
+    d_numerical, categories = train_data.d_numerical, train_data.categories
+    
+    val_data = TabDiffDataset(dataname, data_dir, info, y_only=args.y_only, isTrain=False, dequant_dist=raw_config['data']['dequant_dist'], int_dequant_factor=raw_config['data']['int_dequant_factor'])
+
+    ## Load Metrics
+    real_data_path = f'synthetic/{dataname}/real.csv'
+    test_data_path = f'synthetic/{dataname}/test.csv'
+    val_data_path = f'synthetic/{dataname}/val.csv'
+    if not os.path.exists(val_data_path):
+        print(f"{args.dataname} does not have its validation set. During MLE evaluation, a validation set will be splitted from the training set!")
+        val_data_path = None
+    if args.mode == 'train':
+        metric_list = ["density"]
+    else:
+        if is_dcr:
+            metric_list = ["dcr"]
+        else:
+            metric_list = [
+                "density", 
+                "mle", 
+                "c2st",
+            ]
+    metrics = TabMetrics(real_data_path, test_data_path, val_data_path, info, device, metric_list=metric_list)
+    
+    ## Load the module and models
+    raw_config['unimodmlp_params']['d_numerical'] = d_numerical
+    raw_config['unimodmlp_params']['categories'] = (categories+1).tolist()  # add one for the mask category
+    if args.y_only:
+        raw_config['unimodmlp_params']['use_mlp'] = False     # drop the mlp when training the unconditional model
+        raw_config['unimodmlp_params']['dim_t'] = 128   #reduce the size of the mlp
+        main_model_path = args.ckpt_path
+        if main_model_path is None:
+            main_model_parent_path = f"{curr_dir}/ckpt/{dataname}/{exp_name.replace('_y_only', '')}"
+            main_model_path_arr = glob.glob(f"{main_model_parent_path}/best_ema_model*")
+            assert main_model_path_arr, f"Cannot not infer the main model's ckpt_path from {main_model_parent_path}, please make sure that you first train a main model before training the y_only model!"
+            main_model_path = main_model_path_arr[0]
+        main_model_configs = pickle.load(open(os.path.join(os.path.dirname(main_model_path), 'config.pkl'), 'rb'))
+        if main_model_configs['diffusion_params']['scheduler'] == "power_mean_per_column": # if learnable schedule is enabled in the main model, we need to infer noise params of the target column from the main model ckpt and train the y_only model with those params
+            from tabdiff.models.noise_schedule import PowerMeanNoise_PerColumn, LogLinearNoise_PerColumn
+            if info['task_type'] == 'regression':
+                noise_schedule = PowerMeanNoise_PerColumn(
+                    num_numerical=main_model_configs['unimodmlp_params']['d_numerical'], 
+                    **main_model_configs['diffusion_params']['noise_schedule_params']
+                )
+                raw_config['diffusion_params']['noise_schedule_params']['rho'] = noise_schedule.rho()[0].item()    # the target col is placed at the first position
+            else:
+                noise_schedule = LogLinearNoise_PerColumn(
+                    num_categories=len(main_model_configs['unimodmlp_params']['categories']), 
+                    **main_model_configs['diffusion_params']['noise_schedule_params']
+                )
+                raw_config['diffusion_params']['noise_schedule_params']['k'] = noise_schedule.k()[0].item()    # the target col is placed at the first position
+            
+    backbone = UniModMLP(
+        **raw_config['unimodmlp_params']
+    )
+    model = Model(backbone, **raw_config['diffusion_params']['edm_params'])
+    model.to(device)
+    
+    ## Create and load y_only_model for imputation
+    y_only_model = None
+    if args.impute:
+        y_only_model_path = args.y_only_model_path
+        if y_only_model_path is None:
+            y_only_model_parent_path = f"{curr_dir}/ckpt/{dataname}/{exp_name}_y_only"
+            y_only_model_path_arr = glob.glob(f"{y_only_model_parent_path}/best_ema_model*")
+            assert y_only_model_path_arr, f"Cannot not infer y_only model's ckpt_path from {y_only_model_parent_path}, please make sure that you first train a y_only model before testing imputation!"
+            y_only_model_path = y_only_model_path_arr[0]
+        y_only_model_config_path = os.path.join(os.path.dirname(y_only_model_path), 'config.pkl')
+        with open(y_only_model_config_path, 'rb') as f:
+                y_only_model_config = pickle.load(f)
+        y_only_model = UniModMLP(
+            **y_only_model_config['unimodmlp_params']
+        )
+        y_only_model = Model(y_only_model, **y_only_model_config['diffusion_params']['edm_params'])
+        y_only_model.to(device)
+        # load weights
+        state_dicts = torch.load(y_only_model_path, map_location=device)
+        y_only_model.load_state_dict(state_dicts['denoise_fn'])
+
+    if not args.y_only and not args.non_learnable_schedule:
+        raw_config['diffusion_params']['scheduler'] = 'power_mean_per_column'
+        raw_config['diffusion_params']['cat_scheduler'] = 'log_linear_per_column'
+    diffusion = UnifiedCtimeDiffusion(
+        num_classes=categories,
+        num_numerical_features=d_numerical,
+        denoise_fn=model,
+        y_only_model=y_only_model,
+        **raw_config['diffusion_params'],
+        device=device,
+    )
+    num_params = sum(p.numel() for p in diffusion.parameters())
+    print("The number of parameters = ", num_params)
+    diffusion.to(device)
+    diffusion.train()
+
+    ## Print the configs
+    printed_configs = json.dumps(raw_config, default=lambda x: int(x) if isinstance(x, np.int64) else x, indent=4)
+    print(f"The config of the current run is : \n {printed_configs}")
+    
+    ## Enable Wandb
+    project_name = f"tabdiff_{dataname}"
+    raw_config['project_name'] = project_name
+    logger = wandb.init(
+        project=raw_config['project_name'], 
+        name=exp_name,
+        config=raw_config,
+        mode='disabled' if args.debug or args.no_wandb else 'online',
+    )
+
+    ## Load Trainer
+    sample_batch_size = raw_config['sample']['batch_size']
+    trainer = Trainer(
+        diffusion,
+        train_loader,
+        train_data,
+        val_data,
+        metrics,
+        logger,
+        **raw_config['train']['main'],
+        sample_batch_size=sample_batch_size,
+        num_samples_to_generate=num_samples_to_generate,
+        model_save_path=raw_config['model_save_path'],
+        result_save_path=raw_config['result_save_path'],
+        device=device,
+        ckpt_path=ckpt_path,
+        y_only=args.y_only
+    )
+    if args.mode == 'test':
+        if args.report:
+            if  is_dcr:
+                trainer.report_test_dcr(args.num_runs)
+            else:
+                trainer.report_test(args.num_runs)
+        elif args.impute:
+            imputed_sample_save_dir = f"impute/{dataname}/{exp_name}"
+            trainer.test_impute(
+                args.trial_start, args.trial_size, 
+                args.resample_rounds, 
+                args.impute_condition, 
+                imputed_sample_save_dir,
+                args.w_num,
+                args.w_cat,
+            )
+        else:
+            trainer.test()
+    else:
+        ## Save config
+        config_save_path = raw_config['model_save_path']
+        with open (os.path.join(config_save_path, 'config.pkl'), 'wb') as f:
+            pickle.dump(raw_config, f)
+        trainer.run_loop()
+
+
+
+if __name__ == '__main__':
+
+    parser = argparse.ArgumentParser(description='Training of TabDiff')
+
+    parser.add_argument('--dataname', type=str, default='adult', help='Name of dataset.')
+    parser.add_argument('--gpu', type=int, default=0, help='GPU index.')
+    parser.add_argument('--mode', type=str, default='train', choices=['train', 'test'])
+    parser.add_argument('--debug', action='store_true')
+    parser.add_argument('--no_wandb', action='store_true')
+    parser.add_argument('--deterministic', action='store_true')
+    parser.add_argument('--exp_name', type=str, default=None)
+    parser.add_argument('--non_learnable_schedule', action='store_true')
+    parser.add_argument('--y_only', action='store_true')
+    parser.add_argument('--ckpt_path', type=str, default=None)
+    parser.add_argument('--num_samples_to_generate', type=int, default=None)
+    parser.add_argument('--report', action='store_true')
+    parser.add_argument('--num_runs', type=int, default=20)
+    parser.add_argument('--impute', action='store_true')
+    parser.add_argument('--trial_start', type=int, default=0)
+    parser.add_argument('--trial_size', type=int, default=100)
+    parser.add_argument('--resample_rounds', type=int, default=1)
+    parser.add_argument('--impute_condition', type=str, default='')
+    parser.add_argument('--w_num', type=float, default=1.0)
+    parser.add_argument('--w_cat', type=float, default=1.0)
+    parser.add_argument('--y_only_model_path', type=str, default=None)
+
+    args = parser.parse_args()
+
+    # check cuda
+    if args.gpu != -1 and torch.cuda.is_available():
+        args.device = f'cuda:{args.gpu}'
+    else:
+        args.device = 'cpu'
+
+    main(args)

SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/_tabdiff_runtime/tabdiff/metrics.py

@@ -0,0 +1,306 @@
+from copy import deepcopy
+import numpy as np
+import torch
+import pandas as pd
+# Metrics
+from eval.mle.mle import get_evaluator
+from eval.visualize_density import plot_density
+from sdmetrics.reports.single_table import QualityReport, DiagnosticReport
+from sdmetrics.single_table import LogisticDetection
+from sklearn.preprocessing import OneHotEncoder
+
+from tqdm import tqdm
+
+
+class TabMetrics(object):
+    def __init__(self, real_data_path, test_data_path, val_data_path, info, device, metric_list) -> None:
+        self.real_data_path = real_data_path
+        self.test_data_path = test_data_path
+        self.val_data_path = val_data_path
+        self.info = info
+        self.device = device
+        self.real_data_size = len(pd.read_csv(real_data_path))
+        self.metric_list = metric_list
+
+    def evaluate(self, syn_data):
+        metrics, extras = {}, {}
+        syn_data_cp = deepcopy(syn_data)
+        for metric in self.metric_list:
+            func = eval(f"self.evaluate_{metric}")
+            print(f"Evaluating {metric}")
+            out_metrics, out_extras = func(syn_data_cp)
+            metrics.update(out_metrics)
+            extras.update(out_extras)
+        return metrics, extras
+    
+    def evaluate_density(self, syn_data):
+        real_data = pd.read_csv(self.real_data_path)
+        real_data.columns = range(len(real_data.columns))
+        syn_data.columns = range(len(syn_data.columns))
+        
+
+        info = deepcopy(self.info)
+        
+        y_only = len(syn_data.columns)==1
+        if y_only:
+            target_col_idx = info['target_col_idx'][0]
+            syn_data = self.complete_y_only_data(syn_data, real_data, target_col_idx)
+
+        metadata = info['metadata']
+        metadata['columns'] = {int(key): value for key, value in metadata['columns'].items()} # ensure that keys are all integers?
+
+        new_real_data, new_syn_data, metadata = reorder(real_data, syn_data, info)
+
+        qual_report = QualityReport()
+        qual_report.generate(new_real_data, new_syn_data, metadata)
+
+        diag_report = DiagnosticReport()
+        diag_report.generate(new_real_data, new_syn_data, metadata)
+
+        quality =  qual_report.get_properties()
+        diag = diag_report.get_properties()
+
+        Shape = quality['Score'][0]
+        Trend = quality['Score'][1]
+
+        Overall = (Shape + Trend) / 2
+
+        shape_details = qual_report.get_details(property_name='Column Shapes')
+        trend_details = qual_report.get_details(property_name='Column Pair Trends')
+
+        if y_only:
+            Shape = shape_details['Score'].min()
+        out_metrics = {
+            "density/Shape": Shape,
+            "density/Trend": Trend,
+            "density/Overall": Overall,
+        }
+        out_extras = {
+            "shapes": shape_details,
+            "trends": trend_details
+        }
+        return out_metrics, out_extras
+    
+    def evaluate_mle(self, syn_data):
+        train = syn_data.to_numpy()
+        test = pd.read_csv(self.test_data_path).to_numpy()
+        val = pd.read_csv(self.val_data_path).to_numpy() if self.val_data_path else None
+        
+        info = deepcopy(self.info)
+
+        task_type = info['task_type']
+
+        evaluator = get_evaluator(task_type)
+
+        if task_type == 'regression':
+            best_r2_scores, best_rmse_scores = evaluator(train, test, info, val=val)
+            
+            overall_scores = {}
+            for score_name in ['best_r2_scores', 'best_rmse_scores']:
+                overall_scores[score_name] = {}
+                
+                scores = eval(score_name)
+                for method in scores:
+                    name = method['name']  
+                    method.pop('name')
+                    overall_scores[score_name][name] = method 
+
+        else:
+            best_f1_scores, best_weighted_scores, best_auroc_scores, best_acc_scores, best_avg_scores = evaluator(train, test, info, val=val)
+
+            overall_scores = {}
+            for score_name in ['best_f1_scores', 'best_weighted_scores', 'best_auroc_scores', 'best_acc_scores', 'best_avg_scores']:
+                overall_scores[score_name] = {}
+                
+                scores = eval(score_name)
+                for method in scores:
+                    name = method['name']  
+                    method.pop('name')
+                    overall_scores[score_name][name] = method
+                    
+        mle_score = overall_scores['best_rmse_scores']['XGBRegressor']['RMSE'] if task_type == 'regression' else overall_scores['best_auroc_scores']['XGBClassifier']['roc_auc']
+        out_metrics = {
+            "mle": mle_score,
+        }
+        out_extras = {
+            "mle": overall_scores,
+        }
+        return out_metrics, out_extras
+    
+    def evaluate_c2st(self, syn_data):
+        info = deepcopy(self.info)
+        real_data = pd.read_csv(self.real_data_path)
+
+        real_data.columns = range(len(real_data.columns))
+        syn_data.columns = range(len(syn_data.columns))
+
+        metadata = info['metadata']
+        metadata['columns'] = {int(key): value for key, value in metadata['columns'].items()}
+
+        new_real_data, new_syn_data, metadata = reorder(real_data, syn_data, info)
+
+        score = LogisticDetection.compute(
+            real_data=new_real_data,
+            synthetic_data=new_syn_data,
+            metadata=metadata
+        )
+        
+        out_metrics = {
+            "c2st": score,
+        }
+        out_extras = {}
+        return out_metrics, out_extras
+
+    def evaluate_dcr(self, syn_data):
+        info = deepcopy(self.info)
+        real_data = pd.read_csv(self.real_data_path)
+        test_data = pd.read_csv(self.test_data_path)
+        
+        num_col_idx = info['num_col_idx']
+        cat_col_idx = info['cat_col_idx']
+        target_col_idx = info['target_col_idx']
+
+        task_type = info['task_type']
+        if task_type == 'regression':
+            num_col_idx += target_col_idx
+        else:
+            cat_col_idx += target_col_idx
+
+        num_ranges = []
+
+        real_data.columns = list(np.arange(len(real_data.columns)))
+        syn_data.columns = list(np.arange(len(real_data.columns)))
+        test_data.columns = list(np.arange(len(real_data.columns)))
+        for i in num_col_idx:
+            num_ranges.append(real_data[i].max() - real_data[i].min()) 
+        
+        num_ranges = np.array(num_ranges)
+
+
+        num_real_data = real_data[num_col_idx]
+        cat_real_data = real_data[cat_col_idx]
+        num_syn_data = syn_data[num_col_idx]
+        cat_syn_data = syn_data[cat_col_idx]
+        num_test_data = test_data[num_col_idx]
+        cat_test_data = test_data[cat_col_idx]
+
+        num_real_data_np = num_real_data.to_numpy()
+        cat_real_data_np = cat_real_data.to_numpy().astype('str')
+        num_syn_data_np = num_syn_data.to_numpy()
+        cat_syn_data_np = cat_syn_data.to_numpy().astype('str')
+        num_test_data_np = num_test_data.to_numpy()
+        cat_test_data_np = cat_test_data.to_numpy().astype('str')
+
+        encoder = OneHotEncoder()
+        cat_complete_data_np = np.concatenate([cat_real_data_np, cat_test_data_np], axis=0)
+        encoder.fit(cat_complete_data_np)
+        # encoder.fit(cat_real_data_np)
+
+
+        cat_real_data_oh = encoder.transform(cat_real_data_np).toarray()
+        cat_syn_data_oh = encoder.transform(cat_syn_data_np).toarray()
+        cat_test_data_oh = encoder.transform(cat_test_data_np).toarray()
+
+        num_real_data_np = num_real_data_np / num_ranges
+        num_syn_data_np = num_syn_data_np / num_ranges
+        num_test_data_np = num_test_data_np / num_ranges
+
+        real_data_np = np.concatenate([num_real_data_np, cat_real_data_oh], axis=1)
+        syn_data_np = np.concatenate([num_syn_data_np, cat_syn_data_oh], axis=1)
+        test_data_np = np.concatenate([num_test_data_np, cat_test_data_oh], axis=1)
+
+        device = self.device
+
+        real_data_th = torch.tensor(real_data_np).to(device)
+        syn_data_th = torch.tensor(syn_data_np).to(device)  
+        test_data_th = torch.tensor(test_data_np).to(device)
+
+        dcrs_real = []
+        dcrs_test = []
+        batch_size = 10000 // cat_real_data_oh.shape[1]   # This esitmation should make sure that dcr_real and dcr_test can be fit into 10GB GPU memory
+
+        for i in tqdm(range((syn_data_th.shape[0] // batch_size) + 1)):
+            if i != (syn_data_th.shape[0] // batch_size):
+                batch_syn_data_th = syn_data_th[i*batch_size: (i+1) * batch_size]
+            else:
+                batch_syn_data_th = syn_data_th[i*batch_size:]
+                
+            dcr_real = (batch_syn_data_th[:, None] - real_data_th).abs().sum(dim = 2).min(dim = 1).values
+            dcr_test = (batch_syn_data_th[:, None] - test_data_th).abs().sum(dim = 2).min(dim = 1).values
+            dcrs_real.append(dcr_real)
+            dcrs_test.append(dcr_test)
+            
+        dcrs_real = torch.cat(dcrs_real)
+        dcrs_test = torch.cat(dcrs_test)
+        
+        score = (dcrs_real < dcrs_test).nonzero().shape[0] / dcrs_real.shape[0]
+        
+        out_metrics = {
+            "dcr": score,
+        }
+        out_extras = {
+            "dcr_real": dcrs_real.cpu().numpy(),
+            "dcr_test": dcrs_test.cpu().numpy(),
+        }
+        return out_metrics, out_extras
+        
+    
+    def plot_density(self, syn_data):
+        syn_data_cp = deepcopy(syn_data)
+        real_data = pd.read_csv(self.real_data_path)
+        info = deepcopy(self.info)
+        y_only = len(syn_data_cp.columns)==1
+        if y_only:
+            target_col_idx = info['target_col_idx'][0]
+            target_col_name = info['column_names'][target_col_idx]
+            syn_data_cp = self.complete_y_only_data(syn_data_cp, real_data, target_col_name)
+        img = plot_density(syn_data_cp, real_data, info)
+        return img
+    
+    def complete_y_only_data(self, syn_data, real_data, target_col_idx):
+        syn_target_col = deepcopy(syn_data.iloc[:, 0])
+        syn_data = deepcopy(real_data)
+        syn_data[target_col_idx] = syn_target_col
+        return syn_data
+        
+
+def reorder(real_data, syn_data, info):
+    num_col_idx = deepcopy(info['num_col_idx']) # BUG: info will be modified by += in the next few lines
+    cat_col_idx = deepcopy(info['cat_col_idx'])
+    target_col_idx = deepcopy(info['target_col_idx'])
+
+    task_type = info['task_type']
+    if task_type == 'regression':
+        num_col_idx += target_col_idx
+    else:
+        cat_col_idx += target_col_idx
+
+    real_num_data = real_data[num_col_idx]
+    real_cat_data = real_data[cat_col_idx]
+
+    new_real_data = pd.concat([real_num_data, real_cat_data], axis=1)
+    new_real_data.columns = range(len(new_real_data.columns))
+
+    syn_num_data = syn_data[num_col_idx]
+    syn_cat_data = syn_data[cat_col_idx]
+    
+    new_syn_data = pd.concat([syn_num_data, syn_cat_data], axis=1)
+    new_syn_data.columns = range(len(new_syn_data.columns))
+
+    
+    metadata = info['metadata']
+
+    columns = metadata['columns']
+    metadata['columns'] = {}
+
+    inverse_idx_mapping = info['inverse_idx_mapping']
+
+
+    for i in range(len(new_real_data.columns)):
+        if i < len(num_col_idx):
+            metadata['columns'][i] = columns[num_col_idx[i]]
+        else:
+            metadata['columns'][i] = columns[cat_col_idx[i-len(num_col_idx)]]
+    
+
+    return new_real_data, new_syn_data, metadata

SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/_tabdiff_runtime/tabdiff/models/noise_schedule.py

@@ -0,0 +1,157 @@
+import abc
+
+import torch
+import torch.nn as nn
+
+
+class Noise(abc.ABC, nn.Module):
+  """
+  Baseline forward method to get the total + rate of noise at a timestep
+  """
+  def forward(self, t):
+    # Assume time goes from 0 to 1
+    return self.total_noise(t), self.rate_noise(t)
+
+  @abc.abstractmethod
+  def total_noise(self, t):
+    """
+    Total noise ie \int_0^t g(t) dt + g(0)
+    """
+    pass
+  
+
+class LogLinearNoise(Noise):
+  """Log Linear noise schedule.
+    
+  """
+  def __init__(self, eps_max=1e-3, eps_min=1e-5, **kwargs):
+    super().__init__()
+    self.eps_max = eps_max
+    self.eps_min = eps_min
+    self.sigma_max = self.total_noise(torch.tensor(1.0))
+    self.sigma_min = self.total_noise(torch.tensor(0.0))
+    
+  def k(self):
+    return torch.tensor(1)
+
+  def rate_noise(self, t):
+    return (1 - self.eps_max - self.eps_min) / (1 - ((1 - self.eps_max - self.eps_min) * t + self.eps_min))
+
+  def total_noise(self, t):
+    """
+    sigma_min=-log(1-eps_min), when t=0
+    sigma_max=-log(eps_max), when t=1
+    """
+    return -torch.log1p(-((1 - self.eps_max - self.eps_min) * t + self.eps_min))
+  
+class PowerMeanNoise(Noise):
+  """The noise schedule using the power mean interpolation function.
+  
+  This is the schedule used in EDM
+  """
+  def __init__(self, sigma_min=0.002, sigma_max=80, rho=7, **kwargs):
+    super().__init__()
+    self.sigma_min = sigma_min
+    self.sigma_max = sigma_max
+    self.raw_rho = rho
+    
+  def rho(self):
+    # Return the softplus-transformed rho for all num_numerical values
+    return torch.tensor(self.raw_rho)
+
+  def total_noise(self, t):
+    sigma = (self.sigma_min ** (1/self.rho()) + t * (
+                self.sigma_max ** (1/self.rho()) - self.sigma_min ** (1/self.rho()))).pow(self.rho())
+    return sigma
+  
+  def inverse_to_t(self, sigma):
+    t = (sigma.pow(1/self.rho()) - self.sigma_min ** (1/self.rho())) / (self.sigma_max ** (1/self.rho()) - self.sigma_min ** (1/self.rho()))
+    return t
+
+
+class PowerMeanNoise_PerColumn(nn.Module):
+
+  def __init__(self, num_numerical, sigma_min=0.002, sigma_max=80, rho_init=1, rho_offset=2, **kwargs):
+    super().__init__()
+    self.sigma_min = sigma_min
+    self.sigma_max = sigma_max
+    self.num_numerical = num_numerical
+    self.rho_offset = rho_offset
+    self.rho_raw = nn.Parameter(torch.tensor([rho_init] * self.num_numerical, dtype=torch.float32))
+
+  def rho(self):
+    # Return the softplus-transformed rho for all num_numerical values
+    return nn.functional.softplus(self.rho_raw) + self.rho_offset
+
+  def total_noise(self, t):
+    """
+    Compute total noise for each t in the batch for all num_numerical rhos.
+    t: [batch_size]
+    Returns: [batch_size, num_numerical]
+    """
+    batch_size = t.size(0)
+
+    rho = self.rho()
+
+    sigma_min_pow = self.sigma_min ** (1 / rho)  # Shape: [num_numerical]
+    sigma_max_pow = self.sigma_max ** (1 / rho)  # Shape: [num_numerical]
+
+    sigma = (sigma_min_pow + t * (sigma_max_pow - sigma_min_pow)).pow(rho)  # Shape: [batch_size, num_numerical]
+
+    return sigma
+
+  def rate_noise(self, t):
+    return None
+
+  def inverse_to_t(self, sigma):
+    """
+    Inverse function to map sigma back to t, with proper broadcasting support.
+    sigma: [batch_size, num_numerical] or [batch_size, 1]
+    Returns: t: [batch_size, num_numerical]
+    """
+    rho = self.rho()
+
+    sigma_min_pow = self.sigma_min ** (1 / rho)  # Shape: [num_numerical]
+    sigma_max_pow = self.sigma_max ** (1 / rho)  # Shape: [num_numerical]
+
+    # To enable broadcasting between sigma and the per-column rho values, expand rho where needed.
+    t = (sigma.pow(1 / rho) - sigma_min_pow) / (sigma_max_pow - sigma_min_pow)
+
+    return t
+
+
+class LogLinearNoise_PerColumn(nn.Module):
+
+  def __init__(self, num_categories, eps_max=1e-3, eps_min=1e-5, k_init=-6, k_offset=1, **kwargs):
+
+    super().__init__()
+    self.eps_max = eps_max
+    self.eps_min = eps_min
+    # Use softplus to ensure k is positive
+    self.num_categories = num_categories
+    self.k_offset = k_offset
+    self.k_raw = nn.Parameter(torch.tensor([k_init] * self.num_categories, dtype=torch.float32))
+
+  def k(self):
+    return torch.nn.functional.softplus(self.k_raw) + self.k_offset
+
+  def rate_noise(self, t, noise_fn=None):
+    """
+    Compute rate noise for all categories with broadcasting.
+    t: [batch_size]
+    Returns: [batch_size, num_categories]
+    """
+    k = self.k()  # Shape: [num_categories]
+
+    numerator = (1 - self.eps_max - self.eps_min) * k * t.pow(k - 1)
+    denominator = 1 - ((1 - self.eps_max - self.eps_min) * t.pow(k) + self.eps_min)
+    rate = numerator / denominator  # Shape: [batch_size, num_categories]
+
+    return rate
+
+  def total_noise(self, t, noise_fn=None):
+    k = self.k()  # Shape: [num_categories]
+    
+    total_noise = -torch.log1p(-((1 - self.eps_max - self.eps_min) * t.pow(k) + self.eps_min))
+
+    return total_noise

SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/_tabdiff_runtime/tabdiff/models/unified_ctime_diffusion.py

@@ -0,0 +1,597 @@
+import torch.nn.functional as F
+import torch
+import math
+import numpy as np
+from tabdiff.models.noise_schedule import *
+from tqdm import tqdm
+from itertools import chain
+
+"""
+“Our implementation of the continuous-time masked diffusion is inspired by https://arxiv.org/abs/2406.07524's implementation at [https://github.com/kuleshov-group/mdlm], with modifications to support data distributions that include categorical dimensions of different sizes.”
+"""
+
+S_churn= 1
+S_min=0
+S_max=float('inf')
+S_noise=1
+
+class UnifiedCtimeDiffusion(torch.nn.Module):
+    def __init__(
+            self,
+            num_classes: np.array,
+            num_numerical_features: int,
+            denoise_fn,
+            y_only_model,
+            num_timesteps=1000,
+            scheduler='power_mean',
+            cat_scheduler='log_linear',
+            noise_dist='uniform',
+            edm_params={},
+            noise_dist_params={},
+            noise_schedule_params={},
+            sampler_params={},
+            device=torch.device('cpu'),
+            **kwargs
+        ):
+
+        super(UnifiedCtimeDiffusion, self).__init__()
+
+        self.num_numerical_features = num_numerical_features
+        self.num_classes = num_classes # it as a vector [K1, K2, ..., Km]
+        self.num_classes_expanded = torch.from_numpy(
+            np.concatenate([num_classes[i].repeat(num_classes[i]) for i in range(len(num_classes))])
+        ).to(device) if len(num_classes)>0 else torch.tensor([]).to(device).int()
+        self.mask_index = torch.tensor(self.num_classes).long().to(device)
+        self.neg_infinity = -1000000.0 
+        self.num_classes_w_mask = tuple(self.num_classes + 1)
+
+        offsets = np.cumsum(self.num_classes)
+        offsets = np.append([0], offsets)
+        self.slices_for_classes = []
+        for i in range(1, len(offsets)):
+            self.slices_for_classes.append(np.arange(offsets[i - 1], offsets[i]))
+        self.offsets = torch.from_numpy(offsets).to(device)
+        
+        offsets = np.cumsum(self.num_classes) + np.arange(1, len(self.num_classes)+1)
+        offsets = np.append([0], offsets)
+        self.slices_for_classes_with_mask = []
+        for i in range(1, len(offsets)):
+            self.slices_for_classes_with_mask.append(np.arange(offsets[i - 1], offsets[i]))
+
+        self._denoise_fn = denoise_fn
+        self.y_only_model = y_only_model
+        self.num_timesteps = num_timesteps
+        self.scheduler = scheduler
+        self.cat_scheduler = cat_scheduler
+        self.noise_dist = noise_dist
+        self.edm_params = edm_params
+        self.noise_dist_params = noise_dist_params
+        self.sampler_params = sampler_params
+        if self.num_numerical_features == 0:
+            self.sampler_params['stochastic_sampler'] = False
+            self.sampler_params['second_order_correction'] = False
+        
+        self.w_num = 0.0
+        self.w_cat = 0.0
+        self.num_mask_idx = []
+        self.cat_mask_idx = []
+        
+        self.device = device
+        
+        if self.scheduler == 'power_mean':
+            self.num_schedule = PowerMeanNoise(**noise_schedule_params)
+        elif self.scheduler == 'power_mean_per_column':
+            self.num_schedule = PowerMeanNoise_PerColumn(num_numerical = num_numerical_features, **noise_schedule_params)
+        else:
+            raise NotImplementedError(f"The noise schedule--{self.scheduler}-- is not implemented for contiuous data at CTIME ")
+        
+        if self.cat_scheduler == 'log_linear':
+            self.cat_schedule = LogLinearNoise(**noise_schedule_params)
+        elif self.cat_scheduler == 'log_linear_per_column':
+            self.cat_schedule = LogLinearNoise_PerColumn(num_categories = len(num_classes), **noise_schedule_params)
+        else:
+            raise NotImplementedError(f"The noise schedule--{self.cat_scheduler}-- is not implemented for discrete data at CTIME ")
+
+    def mixed_loss(self, x):
+        b = x.shape[0]
+        device = x.device
+
+        x_num = x[:, :self.num_numerical_features]
+        x_cat = x[:, self.num_numerical_features:].long()
+        # Sample noise level
+        if self.noise_dist == "uniform_t":
+            t = torch.rand(b, device=device, dtype=x_num.dtype)
+            t = t[:, None]
+            sigma_num = self.num_schedule.total_noise(t)
+            sigma_cat = self.cat_schedule.total_noise(t)
+            dsigma_cat = self.cat_schedule.rate_noise(t)
+        else:
+            sigma_num = self.sample_ctime_noise(x)       
+            t = self.num_schedule.inverse_to_t(sigma_num)
+            while torch.any((t < 0) + (t > 1)):     
+                # restrict t to [0,1]
+                # this iterative approach is equivalent to sampling from a truncated version of the orignal noise distribution
+                invalid_idx = ((t < 0) + (t > 1)).nonzero().squeeze(-1)
+                sigma_num[invalid_idx] = self.sample_ctime_noise(x[:len(invalid_idx)])
+                t = self.num_schedule.inverse_to_t(sigma_num)
+            assert not torch.any((t < 0) + (t > 1))
+            sigma_cat = self.cat_schedule.total_noise(t)
+        # Convert sigma_cat to the corresponding alpha and move_chance
+        alpha = torch.exp(-sigma_cat)
+        move_chance = -torch.expm1(-sigma_cat)      # torch.expm1 gives better numertical stability
+            
+        # Continuous forward diff
+        x_num_t = x_num
+        if x_num.shape[1] > 0:
+            noise = torch.randn_like(x_num)
+            x_num_t = x_num + noise * sigma_num
+        
+        # Discrete forward diff
+        x_cat_t = x_cat
+        x_cat_t_soft = x_cat # in the case where x_cat is empty, x_cat_t_soft will have the same shape as x_cat
+        if x_cat.shape[1] > 0:
+            is_learnable = self.cat_scheduler == 'log_linear_per_column'
+            strategy = 'soft'if is_learnable else 'hard'
+            x_cat_t, x_cat_t_soft = self.q_xt(x_cat, move_chance, strategy=strategy)
+
+        # Predict orignal data (distribution)
+        model_out_num, model_out_cat = self._denoise_fn(   
+            x_num_t, x_cat_t_soft,
+            t.squeeze(), sigma=sigma_num
+        )
+
+        d_loss = torch.zeros((1,)).float()
+        c_loss = torch.zeros((1,)).float()
+
+        if x_num.shape[1] > 0:
+            c_loss = self._edm_loss(model_out_num, x_num, sigma_num)
+        if x_cat.shape[1] > 0:
+            logits = self._subs_parameterization(model_out_cat, x_cat_t)    # log normalized probabilities, with the entry mask category being set to -inf
+            d_loss = self._absorbed_closs(logits, x_cat, sigma_cat, dsigma_cat)
+            
+        return d_loss.mean(), c_loss.mean()
+
+    @torch.no_grad()
+    def sample(self, num_samples):
+        b = num_samples
+        device = self.device
+        dtype = torch.float32
+        
+        # Create the chain of t
+        t = torch.linspace(0,1,self.num_timesteps, dtype=dtype, device=device)      # times = 0.0,...,1.0
+        t = t[:, None]
+        
+        # Compute the chains of sigma
+        sigma_num_cur = self.num_schedule.total_noise(t)
+        sigma_cat_cur = self.cat_schedule.total_noise(t)
+        sigma_num_next = torch.zeros_like(sigma_num_cur)
+        sigma_num_next[1:] = sigma_num_cur[0:-1]
+        sigma_cat_next = torch.zeros_like(sigma_cat_cur)
+        sigma_cat_next[1:] = sigma_cat_cur[0:-1]
+        
+        # Prepare sigma_hat for stochastic sampling mode
+        if self.sampler_params['stochastic_sampler']:
+            gamma = min(S_churn / self.num_timesteps, np.sqrt(2) - 1) * (S_min <= sigma_num_cur) * (sigma_num_cur <= S_max)
+            sigma_num_hat = sigma_num_cur + gamma * sigma_num_cur
+            t_hat = self.num_schedule.inverse_to_t(sigma_num_hat)
+            t_hat = torch.min(t_hat, dim=-1, keepdim=True).values    # take the samllest t_hat induced by sigma_num
+            zero_gamma = (gamma==0).any()
+            t_hat[zero_gamma] = t[zero_gamma]
+            out_of_bound = (t_hat > 1).squeeze()
+            sigma_num_hat[out_of_bound] = sigma_num_cur[out_of_bound]
+            t_hat[out_of_bound] = t[out_of_bound]
+            sigma_cat_hat = self.cat_schedule.total_noise(t_hat)
+        else:
+            t_hat = t
+            sigma_num_hat = sigma_num_cur
+            sigma_cat_hat = sigma_cat_cur
+                
+        # Sample priors for the continuous dimensions
+        z_norm = torch.randn((b, self.num_numerical_features), device=device) * sigma_num_cur[-1] 
+            
+        # Sample priors for the discrete dimensions
+        has_cat = len(self.num_classes) > 0
+        z_cat = torch.zeros((b, 0), device=device).float()      # the default values for categorical sample if the dataset has no categorical entry
+        if has_cat:
+            z_cat = self._sample_masked_prior(
+                b,
+                len(self.num_classes),
+            )
+        
+        pbar = tqdm(reversed(range(0, self.num_timesteps)), total=self.num_timesteps)
+        pbar.set_description(f"Sampling Progress")
+        for i in pbar:                  
+            z_norm, z_cat, q_xs = self.edm_update(
+                z_norm, z_cat, i, 
+                t[i], t[i-1] if i > 0 else None, t_hat[i],
+                sigma_num_cur[i], sigma_num_next[i], sigma_num_hat[i], 
+                sigma_cat_cur[i], sigma_cat_next[i], sigma_cat_hat[i],
+            )
+        
+        assert torch.all(z_cat < self.mask_index)
+        sample = torch.cat([z_norm, z_cat], dim=1).cpu()
+        return sample
+    
+    def sample_all(self, num_samples, batch_size, keep_nan_samples=False):        
+        b = batch_size
+
+        all_samples = []
+        num_generated = 0
+        while num_generated < num_samples:
+            print(f"Samples left to generate: {num_samples-num_generated}")
+            sample = self.sample(b)
+            mask_nan = torch.any(sample.isnan(), dim=1)
+            if keep_nan_samples:
+                # If the sample instances that contains Nan are decided to be kept, the row with Nan will be foreced to all zeros
+                sample = sample * (~mask_nan)[:, None]
+            else:
+                # Otherwise the instances with Nan will be eliminated
+                sample = sample[~mask_nan]
+
+            all_samples.append(sample)
+            num_generated += sample.shape[0]
+
+        x_gen = torch.cat(all_samples, dim=0)[:num_samples]
+
+        return x_gen
+    
+    def q_xt(self, x, move_chance, strategy='hard'):
+        """Computes the noisy sample xt.
+
+        Args:
+        x: int torch.Tensor with shape (batch_size,
+            diffusion_model_input_length), input. 
+        move_chance: float torch.Tensor with shape (batch_size, 1).
+        """
+        if strategy == 'hard':
+            move_indices = torch.rand(
+            * x.shape, device=x.device) < move_chance
+            xt = torch.where(move_indices, self.mask_index, x)
+            xt_soft = self.to_one_hot(xt).to(move_chance.dtype)
+            return xt, xt_soft
+        elif strategy == 'soft':
+            bs = x.shape[0]
+            xt_soft = torch.zeros(bs, torch.sum(self.mask_index+1), device=x.device)
+            xt = torch.zeros_like(x)
+            for i in range(len(self.num_classes)):
+                slice_i = self.slices_for_classes_with_mask[i]
+                # set the bernoulli probabilities, which determines the "coin flip" transition to the mask class
+                prob_i = torch.zeros(bs, 2, device=x.device)
+                prob_i[:,0] = 1-move_chance[:,i]
+                prob_i[:,-1] = move_chance[:,i]
+                log_prob_i = torch.log(prob_i)
+                # draw soft samples and place them back to the corresponding columns
+                soft_sample_i = F.gumbel_softmax(log_prob_i, tau=0.01, hard=True)
+                idx = torch.stack((x[:,i]+slice_i[0], torch.ones_like(x[:,i])*slice_i[-1]), dim=-1)
+                xt_soft[torch.arange(len(idx)).unsqueeze(1), idx] = soft_sample_i
+                # retrieve the hard samples
+                xt[:, i] = torch.where(soft_sample_i[:,1] > soft_sample_i[:,0], self.mask_index[i], x[:,i])
+            return xt, xt_soft
+    
+    
+    def _subs_parameterization(self, unormalized_prob, xt):
+        # log prob at the mask index = - infinity
+        unormalized_prob = self.pad(unormalized_prob, self.neg_infinity)
+        
+        unormalized_prob[:, range(unormalized_prob.shape[1]), self.mask_index] += self.neg_infinity
+        
+        # Take log softmax on the unnormalized probabilities to the logits
+        logits = unormalized_prob - torch.logsumexp(unormalized_prob, dim=-1,
+                                        keepdim=True)
+        # Apply updates directly in the logits matrix.
+        # For the logits of the unmasked tokens, set all values
+        # to -infinity except for the indices corresponding to
+        # the unmasked tokens.
+        unmasked_indices = (xt != self.mask_index)    # (bs, K)
+        logits[unmasked_indices] = self.neg_infinity 
+        logits[unmasked_indices, xt[unmasked_indices]] = 0
+        return logits
+    
+    def pad(self, x, pad_value):
+        """
+        Converts a concatenated tensor of class probabilities into a padded matrix, 
+        where each sub-tensor is padded along the last dimension to match the largest 
+        category size (max number of classes).
+
+        Args:
+            x (Tensor): The input tensor containing concatenated probabilities for all the categories in x_cat. 
+                        [bs, sum(num_classes_w_mask)]
+            pad_value (float): The value filled into the dummy entries, which are padded to ensure all sub-tensors have equal size 
+                            along the last dimension.
+
+        Returns:
+            Tensor: A new tensorwith
+                    [bs, len(num_classes_w_mask), max(num_classes_w_mask)), num_categories]
+        """
+        splited = torch.split(x, self.num_classes_w_mask, dim=-1)
+        max_K = max(self.num_classes_w_mask)
+        padded_ = [
+            torch.cat((
+                t, 
+                pad_value*torch.ones(*(t.shape[:-1]), max_K-t.shape[-1], dtype=t.dtype, device=t.device)
+            ), dim=-1) 
+        for t in splited]
+        out = torch.stack(padded_, dim=-2)
+        return out
+    
+    def to_one_hot(self, x_cat):
+        x_cat_oh = torch.cat(
+            [F.one_hot(x_cat[:, i], num_classes=self.num_classes[i]+1,) for i in range(len(self.num_classes))], 
+            dim=-1
+        )
+        return x_cat_oh
+    
+    def _absorbed_closs(self, model_output, x0, sigma, dsigma):
+        """
+            alpha: (bs,)
+        """
+        log_p_theta = torch.gather(
+            model_output, -1, x0[:, :, None]
+        ).squeeze(-1)
+        alpha = torch.exp(-sigma)
+        if self.cat_scheduler in ['log_linear_unified', 'log_linear_per_column']:
+            elbo_weight = - dsigma / torch.expm1(sigma)
+        else:
+            elbo_weight = -1/(1-alpha)
+        
+        loss = elbo_weight * log_p_theta
+        return loss
+    
+    def _sample_masked_prior(self, *batch_dims):
+        return self.mask_index[None,:] * torch.ones(    
+        * batch_dims, dtype=torch.int64, device=self.mask_index.device)
+        
+    def _mdlm_update(self, log_p_x0, x, alpha_t, alpha_s):
+        """
+            # t: (bs,)
+            log_p_x0: (bs, K, K_max)
+            # alpha_t: (bs,)
+            # alpha_s: (bs,)
+            alpha_t: (bs, 1/K_cat)
+            alpha_s: (bs,1/K_cat)
+        """
+        move_chance_t = 1 - alpha_t
+        move_chance_s = 1 - alpha_s     
+        move_chance_t = move_chance_t.unsqueeze(-1)
+        move_chance_s = move_chance_s.unsqueeze(-1)
+        assert move_chance_t.ndim == log_p_x0.ndim
+        # Technically, this isn't q_xs since there's a division
+        # term that is missing. This division term doesn't affect
+        # the samples.
+        # There is a noremalizing term is (1-\alpha_t) who's responsility is to ensure q_xs is normalized. 
+        # However, omiting it won't make a difference for the Gumbel-max sampling trick in  _sample_categorical()
+        q_xs = log_p_x0.exp() * (move_chance_t
+                                - move_chance_s)
+        q_xs[:, range(q_xs.shape[1]), self.mask_index] = move_chance_s[:, :, 0]
+        
+        # Important: make sure that prob of dummy classes are exactly 0
+        dummy_mask = torch.tensor([[(1 if i <= mask_idx else 0) for i in range(max(self.mask_index+1))] for mask_idx in self.mask_index], device=q_xs.device)
+        dummy_mask = torch.ones_like(q_xs) * dummy_mask
+        q_xs *= dummy_mask
+        
+        _x = self._sample_categorical(q_xs)
+
+        copy_flag = (x != self.mask_index).to(x.dtype)
+        
+        z_cat = copy_flag * x + (1 - copy_flag) * _x
+        return copy_flag * x + (1 - copy_flag) * _x, q_xs
+
+    def _sample_categorical(self, categorical_probs):
+        gumbel_norm = (
+            1e-10
+            - (torch.rand_like(categorical_probs) + 1e-10).log())
+        return (categorical_probs / gumbel_norm).argmax(dim=-1)
+    
+    def sample_ctime_noise(self, batch):
+        if self.noise_dist == 'log_norm':
+            rnd_normal = torch.randn(batch.shape[0], device=batch.device)
+            sigma = (rnd_normal * self.noise_dist_params['P_std'] + self.noise_dist_params['P_mean']).exp()
+        else:
+            raise NotImplementedError(f"The noise distribution--{self.noise_dist}-- is not implemented for CTIME ")
+        return sigma
+
+    def _edm_loss(self, D_yn, y, sigma):
+        weight = (sigma ** 2 + self.edm_params['sigma_data'] ** 2) / (sigma * self.edm_params['sigma_data']) ** 2
+    
+        target = y
+        loss = weight * ((D_yn - target) ** 2)
+
+        return loss
+    
+    def edm_update(
+            self, x_num_cur, x_cat_cur, i, 
+            t_cur, t_next, t_hat,
+            sigma_num_cur, sigma_num_next, sigma_num_hat, 
+            sigma_cat_cur, sigma_cat_next, sigma_cat_hat, 
+        ):
+        """
+        i = T-1,...,0
+        """
+        cfg = self.y_only_model is not None
+        
+        b = x_num_cur.shape[0]
+        has_cat = len(self.num_classes) > 0
+        
+        # Get x_num_hat by move towards the noise by a small step
+        x_num_hat = x_num_cur + (sigma_num_hat ** 2 - sigma_num_cur ** 2).sqrt() * S_noise * torch.randn_like(x_num_cur)
+        # Get x_cat_hat
+        move_chance = -torch.expm1(sigma_cat_cur - sigma_cat_hat)    # the incremental move change is 1 - alpha_t/alpha_s = 1 - exp(sigma_s - sigma_t)
+        x_cat_hat, _ = self.q_xt(x_cat_cur, move_chance) if has_cat else (x_cat_cur, x_cat_cur)
+
+        # Get predictions
+        x_cat_hat_oh = self.to_one_hot(x_cat_hat).to(x_num_hat.dtype) if has_cat else x_cat_hat
+        denoised, raw_logits = self._denoise_fn(
+            x_num_hat.float(), x_cat_hat_oh,
+            t_hat.squeeze().repeat(b), sigma=sigma_num_hat.unsqueeze(0).repeat(b,1)  # sigma accepts (bs, K_num)
+        )
+        
+        # Apply cfg updates, if is in cfg mode
+        is_bin_class = len(self.num_mask_idx) == 0
+        is_learnable = self.scheduler=="power_mean_per_column"
+        if cfg:
+            if not is_learnable:
+                sigma_cond = sigma_num_hat
+            else:
+                if is_bin_class:
+                    sigma_cond = (0.002 ** (1/7) + t_hat * (80 ** (1/7) - 0.002 ** (1/7))).pow(7)
+                else:
+                    sigma_cond = sigma_num_hat[self.num_mask_idx]
+            y_num_hat = x_num_hat.float()[:, self.num_mask_idx]
+            idx = list(chain(*[self.slices_for_classes_with_mask[i] for i in self.cat_mask_idx]))
+            y_cat_hat = x_cat_hat_oh[:,idx]
+            y_only_denoised, y_only_raw_logits = self.y_only_model(
+                y_num_hat, 
+                y_cat_hat,
+                t_hat.squeeze().repeat(b), sigma=sigma_cond.unsqueeze(0).repeat(b,1)  # sigma accepts (bs, K_num)
+            )
+            
+            denoised[:, self.num_mask_idx] *= 1 + self.w_num
+            denoised[:, self.num_mask_idx] -= self.w_num*y_only_denoised
+            
+            mask_logit_idx = [self.slices_for_classes_with_mask[i] for i in self.cat_mask_idx]
+            mask_logit_idx = np.concatenate(mask_logit_idx) if len(mask_logit_idx)>0 else np.array([])
+            
+            raw_logits[:, mask_logit_idx] *= 1 + self.w_cat
+            raw_logits[:, mask_logit_idx] -= self.w_cat*y_only_raw_logits
+        
+        # Euler step
+        d_cur = (x_num_hat - denoised) / sigma_num_hat
+        x_num_next = x_num_hat + (sigma_num_next - sigma_num_hat) * d_cur
+        
+        # Unmasking
+        x_cat_next = x_cat_cur
+        q_xs = torch.zeros_like(x_cat_cur).float()
+        if has_cat:
+            logits = self._subs_parameterization(raw_logits, x_cat_hat)
+            alpha_t = torch.exp(-sigma_cat_hat).unsqueeze(0).repeat(b,1)
+            alpha_s = torch.exp(-sigma_cat_next).unsqueeze(0).repeat(b,1)
+            x_cat_next, q_xs = self._mdlm_update(logits, x_cat_hat, alpha_t, alpha_s)
+        
+        # Apply 2nd order correction.
+        if self.sampler_params['second_order_correction']:
+            if i > 0:
+                x_cat_hat_oh = self.to_one_hot(x_cat_hat).to(x_num_next.dtype) if has_cat else x_cat_hat
+                denoised, raw_logits = self._denoise_fn(
+                    x_num_next.float(), x_cat_hat_oh,
+                    t_next.squeeze().repeat(b), sigma=sigma_num_next.unsqueeze(0).repeat(b,1)
+                )
+                if cfg:
+                    if not is_learnable:
+                        sigma_cond = sigma_num_next
+                    else:
+                        if is_bin_class:
+                            sigma_cond = (0.002 ** (1/7) + t_next * (80 ** (1/7) - 0.002 ** (1/7))).pow(7)
+                        else:
+                            sigma_cond = sigma_num_next[self.num_mask_idx]
+                    y_num_next = x_num_next.float()[:, self.num_mask_idx]
+                    idx = list(chain(*[self.slices_for_classes_with_mask[i] for i in self.cat_mask_idx]))
+                    y_cat_hat = x_cat_hat_oh[:, idx]
+                    y_only_denoised, y_only_raw_logits = self.y_only_model(
+                        y_num_next,
+                        y_cat_hat,
+                        t_next.squeeze().repeat(b), sigma=sigma_cond.unsqueeze(0).repeat(b,1)  # sigma accepts (bs, K_num)
+                    )
+                    denoised[:, self.num_mask_idx] *= 1 + self.w_num
+                    denoised[:, self.num_mask_idx] -= self.w_num*y_only_denoised
+                
+                d_prime = (x_num_next - denoised) / sigma_num_next
+                x_num_next = x_num_hat + (sigma_num_next - sigma_num_hat) * (0.5 * d_cur + 0.5 * d_prime)
+        
+        return x_num_next, x_cat_next, q_xs
+
+
+    def sample_impute(self, x_num, x_cat, num_mask_idx, cat_mask_idx, resample_rounds, impute_condition, w_num, w_cat):
+        self.w_num = w_num
+        self.w_cat = w_cat
+        self.num_mask_idx = num_mask_idx
+        self.cat_mask_idx = cat_mask_idx
+        
+        b = x_num.size(0)
+        device = self.device
+        dtype = torch.float32
+
+        # Create masks, true for the missing columns
+        num_mask = [i in num_mask_idx for i in range(self.num_numerical_features)]
+        cat_mask = [i in cat_mask_idx for i in range(len(self.num_classes))]
+        num_mask = torch.tensor(num_mask).to(x_num.device).to(x_num.dtype)
+        cat_mask = torch.tensor(cat_mask).to(x_cat.device).to(x_cat.dtype)
+
+        # Create the chain of t
+        t = torch.linspace(0,1,self.num_timesteps, dtype=dtype, device=device)      # times = 0.0,...,1.0
+        t = t[:, None]
+        
+        # Compute the chains of sigma
+        sigma_num_cur = self.num_schedule.total_noise(t)
+        sigma_cat_cur = self.cat_schedule.total_noise(t)
+        sigma_num_next = torch.zeros_like(sigma_num_cur)
+        sigma_num_next[1:] = sigma_num_cur[0:-1]
+        sigma_cat_next = torch.zeros_like(sigma_cat_cur)
+        sigma_cat_next[1:] = sigma_cat_cur[0:-1]
+        
+        # Prepare sigma_hat for stochastic sampling mode
+        if self.sampler_params['stochastic_sampler']:
+            gamma = min(S_churn / self.num_timesteps, np.sqrt(2) - 1) * (S_min <= sigma_num_cur) * (sigma_num_cur <= S_max)
+            sigma_num_hat = sigma_num_cur + gamma * sigma_num_cur
+            t_hat = self.num_schedule.inverse_to_t(sigma_num_hat)
+            t_hat = torch.min(t_hat, dim=-1, keepdim=True).values    # take the samllest t_hat induced by sigma_num
+            zero_gamma = (gamma==0).any()
+            t_hat[zero_gamma] = t[zero_gamma]
+            out_of_bound = (t_hat > 1).squeeze()
+            sigma_num_hat[out_of_bound] = sigma_num_cur[out_of_bound]
+            t_hat[out_of_bound] = t[out_of_bound]
+            sigma_cat_hat = self.cat_schedule.total_noise(t_hat)
+        else:
+            t_hat = t
+            sigma_num_hat = sigma_num_cur
+            sigma_cat_hat = sigma_cat_cur
+
+        # Sample priors for the continuous dimensions
+        if impute_condition == "x_t":
+            z_norm = x_num + torch.randn((b, self.num_numerical_features), device=device) * sigma_num_cur[-1]   # z_{t_max} = x_0(masked) + sigma_max*epsilon
+        elif impute_condition == "x_0":
+            z_norm = x_num
+            
+        # Sample priors for the discrete dimensions
+        has_cat = len(self.num_classes) > 0
+        z_cat = torch.zeros((b, 0), device=device).float()      # the default values for categorical sample if the dataset has no categorical entry
+        if has_cat:
+            if impute_condition == "x_t":
+                z_cat = self._sample_masked_prior(
+                    b,
+                    len(self.num_classes),
+                )   # z_{t_max} is still all pushed to [MASK]
+            elif impute_condition == "x_0":
+                z_cat = x_cat
+        
+        pbar = tqdm(reversed(range(0, self.num_timesteps)), total=self.num_timesteps)
+        pbar.set_description(f"Sampling Progress")
+        for i in pbar:
+            for u in range (resample_rounds):
+                # Get known parts by Forward Flow
+                if impute_condition == "x_t":
+                    z_norm_known = x_num + torch.randn((b, self.num_numerical_features), device=device) * sigma_num_next[i]
+                    move_chance = 1 - torch.exp(-sigma_cat_next[i]) if i < (self.num_timesteps-1) else torch.ones_like(sigma_cat_next[i])     # force move_chance to be 1 for the first iteration
+                    z_cat_known, _ = self.q_xt(x_cat, move_chance)
+                elif impute_condition == "x_0":
+                    z_norm_known = x_num
+                    z_cat_known = x_cat
+                
+                # Get unknown by Reverse Step
+                z_norm_unknown, z_cat_unknown, q_xs = self.edm_update(
+                    z_norm, z_cat, i, 
+                    t[i], t[i-1] if i > 0 else None, t_hat[i],
+                    sigma_num_cur[i], sigma_num_next[i], sigma_num_hat[i], 
+                    sigma_cat_cur[i], sigma_cat_next[i], sigma_cat_hat[i],
+                )
+                z_norm = (1 - num_mask)  * z_norm_known + num_mask * z_norm_unknown
+                z_cat = (1 - cat_mask) * z_cat_known + cat_mask * z_cat_unknown
+
+                # Resample x_t from x_{t-1} by Foward Step
+                if u < resample_rounds-1:
+                    z_norm = z_norm + (sigma_num_cur[i] ** 2 - sigma_num_next[i] ** 2).sqrt() * S_noise * torch.randn_like(z_norm)
+                    move_chance = -torch.expm1(sigma_cat_next[i] - sigma_cat_cur[i])
+                    z_cat, _ = self.q_xt(z_cat, move_chance)
+        
+        sample = torch.cat([z_norm, z_cat], dim=1).cpu()
+        return sample
+    

SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/_tabdiff_runtime/tabdiff/modules/main_modules.py

@@ -0,0 +1,167 @@
+from typing import Callable, Union
+
+from tabdiff.modules.transformer import Reconstructor, Tokenizer, Transformer
+import torch
+import torch.nn as nn
+import torch.optim
+
+ModuleType = Union[str, Callable[..., nn.Module]]
+
+class SiLU(nn.Module):
+    def forward(self, x):
+        return x * torch.sigmoid(x)
+
+class PositionalEmbedding(torch.nn.Module):
+    def __init__(self, num_channels, max_positions=10000, endpoint=False):
+        super().__init__()
+        self.num_channels = num_channels
+        self.max_positions = max_positions
+        self.endpoint = endpoint
+
+    def forward(self, x):
+        freqs = torch.arange(start=0, end=self.num_channels//2, dtype=torch.float32, device=x.device)
+        freqs = freqs / (self.num_channels // 2 - (1 if self.endpoint else 0))
+        freqs = (1 / self.max_positions) ** freqs
+        x = x.ger(freqs.to(x.dtype))
+        x = torch.cat([x.cos(), x.sin()], dim=1)
+        return x
+
+
+class MLPDiffusion(nn.Module):
+    def __init__(self, d_in, dim_t = 512, use_mlp=True):
+        super().__init__()
+        self.dim_t = dim_t
+
+        self.proj = nn.Linear(d_in, dim_t)
+
+        self.mlp = nn.Sequential(
+            nn.Linear(dim_t, dim_t * 2),
+            nn.SiLU(),
+            nn.Linear(dim_t * 2, dim_t * 2),
+            nn.SiLU(),
+            nn.Linear(dim_t * 2, dim_t),
+            nn.SiLU(),
+            nn.Linear(dim_t, d_in),
+        ) if use_mlp else nn.Linear(dim_t, d_in)
+
+        self.map_noise = PositionalEmbedding(num_channels=dim_t)
+        self.time_embed = nn.Sequential(
+            nn.Linear(dim_t, dim_t),
+            nn.SiLU(),
+            nn.Linear(dim_t, dim_t)
+        )
+        
+        self.use_mlp = use_mlp
+    
+    def forward(self, x, timesteps):
+        emb = self.map_noise(timesteps)
+        emb = emb.reshape(emb.shape[0], 2, -1).flip(1).reshape(*emb.shape) # swap sin/cos
+        emb = self.time_embed(emb)
+    
+        x = self.proj(x) + emb
+        return self.mlp(x)
+    
+class UniModMLP(nn.Module):
+    """
+        Input:
+            x_num: [bs, d_numerical]
+            x_cat: [bs, len(categories)]
+        Output:
+            x_num_pred: [bs, d_numerical], the predicted mean for numerical data
+            x_cat_pred: [bs, sum(categories)], the predicted UNORMALIZED logits for categorical data
+    """
+    def __init__(
+            self, d_numerical, categories, num_layers, d_token,
+            n_head = 1, factor = 4, bias = True, dim_t=512, use_mlp=True, **kwargs
+        ):
+        super().__init__()
+        self.d_numerical = d_numerical
+        self.categories = categories
+
+        self.tokenizer = Tokenizer(d_numerical, categories, d_token, bias = bias)
+        self.encoder = Transformer(num_layers, d_token, n_head, d_token, factor)
+        d_in = d_token * (d_numerical + len(categories))
+        self.mlp = MLPDiffusion(d_in, dim_t=dim_t, use_mlp=use_mlp)
+        self.decoder = Transformer(num_layers, d_token, n_head, d_token, factor)
+        self.detokenizer = Reconstructor(d_numerical, categories, d_token)
+        
+        self.model = nn.ModuleList([self.tokenizer, self.encoder, self.mlp, self.decoder, self.detokenizer])
+
+    def forward(self, x_num, x_cat, timesteps):
+        e = self.tokenizer(x_num, x_cat)
+        decoder_input = e[:, 1:, :]        # ignore the first CLS token. 
+        y = self.encoder(decoder_input)
+        pred_y = self.mlp(y.reshape(y.shape[0], -1), timesteps)
+        pred_e = self.decoder(pred_y.reshape(*y.shape))
+        x_num_pred, x_cat_pred = self.detokenizer(pred_e)
+        x_cat_pred = torch.cat(x_cat_pred, dim=-1) if len(x_cat_pred)>0 else torch.zeros_like(x_cat).to(x_num_pred.dtype)
+
+        return x_num_pred, x_cat_pred
+
+
+class Precond(nn.Module):
+    def __init__(self,
+        denoise_fn,
+        sigma_data = 0.5,              # Expected standard deviation of the training data.
+        net_conditioning = "sigma",
+    ):
+        super().__init__()
+        self.sigma_data = sigma_data
+        self.net_conditioning = net_conditioning
+        self.denoise_fn_F = denoise_fn
+
+    def forward(self, x_num, x_cat, t, sigma):
+
+        x_num = x_num.to(torch.float32)
+
+        sigma = sigma.to(torch.float32)
+        assert sigma.ndim == 2
+        if sigma.dim() > 1: # if learnable column-wise noise schedule, sigma conditioning is set to the defaults schedule of rho=7
+            sigma_cond = (0.002 ** (1/7) + t * (80 ** (1/7) - 0.002 ** (1/7))).pow(7)
+        else:
+            sigma_cond = sigma 
+        dtype = torch.float32
+
+        c_skip = self.sigma_data ** 2 / (sigma ** 2 + self.sigma_data ** 2)
+        c_out = sigma * self.sigma_data / (sigma ** 2 + self.sigma_data ** 2).sqrt()
+        c_in = 1 / (self.sigma_data ** 2 + sigma ** 2).sqrt()
+        c_noise = sigma_cond.log() / 4
+
+        x_in = c_in * x_num
+        if self.net_conditioning == "sigma":
+            F_x, x_cat_pred = self.denoise_fn_F(x_in, x_cat, c_noise.flatten())
+        elif self.net_conditioning == "t":
+            F_x, x_cat_pred = self.denoise_fn_F(x_in, x_cat, t)
+
+        assert F_x.dtype == dtype
+        D_x = c_skip * x_num + c_out * F_x.to(torch.float32)
+        
+        return D_x, x_cat_pred
+    
+
+class Model(nn.Module):
+    def __init__(
+            self, denoise_fn,
+            sigma_data=0.5, 
+            precond=False, 
+            net_conditioning="sigma",
+            **kwargs
+        ):
+        super().__init__()
+        self.precond = precond
+        if precond:
+            self.denoise_fn_D = Precond(
+                denoise_fn,
+                sigma_data=sigma_data,
+                net_conditioning=net_conditioning
+            )
+        else:
+            self.denoise_fn_D = denoise_fn
+
+    def forward(self, x_num, x_cat, t, sigma=None):
+        if self.precond:
+            return self.denoise_fn_D(x_num, x_cat, t, sigma)
+        else:
+            return self.denoise_fn_D(x_num, x_cat, t)
+
+

SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/_tabdiff_runtime/tabdiff/modules/transformer.py

@@ -0,0 +1,258 @@
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.init as nn_init
+import torch.nn.functional as F
+from torch import Tensor
+
+import math
+
+class Tokenizer(nn.Module):
+
+    def __init__(self, d_numerical, categories, d_token, bias):
+        super().__init__()
+        if categories is None:
+            d_bias = d_numerical
+            self.category_offsets = None
+            self.category_embeddings = None
+        else:
+            d_bias = d_numerical + len(categories)
+            category_offsets = torch.tensor([0] + list(categories[:-1])).cumsum(0)
+            self.register_buffer('category_offsets', category_offsets)
+            self.cat_weight = nn.Parameter(Tensor(sum(categories), d_token))
+            nn.init.kaiming_uniform_(self.cat_weight, a=math.sqrt(5))
+
+        # take [CLS] token into account
+        self.weight = nn.Parameter(Tensor(d_numerical + 1, d_token))
+        self.bias = nn.Parameter(Tensor(d_bias, d_token)) if bias else None
+        # The initialization is inspired by nn.Linear
+        nn_init.kaiming_uniform_(self.weight, a=math.sqrt(5))
+        if self.bias is not None:
+            nn_init.kaiming_uniform_(self.bias, a=math.sqrt(5))
+
+    @property
+    def n_tokens(self):
+        return len(self.weight) + (
+            0 if self.category_offsets is None else len(self.category_offsets)
+        )
+
+    def forward(self, x_num, x_cat):
+        x_some = x_num if x_cat is None else x_cat
+        assert x_some is not None
+        x_num = torch.cat(
+            [torch.ones(len(x_some), 1, device=x_some.device)]  # [CLS]
+            + ([] if x_num is None else [x_num]),
+            dim=1,
+        )
+    
+        x = self.weight[None] * x_num[:, :, None]
+
+        if x_cat is not None:
+            for start, end in zip(self.category_offsets, torch.cat([self.category_offsets[1:], torch.tensor([x_cat.shape[1]], device=x_cat.device)])):
+                if start < end:
+                    x = torch.cat(
+                        [x, x_cat[:, start:end].unsqueeze(1) @ self.cat_weight[start:end][None]],
+                        dim=1,
+                    )
+        if self.bias is not None:
+            bias = torch.cat(
+                [
+                    torch.zeros(1, self.bias.shape[1], device=x.device),
+                    self.bias,
+                ]
+            )
+            x = x + bias[None]
+
+        return x
+
+
+class MultiheadAttention(nn.Module):
+    def __init__(self, d, n_heads, dropout, initialization = 'kaiming'):
+
+        if n_heads > 1:
+            assert d % n_heads == 0
+        assert initialization in ['xavier', 'kaiming']
+
+        super().__init__()
+        self.W_q = nn.Linear(d, d)
+        self.W_k = nn.Linear(d, d)
+        self.W_v = nn.Linear(d, d)
+        self.W_out = nn.Linear(d, d) if n_heads > 1 else None
+        self.n_heads = n_heads
+        self.dropout = nn.Dropout(dropout) if dropout else None
+
+        for m in [self.W_q, self.W_k, self.W_v]:
+            if initialization == 'xavier' and (n_heads > 1 or m is not self.W_v):
+                # gain is needed since W_qkv is represented with 3 separate layers
+                nn_init.xavier_uniform_(m.weight, gain=1 / math.sqrt(2))
+            nn_init.zeros_(m.bias)
+        if self.W_out is not None:
+            nn_init.zeros_(self.W_out.bias)
+
+    def _reshape(self, x):
+        batch_size, n_tokens, d = x.shape
+        d_head = d // self.n_heads
+        return (
+            x.reshape(batch_size, n_tokens, self.n_heads, d_head)
+            .transpose(1, 2)
+            .reshape(batch_size * self.n_heads, n_tokens, d_head)
+        )
+
+    def forward(self, x_q, x_kv, key_compression = None, value_compression = None):
+  
+        q, k, v = self.W_q(x_q), self.W_k(x_kv), self.W_v(x_kv)
+        for tensor in [q, k, v]:
+            assert tensor.shape[-1] % self.n_heads == 0
+        if key_compression is not None:
+            assert value_compression is not None
+            k = key_compression(k.transpose(1, 2)).transpose(1, 2)
+            v = value_compression(v.transpose(1, 2)).transpose(1, 2)
+        else:
+            assert value_compression is None
+
+        batch_size = len(q)
+        d_head_key = k.shape[-1] // self.n_heads
+        d_head_value = v.shape[-1] // self.n_heads
+        n_q_tokens = q.shape[1]
+
+        q = self._reshape(q)
+        k = self._reshape(k)
+
+        a = q @ k.transpose(1, 2)
+        b = math.sqrt(d_head_key)
+        attention = F.softmax(a/b , dim=-1)
+
+        
+        if self.dropout is not None:
+            attention = self.dropout(attention)
+        x = attention @ self._reshape(v)
+        x = (
+            x.reshape(batch_size, self.n_heads, n_q_tokens, d_head_value)
+            .transpose(1, 2)
+            .reshape(batch_size, n_q_tokens, self.n_heads * d_head_value)
+        )
+        if self.W_out is not None:
+            x = self.W_out(x)
+
+        return x
+        
+class Transformer(nn.Module):
+
+    def __init__(
+        self,
+        n_layers: int,
+        d_token: int,
+        n_heads: int,
+        d_out: int,
+        d_ffn_factor: int,
+        attention_dropout = 0.0,
+        ffn_dropout = 0.0,
+        residual_dropout = 0.0,
+        activation = 'relu',
+        prenormalization = True,
+        initialization = 'kaiming',      
+    ):
+        super().__init__()
+
+        def make_normalization():
+            return nn.LayerNorm(d_token)
+
+        d_hidden = int(d_token * d_ffn_factor)
+        self.layers = nn.ModuleList([])
+        for layer_idx in range(n_layers):
+            layer = nn.ModuleDict(
+                {
+                    'attention': MultiheadAttention(
+                        d_token, n_heads, attention_dropout, initialization
+                    ),
+                    'linear0': nn.Linear(
+                        d_token, d_hidden
+                    ),
+                    'linear1': nn.Linear(d_hidden, d_token),
+                    'norm1': make_normalization(),
+                }
+            )
+            if not prenormalization or layer_idx:
+                layer['norm0'] = make_normalization()
+   
+            self.layers.append(layer)
+
+        self.activation = nn.ReLU()
+        self.last_activation = nn.ReLU()
+        # self.activation = lib.get_activation_fn(activation)
+        # self.last_activation = lib.get_nonglu_activation_fn(activation)
+        self.prenormalization = prenormalization
+        self.last_normalization = make_normalization() if prenormalization else None
+        self.ffn_dropout = ffn_dropout
+        self.residual_dropout = residual_dropout
+        self.head = nn.Linear(d_token, d_out)
+
+
+    def _start_residual(self, x, layer, norm_idx):
+        x_residual = x
+        if self.prenormalization:
+            norm_key = f'norm{norm_idx}'
+            if norm_key in layer:
+                x_residual = layer[norm_key](x_residual)
+        return x_residual
+
+    def _end_residual(self, x, x_residual, layer, norm_idx):
+        if self.residual_dropout:
+            x_residual = F.dropout(x_residual, self.residual_dropout, self.training)
+        x = x + x_residual
+        if not self.prenormalization:
+            x = layer[f'norm{norm_idx}'](x)
+        return x
+
+    def forward(self, x):
+        for layer_idx, layer in enumerate(self.layers):
+            is_last_layer = layer_idx + 1 == len(self.layers)
+
+            x_residual = self._start_residual(x, layer, 0)
+            x_residual = layer['attention'](
+                # for the last attention, it is enough to process only [CLS]
+                x_residual,
+                x_residual,
+            )
+
+            x = self._end_residual(x, x_residual, layer, 0)
+
+            x_residual = self._start_residual(x, layer, 1)
+            x_residual = layer['linear0'](x_residual)
+            x_residual = self.activation(x_residual)
+            if self.ffn_dropout:
+                x_residual = F.dropout(x_residual, self.ffn_dropout, self.training)
+            x_residual = layer['linear1'](x_residual)
+            x = self._end_residual(x, x_residual, layer, 1)
+        return x
+
+
+class Reconstructor(nn.Module):
+    def __init__(self, d_numerical, categories, d_token):
+        super(Reconstructor, self).__init__()
+
+        self.d_numerical = d_numerical
+        self.categories = categories
+        self.d_token = d_token
+        
+        self.weight = nn.Parameter(Tensor(d_numerical, d_token))  
+        nn.init.xavier_uniform_(self.weight, gain=1 / math.sqrt(2))
+        self.cat_recons = nn.ModuleList()
+
+        for d in categories:
+            recon = nn.Linear(d_token, d)
+            nn.init.xavier_uniform_(recon.weight, gain=1 / math.sqrt(2))
+            self.cat_recons.append(recon)
+
+    def forward(self, h):
+        h_num  = h[:, :self.d_numerical]
+        h_cat  = h[:, self.d_numerical:]
+
+        recon_x_num = torch.mul(h_num, self.weight.unsqueeze(0)).sum(-1)
+        recon_x_cat = []
+
+        for i, recon in enumerate(self.cat_recons):
+      
+            recon_x_cat.append(recon(h_cat[:, i]))
+
+        return recon_x_num, recon_x_cat

SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/_tabdiff_runtime/tabdiff/trainer.py

@@ -0,0 +1,657 @@
+import os
+import glob
+import time
+import torch
+from torch.optim.lr_scheduler import ReduceLROnPlateau
+import numpy as np
+import pandas as pd
+import json
+
+from copy import deepcopy
+
+from utils_train import update_ema
+
+from tqdm import tqdm
+
+BAR = "=============="
+def print_with_bar(log_msg):
+    log_msg = BAR + log_msg + BAR
+    if "End" in log_msg:
+         log_msg += "\n"
+    print(log_msg)
+
+class Trainer:
+    def __init__(
+            self, diffusion, train_iter, dataset, test_dataset,  metrics, logger, 
+            lr, weight_decay,
+            steps, batch_size, check_val_every,
+            sample_batch_size, model_save_path, result_save_path,
+            num_samples_to_generate=None,
+            lr_scheduler='reduce_lr_on_plateau',
+            reduce_lr_patience=100, factor=0.9, 
+            ema_decay=0.997,
+            closs_weight_schedule = "fixed",
+            c_lambda = 1.0,
+            d_lambda = 1.0,
+            device=torch.device('cuda:1'),
+            ckpt_path = None,
+            y_only=False,
+            **kwargs
+    ):
+        self.y_only = y_only
+        self.diffusion = diffusion
+        self.ema_model = deepcopy(self.diffusion._denoise_fn)
+        for param in self.ema_model.parameters():
+            param.detach_()
+        self.ema_num_schedule = deepcopy(self.diffusion.num_schedule)
+        for param in self.ema_num_schedule.parameters():
+            param.detach_()
+        self.ema_cat_schedule = deepcopy(self.diffusion.cat_schedule)
+        for param in self.ema_cat_schedule.parameters():
+            param.detach_()
+
+        self.train_iter = train_iter
+        self.dataset = dataset
+        self.test_dataset = test_dataset
+        self.steps = steps
+        self.init_lr = lr
+        self.optimizer = torch.optim.AdamW(self.diffusion.parameters(), lr=lr, weight_decay=weight_decay)
+        self.ema_decay = ema_decay
+        self.lr_scheduler = lr_scheduler
+        # PyTorch >= 2.8: ReduceLROnPlateau no longer accepts `verbose=`
+        self.scheduler = ReduceLROnPlateau(
+            self.optimizer, mode="min", factor=factor, patience=reduce_lr_patience
+        )
+        self.closs_weight_schedule = closs_weight_schedule
+        self.c_lambda = c_lambda
+        self.d_lambda = d_lambda
+
+        self.batch_size = batch_size
+        self.sample_batch_size = sample_batch_size
+        self.num_samples_to_generate = num_samples_to_generate
+        self.metrics = metrics
+        self.logger = logger
+        self.check_val_every = check_val_every
+        
+        self.device = device
+        self.model_save_path = model_save_path
+        self.result_save_path = result_save_path
+        self.ckpt_path = ckpt_path
+        if self.ckpt_path is not None:
+            state_dicts = torch.load(self.ckpt_path, map_location=self.device)
+            self.diffusion._denoise_fn.load_state_dict(state_dicts['denoise_fn'])
+            self.diffusion.num_schedule.load_state_dict(state_dicts['num_schedule'])
+            self.diffusion.cat_schedule.load_state_dict(state_dicts['cat_schedule'])   
+            print(f"Weights are loaded from {self.ckpt_path}")     
+        
+        self.curr_epoch = int(os.path.basename(self.ckpt_path).split('_')[-1].split('.')[0]) if self.ckpt_path is not None else 0
+
+    def _anneal_lr(self, step):
+        frac_done = step / self.steps
+        lr = self.init_lr * (1 - frac_done)
+        for param_group in self.optimizer.param_groups:
+            param_group["lr"] = lr
+
+    def _run_step(self, x, closs_weight, dloss_weight):
+        x = x.to(self.device)
+        
+        self.diffusion.train()
+
+        self.optimizer.zero_grad()
+
+        dloss, closs = self.diffusion.mixed_loss(x)
+
+        loss = dloss_weight * dloss + closs_weight * closs
+        loss.backward()
+        self.optimizer.step()
+
+        return dloss, closs
+    
+    def compute_loss(self):      # eval loss is not weighted
+        curr_dloss = 0.0
+        curr_closs = 0.0
+        curr_count = 0
+        data_iter = self.train_iter
+        for batch in data_iter:
+            x = batch.float().to(self.device)
+            self.diffusion.eval()
+            with torch.no_grad():
+                batch_dloss, batch_closs = self.diffusion.mixed_loss(x)
+            curr_dloss += batch_dloss.item() * len(x)
+            curr_closs += batch_closs.item() * len(x)
+            curr_count += len(x)
+        mloss = np.around(curr_dloss / curr_count, 4)
+        gloss = np.around(curr_closs / curr_count, 4)
+        return mloss, gloss
+    
+    def run_loop(self):
+        patience = 0
+        closs_weight, dloss_weight = self.c_lambda, self.d_lambda
+        best_loss = np.inf
+        best_ema_loss = np.inf
+        best_val_loss = np.inf
+        start_time = time.time()
+        print_with_bar(f"Starting Trainin Loop, total number of epoch = {self.steps}")
+        # Set up wandb's step metric
+        self.logger.define_metric("epoch")
+        self.logger.define_metric("*", step_metric="epoch")
+        
+        start_epoch = self.curr_epoch
+        if start_epoch > 0:
+            print_with_bar(f"Resuming training from epoch {start_epoch}, with validation check every {self.check_val_every} epoches")
+        for epoch in range (start_epoch, self.steps):
+            self.curr_epoch = epoch+1
+            # Set up pbar
+            pbar = tqdm(self.train_iter, total=len(self.train_iter))
+            pbar.set_description(f"Epoch {epoch+1}/{self.steps}")
+            
+            # Compute the loss weights
+            if self.closs_weight_schedule == "fixed":
+                pass
+            elif self.closs_weight_schedule == "anneal":
+                frac_done = epoch / self.steps
+                closs_weight = self.c_lambda * (1 - frac_done)
+            else:
+                raise NotImplementedError(f"The continuous loss weight schedule {self.closs_weight_schedule} is not implemneted")
+
+            # Training Step
+            curr_dloss = 0.0
+            curr_closs = 0.0
+            curr_count = 0
+            curr_lr = self.optimizer.param_groups[0]['lr']
+            for batch in pbar:
+                x = batch.float().to(self.device)
+                batch_dloss, batch_closs = self._run_step(x, closs_weight, dloss_weight)
+                curr_dloss += batch_dloss.item() * len(x)
+                curr_closs += batch_closs.item() * len(x)
+                curr_count += len(x)
+                pbar.set_postfix({
+                    "lr": curr_lr,
+                    "DLoss": np.around(curr_dloss/curr_count, 4),
+                    "CLoss": np.around(curr_closs/curr_count, 4),
+                    "TotalLoss": np.around((curr_dloss + curr_closs)/curr_count, 4),
+                    "closs_weight": closs_weight,
+                    "dloss_weight": dloss_weight,
+                })
+                
+            # Log training Loss
+            log_dict = {}
+            mloss = np.around(curr_dloss / curr_count, 4)
+            gloss = np.around(curr_closs / curr_count, 4)
+            total_loss = mloss + gloss
+            if np.isnan(gloss):
+                    print('Finding Nan in gaussian loss')
+                    break
+            loss_dict = {
+                "epoch": epoch + 1,
+                "lr": curr_lr,
+                "closs_weight": closs_weight,
+                "dloss_weight": dloss_weight,
+                "loss/c_loss": gloss,
+                "loss/d_loss": mloss,
+                "loss/total_loss": total_loss
+            }
+            log_dict.update(loss_dict)
+            
+            # Log the learned noise schedules for numerical dimensions
+            if self.dataset.d_numerical > 0:    # numerical data is not empty
+                num_noise_dict = {}
+                if self.diffusion.num_schedule.rho().dim() == 0:   # non-learnable num schedule
+                    num_noise_dict = {"num_noise/rho": self.diffusion.num_schedule.rho().item()}
+                else:
+                    num_noise_dict = {f"num_noise/rho_col_{i}": value.item() for i, value in enumerate(self.diffusion.num_schedule.rho())}
+                log_dict.update(num_noise_dict)            
+
+            # Log the learned noise schedules for categlrical dimensions
+            if len(self.dataset.categories) > 0:    # categorical data is not empty
+                cat_noise_dict = {}
+                if self.diffusion.cat_schedule.k().dim() == 0:   # non-learnable cat schedule
+                    cat_noise_dict = {"cat_noise/k": self.diffusion.cat_schedule.k().item()}
+                else:
+                    cat_noise_dict = {f"cat_noise/k_col_{i}": value.item() for i, value in enumerate(self.diffusion.cat_schedule.k())}
+                log_dict.update(cat_noise_dict)
+            
+            # Adjust learning rate
+            if self.lr_scheduler == 'reduce_lr_on_plateau':
+                self.scheduler.step(total_loss)
+            elif  self.lr_scheduler == 'anneal':
+                self._anneal_lr(epoch)
+            elif self.lr_scheduler == 'fixed':
+                pass
+            else:
+                raise NotImplementedError(f"LR scheduler with name '{self.lr_scheduler}' is not implemented")
+            
+            # Update EMA models
+            update_ema(self.ema_model.parameters(), self.diffusion._denoise_fn.parameters(), rate=self.ema_decay)
+            update_ema(self.ema_num_schedule.parameters(), self.diffusion.num_schedule.parameters(), rate=self.ema_decay)
+            update_ema(self.ema_cat_schedule.parameters(), self.diffusion.cat_schedule.parameters(), rate=self.ema_decay)
+
+            # Save ckpt base on the best training loss
+            if total_loss < best_loss and self.curr_epoch > 4000:
+                best_loss = total_loss
+                to_remove = glob.glob(os.path.join(self.model_save_path, f"best_model_*"))
+                if to_remove:
+                    os.remove(to_remove[0])
+                state_dicts = {
+                    'denoise_fn': self.diffusion._denoise_fn.state_dict(), 
+                    'num_schedule':self.diffusion.num_schedule.state_dict(), 
+                    'cat_schedule': self.diffusion.cat_schedule.state_dict(),
+                }
+                torch.save(state_dicts, os.path.join(self.model_save_path, f'best_model_{np.round(total_loss,4)}_{epoch+1}.pt'))
+                patience = 0
+            else:
+                patience += 1   # increment patience if best loss is not surpassed
+            
+            # Compute and log EMA model loss
+            curr_model, curr_num_schedule, curr_cat_schedule = self.to_ema_model()
+            ema_mloss, ema_gloss = self.compute_loss()
+            self.to_model(curr_model, curr_num_schedule, curr_cat_schedule)
+            ema_total_loss = ema_mloss + ema_gloss
+            ema_loss_dict = {
+                "ema_loss/c_loss": ema_gloss,
+                "ema_loss/d_loss": ema_mloss,
+                "ema_loss/total_loss": ema_total_loss
+            }
+            
+            # Save the best ema ckpt
+            if ema_total_loss < best_ema_loss and self.curr_epoch > 4000:
+                best_ema_loss = ema_total_loss
+                to_remove = glob.glob(os.path.join(self.model_save_path, f"best_ema_model_*"))
+                if to_remove:
+                    os.remove(to_remove[0])
+                state_dicts = {
+                    'denoise_fn': self.ema_model.state_dict(), 
+                    'num_schedule':self.ema_num_schedule.state_dict(), 
+                    'cat_schedule': self.ema_cat_schedule.state_dict(),
+                }
+                torch.save(state_dicts, os.path.join(self.model_save_path, f'best_ema_model_{np.round(ema_total_loss,4)}_{epoch+1}.pt'))
+            
+            # Evaluate Sample Quality
+            if (epoch+1) % self.check_val_every == 0:
+                state_dicts = {
+                    'denoise_fn': self.diffusion._denoise_fn.state_dict(), 
+                    'num_schedule':self.diffusion.num_schedule.state_dict(), 
+                    'cat_schedule': self.diffusion.cat_schedule.state_dict(),
+                }
+                torch.save(state_dicts, os.path.join(self.model_save_path, f'model_{epoch+1}.pt'))
+                
+                print_with_bar(f"Routine Generation Evaluation every {self.check_val_every}, currently at epoch #{epoch+1}, wiht total_loss={total_loss}.")
+                # 适配器训练：容器内无 Chrome，跳过 Kaleido 密度图
+                _plot_density = os.environ.get("TABDIFF_ADAPTER_TRAIN", "").strip().lower() not in ("1", "true", "yes")
+                out_metrics, _, _ = self.evaluate_generation(save_metric_details=True, plot_density=_plot_density)
+                log_dict.update(out_metrics)
+                print(f"Eval Resutls of the Non-EMA model:\n {out_metrics}")
+
+                # Evaluate the EMA model
+                torch.save(self.ema_model.state_dict(), os.path.join(self.model_save_path, f'ema_model_{epoch+1}.pt'))
+                ema_out_metrics, _, _ = self.evaluate_generation(ema=True, save_metric_details=True, plot_density=_plot_density)
+                log_dict.update({
+                    "ema": ema_out_metrics,
+                })
+                print(f"Eval Resutls of the EMA model:\n {ema_out_metrics}")
+            
+            # Submit logs
+            self.logger.log(log_dict)
+
+        end_time = time.time()
+        print_with_bar(f"Ending Trainnig Loop, totoal training time = {end_time - start_time}")
+        self.logger.log({
+            'training_time': end_time - start_time
+        })
+        
+    def report_test(self, num_runs):
+        save_dir = self.result_save_path
+        
+        shape_ = []
+        trend_ = []
+        mle_ = []
+        c2st_ = []
+        for i in range(num_runs):
+            print_with_bar(f"GENERAL Evaluation Run {i}")
+            out_metrics, extras, syn_df = self.evaluate_generation()
+            print(f"Results of Run {i} are: \n{out_metrics}")
+            shape_.append(out_metrics["density/Shape"])
+            trend_.append(out_metrics["density/Trend"])
+            mle_.append(out_metrics["mle"])
+            c2st_.append(out_metrics["c2st"])
+            # Save samples for quality evaluation
+            save_path = os.path.join(save_dir, "all_samples")
+            if not os.path.exists(save_path):
+                os.makedirs(save_path)
+            syn_df.to_csv(os.path.join(save_path, f"samples_{i}.csv"), index=False)
+
+        shape_ = np.array(shape_)
+        trend_ = np.array(trend_)
+        mle_ = np.array(mle_)
+        c2st_ = np.array(c2st_)
+        
+        shape_error = (1 - shape_)*100
+        trend_error = (1 - trend_)*100
+        c2st_percent = c2st_ * 100
+        
+        all_results = pd.DataFrame({
+            "shape": shape_error,
+            "trend": trend_error,
+            "mle": mle_,
+            "c2st": c2st_percent,
+        })
+        avg = all_results.mean(axis=0).round(3)
+        std = all_results.std(axis=0).round(3)
+        avg_std = pd.concat([avg, std], axis=1, ignore_index=True)
+        avg_std.columns = ["avg", "std"]
+        avg_std.index = [
+            "shape", 
+            "trend", 
+            "mle", 
+            "c2st", 
+        ]
+        
+        # Savings
+        all_results.to_csv(f"{save_dir}/all_results.csv", index=True)
+        avg_std.to_csv(f"{save_dir}/avg_std.csv", index=True)
+        print_with_bar(f"The AVG over {num_runs} runs are: \n{avg_std}")
+        
+    def report_test_dcr(self, num_runs):
+        save_dir = self.result_save_path
+        
+        dcr_ = []
+        dcr_real_ = []
+        dcr_test_ = []
+        for i in range(num_runs):
+            print_with_bar(f"DCR Evaluation Run {i}")
+            out_metrics, extras, syn_df = self.evaluate_generation()
+            print(f"Results of Run {i} are: \n{out_metrics}")
+            dcr_.append(out_metrics["dcr"])
+            dcr_real_.append(extras["dcr_real"])
+            dcr_test_.append(extras["dcr_test"])
+            save_path = os.path.join(save_dir, "all_samples")
+            if not os.path.exists(save_path):
+                os.makedirs(save_path)
+            syn_df.to_csv(os.path.join(save_path, f"samples_{i}.csv"), index=False)
+
+        dcr_ = np.array(dcr_)
+        
+        dcr_percent = dcr_ * 100
+        
+        all_results = pd.DataFrame({
+            "dcr": dcr_percent,
+        })
+        avg = all_results.mean(axis=0).round(3)
+        std = all_results.std(axis=0).round(3)
+        avg_std = pd.concat([avg, std], axis=1, ignore_index=True)
+        avg_std.columns = ["avg", "std"]
+        avg_std.index = [
+            "dcr", 
+        ]
+        
+        # Savings
+        all_results.to_csv(f"{save_dir}/all_results.csv", index=True)
+        avg_std.to_csv(f"{save_dir}/avg_std.csv", index=True)
+        dcr_real = np.concatenate(dcr_real_, axis=0)
+        dcr_test = np.concatenate(dcr_test_, axis=0)
+        dcr_df = pd.DataFrame({
+            "dcr_real": dcr_real,
+            "dcr_test": dcr_test
+        })
+        dcr_df.to_csv(f"{save_dir}/dcr.csv", index=False)
+        
+        print_with_bar(f"The AVG over {num_runs} runs are: \n{avg_std}")
+        
+    def test(self):
+        _plot_density = os.environ.get("TABDIFF_ADAPTER_TRAIN", "").strip().lower() not in ("1", "true", "yes")
+        out_metrics, _, _ = self.evaluate_generation(save_metric_details=True, plot_density=_plot_density)
+        print_with_bar(f"Results of the test are: \n{out_metrics}")
+        self.logger.log(out_metrics)
+        print(out_metrics)
+
+    def evaluate_generation(self, save_metric_details=False, plot_density=False, ema=False):
+        self.diffusion.eval()
+        
+        # Sample a synthetic table
+        num_samples = self.num_samples_to_generate if self.num_samples_to_generate else self.metrics.real_data_size # By default, num_samples_to_generate is not specified. In this case, we generate the same number of samples as the real dataset. This approach is consistently used across all experiments in the paper.
+        syn_df = self.sample_synthetic(num_samples, ema=ema)
+        
+        # Save the sample
+        save_path = os.path.join(self.result_save_path, str(self.curr_epoch), "ema" if ema else "")
+        if not os.path.exists(save_path):
+            os.makedirs(save_path)
+        path = os.path.join(save_path, "samples.csv")
+        syn_df.to_csv(path, index=False)
+        print(
+            f"Samples are saved at {path}"
+        )
+
+        # 流水线仅需要 CSV：跳过 MLE/C2ST 等（合成表为字符串类别时 MLE 会报错）
+        if os.environ.get("TABDIFF_ADAPTER_SAMPLE_ONLY", "").strip().lower() in ("1", "true", "yes"):
+            return {}, {}, syn_df
+        
+        # Compute evaluation metrics on the sample
+        syn_df_loaded = pd.read_csv(os.path.join(save_path, "samples.csv")) # In the original tabsyn code, syn_data is implicitly casted into float.64 when it gets loaded with pd.read_csv in the evaluation script. If we don't cast, the density evluation for some columns (especially those with tailed and peaked distribution) will collapse.
+        out_metrics, extras = self.metrics.evaluate(syn_df_loaded)
+        
+        # Save metrics and metric details
+        path = os.path.join(save_path, "all_results.json")
+        with open(path, "w") as json_file:
+            json.dump(out_metrics, json_file, indent=4, separators=(", ", ": "))        # always locally save the output metrics
+        if save_metric_details:
+            for name, extra in extras.items():
+                if isinstance(extra, pd.DataFrame):
+                    extra.to_csv(os.path.join(save_path, f"{name}.csv"))
+                elif isinstance(extra, dict):
+                    with open(os.path.join(save_path, f"{name}.json"), "w") as json_file:
+                        json.dump(extra, json_file, indent=4, separators=(", ", ": "))
+                else:
+                    raise NotImplementedError(f"Extra file generated during evaluations has type {type(extra)}, and code to save this type of file is not implemented")
+        
+        # Plot density figures
+        if plot_density:
+            img = self.metrics.plot_density(syn_df_loaded)
+            path = os.path.join(save_path, "density_plots.png")
+            img.save(path)
+            print(
+                f"The density plots are saved at {path}"
+            )
+        return out_metrics, extras, syn_df
+        
+
+    def sample_synthetic(self, num_samples, keep_nan_samples=True, ema=False):
+        if ema:
+            curr_model, curr_num_schedule, curr_cat_schedule = self.to_ema_model()
+        info = self.metrics.info
+        
+        print_with_bar(f"Starting Sampling, total samples to generate = {num_samples}")
+        start_time = time.time()
+        
+        syn_data = self.diffusion.sample_all(num_samples, self.sample_batch_size, keep_nan_samples=keep_nan_samples)
+        print(f"Shape of the generated sample = {syn_data.shape}")
+        
+        if keep_nan_samples:
+            num_all_zero_row = (syn_data.sum(dim=1) == 0).sum()
+            if num_all_zero_row:
+                print(f"The generated samples contain {num_all_zero_row} Nan instances!!!")
+                self.logger.log({
+                    'num_Nan_sample': num_all_zero_row
+                })
+
+        # Recover tables
+        num_inverse = self.dataset.num_inverse
+        int_inverse = self.dataset.int_inverse
+        cat_inverse = self.dataset.cat_inverse
+        
+        if self.y_only:
+            if info['task_type'] == 'binclass':
+                syn_data = cat_inverse(syn_data)
+            else:
+                syn_data = num_inverse(syn_data)
+            syn_df = pd.DataFrame()
+            syn_df[info['column_names'][info['target_col_idx'][0]]] = syn_data[:, 0]
+        else:
+            syn_num, syn_cat, syn_target = split_num_cat_target(syn_data, info, num_inverse, int_inverse, cat_inverse) 
+            syn_df = recover_data(syn_num, syn_cat, syn_target, info)
+            
+
+            idx_name_mapping = info['idx_name_mapping']
+            idx_name_mapping = {int(key): value for key, value in idx_name_mapping.items()}
+
+            syn_df.rename(columns = idx_name_mapping, inplace=True)
+        
+        end_time = time.time()
+        print_with_bar(f"Ending Sampling, totoal sampling time = {end_time - start_time}")
+        
+        if ema:
+            self.to_model(curr_model, curr_num_schedule, curr_cat_schedule)
+
+        return syn_df
+    
+    def to_ema_model(self):
+        curr_model = self.diffusion._denoise_fn
+        curr_num_schedule = self.diffusion.num_schedule
+        curr_cat_schedule = self.diffusion.cat_schedule
+        self.diffusion._denoise_fn = self.ema_model  # temporarily install the ema parameters into the model
+        self.diffusion.num_schedule = self.ema_num_schedule
+        self.diffusion.cat_schedule = self.ema_cat_schedule
+        
+        return curr_model, curr_num_schedule, curr_cat_schedule
+
+    def to_model(self, curr_model, curr_num_schedule, curr_cat_schedule):
+        self.diffusion._denoise_fn = curr_model      # give back the parameters
+        self.diffusion.num_schedule = curr_num_schedule
+        self.diffusion.cat_schedule = curr_cat_schedule
+        
+    def test_impute(self, trail_start, trial_size, resample_rounds, impute_condition, imputed_sample_save_dir, w_num, w_cat):
+        self.diffusion.eval()
+        
+        info = self.metrics.info
+        task_type = info['task_type']
+        d_numerical, categories = self.dataset.d_numerical, self.dataset.categories
+        num_mask_idx, cat_mask_idx = [], []
+        X_train = self.dataset.X
+        X_train = X_train
+        x_num_train, x_cat_train = X_train[:,:d_numerical], X_train[:,d_numerical:]
+        
+        if task_type == 'binclass':    # for cat cols, push the masked col to [MASK]
+            cat_mask_idx += [0]
+        else:      # for num cols, set the masked col to the col mean
+            num_mask_idx += [0]
+            avg = x_num_train[:, num_mask_idx].mean(0).to(self.device)
+        
+        with torch.no_grad():
+            
+            for trial in range(trail_start, trail_start+trial_size):
+                print_with_bar(f"Imputing trial {trial}")
+                X_test = self.test_dataset.X
+                X_test = deepcopy(X_test).to(self.device)
+                x_num_test, x_cat_test = X_test[:, :d_numerical], X_test[:, d_numerical:].long()
+                
+                # Apply mask to x_0
+                if num_mask_idx:
+                    x_num_test[:, num_mask_idx] = avg
+                if cat_mask_idx:
+                    x_cat_test[:, cat_mask_idx] = torch.tensor(categories, dtype=x_cat_test.dtype, device=x_cat_test.device)[cat_mask_idx]
+                
+                # Sample imputed tables
+                syn_data = self.diffusion.sample_impute(x_num_test, x_cat_test, num_mask_idx, cat_mask_idx, resample_rounds, impute_condition, w_num, w_cat)
+                print(f"Shape of the imputed sample = {syn_data.shape}")
+
+                # Recover tables
+                num_inverse = self.dataset.num_inverse
+                int_inverse = self.dataset.int_inverse
+                cat_inverse = self.dataset.cat_inverse
+                
+                if torch.any((syn_data[:, d_numerical+1:]).max(dim=0).values > (x_cat_train[:,1:]).max(dim=0).values):     # if the test set contains categories not presented in the train set, we can not do cat_inverse. So we implement a patch that set those columns to the same as the train set
+                    print("Test set contains extra categories, and so does imputed syn data. We cannot do cat_inverse. So we set the cat columns as the same as the train set")
+                    syn_data[:, d_numerical+1:] = x_cat_train[:syn_data.shape[0],1:]
+                    
+                
+                syn_num, syn_cat, syn_target = split_num_cat_target(syn_data, info, num_inverse, int_inverse, cat_inverse) 
+                syn_df = recover_data(syn_num, syn_cat, syn_target, info)
+
+                idx_name_mapping = info['idx_name_mapping']
+                idx_name_mapping = {int(key): value for key, value in idx_name_mapping.items()}
+
+                syn_df.rename(columns = idx_name_mapping, inplace=True)
+                
+                # Save imputed samples
+                os.makedirs(imputed_sample_save_dir) if not os.path.exists(imputed_sample_save_dir) else None
+                print(f"Imputed samples are saved to {imputed_sample_save_dir}/{trial}.csv")
+                syn_df.to_csv(f'{imputed_sample_save_dir}/{trial}.csv', index = False)
+        
+def _as_numpy_float32(x):
+    """Inverse 变换可能返回 Tensor；统一为 numpy float32（含 0 列）。"""
+    if x is None:
+        return np.array([], dtype=np.float32)
+    if isinstance(x, torch.Tensor):
+        x = x.detach().cpu().numpy()
+    return np.asarray(x, dtype=np.float32)
+
+
+@torch.no_grad()
+def split_num_cat_target(syn_data, info, num_inverse, int_inverse, cat_inverse):
+    task_type = info['task_type']
+
+    num_col_idx = info['num_col_idx']
+    cat_col_idx = info['cat_col_idx']
+    target_col_idx = info['target_col_idx']
+
+    n_num_feat = len(num_col_idx)
+    n_cat_feat = len(cat_col_idx)
+
+    if task_type == 'regression':
+        n_num_feat += len(target_col_idx)
+    else:
+        n_cat_feat += len(target_col_idx)
+
+    syn_num = syn_data[:, :n_num_feat]
+    syn_cat = syn_data[:, n_num_feat:]
+
+    if n_num_feat > 0:
+        syn_num = _as_numpy_float32(num_inverse(syn_num))
+        syn_num = _as_numpy_float32(int_inverse(syn_num))
+    else:
+        syn_num = np.zeros((syn_data.shape[0], 0), dtype=np.float32)
+    syn_cat = cat_inverse(syn_cat)
+
+
+    if info['task_type'] == 'regression':
+        syn_target = syn_num[:, :len(target_col_idx)]
+        syn_num = syn_num[:, len(target_col_idx):]
+    
+    else:
+        print(syn_cat.shape)
+        syn_target = syn_cat[:, :len(target_col_idx)]
+        syn_cat = syn_cat[:, len(target_col_idx):]
+
+    return syn_num, syn_cat, syn_target
+
+def recover_data(syn_num, syn_cat, syn_target, info):
+
+    num_col_idx = info['num_col_idx']
+    cat_col_idx = info['cat_col_idx']
+    target_col_idx = info['target_col_idx']
+
+
+    idx_mapping = info['idx_mapping']
+    idx_mapping = {int(key): value for key, value in idx_mapping.items()}
+
+    syn_df = pd.DataFrame()
+
+    if info['task_type'] == 'regression':
+        for i in range(len(num_col_idx) + len(cat_col_idx) + len(target_col_idx)):
+            if i in set(num_col_idx):
+                syn_df[i] = syn_num[:, idx_mapping[i]] 
+            elif i in set(cat_col_idx):
+                syn_df[i] = syn_cat[:, idx_mapping[i] - len(num_col_idx)]
+            else:
+                syn_df[i] = syn_target[:, idx_mapping[i] - len(num_col_idx) - len(cat_col_idx)]
+
+
+    else:
+        for i in range(len(num_col_idx) + len(cat_col_idx) + len(target_col_idx)):
+            if i in set(num_col_idx):
+                syn_df[i] = syn_num[:, idx_mapping[i]]
+            elif i in set(cat_col_idx):
+                syn_df[i] = syn_cat[:, idx_mapping[i] - len(num_col_idx)]
+            else:
+                syn_df[i] = syn_target[:, idx_mapping[i] - len(num_col_idx) - len(cat_col_idx)]
+
+    return syn_df

SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/_tabdiff_runtime/utils_train.py

@@ -0,0 +1,198 @@
+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 TabDiffDataset(Dataset):
+    def __init__(self, dataname, data_dir, info, isTrain=True, y_only=False, 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, y_only, 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, y_only=False, 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,
+        y_only = y_only,
+    )
+
+    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']
+        if X_cat is None:
+            X_train_cat = np.empty((X_train_num.shape[0], 0), dtype=np.int64)
+            X_test_cat = np.empty((X_test_num.shape[0], 0), dtype=np.int64)
+            categories = []
+        else:
+            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,
+    y_only = False,
+):
+
+    # classification
+    if task_type == 'binclass' or task_type == 'multiclass':
+        has_cat = os.path.exists(os.path.join(data_path, 'X_cat_train.npy'))
+        X_cat = {} if (has_cat or concat) 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 y_only:
+                X_num_t = X_num_t[:, :0]
+                X_cat_t = X_cat_t[:, :0]
+            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 y_only:
+                X_num_t = X_num_t[:, :0]
+                X_cat_t = X_cat_t[:, :0]
+            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']
+
+    if y_only:
+        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/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/_tabdiff_train.py

@@ -0,0 +1,78 @@
+
+import os, shutil, subprocess, sys
+td = r"/workspace/TabDiff"
+name = r"pipeline_n11"
+src = r"/work/output-Benchmark-trainonly-v1/n11/tabdiff/tabdiff-n11-20260521_051642/tabular_bundle/pipeline_n11"
+rt = r"/work/output-Benchmark-trainonly-v1/n11/tabdiff/tabdiff-n11-20260521_051642/_tabdiff_runtime"
+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(td, rt, ignore=_ignore)
+
+def _replace_once(path, old, new):
+    text = open(path, "r", encoding="utf-8").read()
+    if old not in text:
+        raise RuntimeError(f"patch anchor not found in {path}")
+    text = text.replace(old, new, 1)
+    with open(path, "w", encoding="utf-8") as f:
+        f.write(text)
+
+_replace_once(
+    os.path.join(rt, "utils_train.py"),
+    "        X_train_num, X_test_num = X_num['train'], X_num['test']\n        X_train_cat, X_test_cat = X_cat['train'], X_cat['test']\n        \n        categories = src.get_categories(X_train_cat)\n",
+    "        X_train_num, X_test_num = X_num['train'], X_num['test']\n        if X_cat is None:\n            X_train_cat = np.empty((X_train_num.shape[0], 0), dtype=np.int64)\n            X_test_cat = np.empty((X_test_num.shape[0], 0), dtype=np.int64)\n            categories = []\n        else:\n            X_train_cat, X_test_cat = X_cat['train'], X_cat['test']\n            categories = src.get_categories(X_train_cat)\n",
+)
+_replace_once(
+    os.path.join(rt, "utils_train.py"),
+    "        X_cat = {} if os.path.exists(os.path.join(data_path, 'X_cat_train.npy'))  else None\n        X_num = {} if os.path.exists(os.path.join(data_path, 'X_num_train.npy')) else None\n        y = {} if os.path.exists(os.path.join(data_path, 'y_train.npy')) else None\n",
+    "        has_cat = os.path.exists(os.path.join(data_path, 'X_cat_train.npy'))\n        X_cat = {} if (has_cat or concat) else None\n        X_num = {} if os.path.exists(os.path.join(data_path, 'X_num_train.npy')) else None\n        y = {} if os.path.exists(os.path.join(data_path, 'y_train.npy')) else None\n",
+)
+_replace_once(
+    os.path.join(rt, "src", "data.py"),
+    "        num_workers=1,\n",
+    "        num_workers=int(os.environ.get('TABDIFF_NUM_WORKERS', '0')),\n",
+)
+_replace_once(
+    os.path.join(rt, "src", "data.py"),
+    "    loader = torch.utils.data.DataLoader(torch_dataset, batch_size=batch_size, shuffle=shuffle, num_workers=1)\n",
+    "    loader = torch.utils.data.DataLoader(torch_dataset, batch_size=batch_size, shuffle=shuffle, num_workers=int(os.environ.get('TABDIFF_NUM_WORKERS', '0')))\n",
+)
+_replace_once(
+    os.path.join(rt, "tabdiff", "main.py"),
+    "    if os.environ.get(\"TABDIFF_ADAPTER_TRAIN\", \"\").strip() and args.mode == \"train\":\n        raw_config[\"train\"][\"main\"][\"check_val_every\"] = int(raw_config[\"train\"][\"main\"][\"steps\"])\n\n    ## Load training data\n",
+    "    if os.environ.get(\"TABDIFF_ADAPTER_TRAIN\", \"\").strip() and args.mode == \"train\":\n        raw_config[\"train\"][\"main\"][\"check_val_every\"] = int(raw_config[\"train\"][\"main\"][\"steps\"])\n\n    _train_batch = os.environ.get(\"TABDIFF_BATCH_SIZE\", \"\").strip() or os.environ.get(\"TABDIFF_TRAIN_BATCH_SIZE\", \"\").strip()\n    if _train_batch:\n        raw_config[\"train\"][\"main\"][\"batch_size\"] = max(1, int(_train_batch))\n    _sample_batch = os.environ.get(\"TABDIFF_SAMPLE_BATCH_SIZE\", \"\").strip()\n    if _sample_batch:\n        raw_config[\"sample\"][\"batch_size\"] = max(1, int(_sample_batch))\n    _train_lr = os.environ.get(\"TABDIFF_LR\", \"\").strip() or os.environ.get(\"TABDIFF_LEARNING_RATE\", \"\").strip()\n    if _train_lr:\n        raw_config[\"train\"][\"main\"][\"lr\"] = float(_train_lr)\n    _num_timesteps = os.environ.get(\"TABDIFF_NUM_TIMESTEPS\", \"\").strip() or os.environ.get(\"TABDIFF_TIMESTEPS\", \"\").strip()\n    if _num_timesteps:\n        raw_config[\"diffusion_params\"][\"num_timesteps\"] = max(1, int(_num_timesteps))\n\n    ## Load training data\n",
+)
+_replace_once(
+    os.path.join(rt, "tabdiff", "main.py"),
+    "        num_workers = 4,\n",
+    "        num_workers = int(os.environ.get('TABDIFF_NUM_WORKERS', '0')),\n",
+)
+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["TABDIFF_SMOKE_STEPS"] = "800"
+os.environ["TABDIFF_STEPS"] = "800"
+os.environ["TABDIFF_BATCH_SIZE"] = "512"
+os.environ["TABDIFF_TRAIN_BATCH_SIZE"] = "512"
+os.environ["TABDIFF_SAMPLE_BATCH_SIZE"] = "512"
+os.environ["TABDIFF_LR"] = "0.0005"
+os.environ["TABDIFF_LEARNING_RATE"] = "0.0005"
+os.environ["TABDIFF_NUM_TIMESTEPS"] = "50"
+os.environ["TABDIFF_TIMESTEPS"] = "50"
+os.environ["TABDIFF_NUM_WORKERS"] = "0"
+os.environ["TABDIFF_ADAPTER_TRAIN"] = "1"
+subprocess.check_call([
+    sys.executable, "-m", "tabdiff.main",
+    "--dataname", name, "--mode", "train", "--gpu", "0",
+    "--no_wandb", "--exp_name", r"adapter_learnable",
+])

SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/bo_combo.json

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

SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/gen_20260521_053144.log

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

SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/input_snapshot.json

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

SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/models_tabdiff/trained.pt

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

SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/public_gate/normalized_schema_snapshot.json

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

SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/public_gate/public_gate_report.json

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

SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/public_gate/staged_input_manifest.json

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

SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/run_config.json

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

SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/runtime_result.json

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

SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/staged/public/staged_features.json

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

SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/staged/public/test.csv

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

SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/staged/public/train.csv

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

SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/staged/public/val.csv

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

SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/staged/tabdiff/adapter_report.json

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

SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/staged/tabdiff/adapter_transforms_applied.json

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

SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/staged/tabdiff/model_input_manifest.json

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

SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/tabdiff-n11-15215-20260521_053144.csv

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

SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/tabdiff_train_meta.json

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

SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/tabular_bundle/pipeline_n11/X_num_test.npy

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

SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/tabular_bundle/pipeline_n11/X_num_train.npy

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

SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/tabular_bundle/pipeline_n11/X_num_val.npy

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

SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/tabular_bundle/pipeline_n11/info.json

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

SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/tabular_bundle/pipeline_n11/real.csv

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

SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/tabular_bundle/pipeline_n11/staged_features.json

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

SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/tabular_bundle/pipeline_n11/test.csv

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

SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/tabular_bundle/pipeline_n11/train.csv

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

SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/tabular_bundle/pipeline_n11/val.csv

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

SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/tabular_bundle/pipeline_n11/y_test.npy

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

SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/tabular_bundle/pipeline_n11/y_train.npy

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

SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/tabular_bundle/pipeline_n11/y_val.npy

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

SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_051642/train_20260521_051643.log

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

SynthData0523/hyper_parameter_tuning/n11/tabdiff/runs/tabdiff-n11-20260521_053348/_tabdiff_gen.py

@@ -0,0 +1,42 @@
+
+import os, shutil, subprocess, sys
+td = r"/workspace/TabDiff"
+name = r"pipeline_n11"
+src = r"/work/output-Benchmark-trainonly-v1/n11/tabdiff/tabdiff-n11-20260521_053348/tabular_bundle/pipeline_n11"
+rt = r"/work/output-Benchmark-trainonly-v1/n11/tabdiff/tabdiff-n11-20260521_053348/_tabdiff_runtime"
+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(td, 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", "")
+subprocess.check_call([
+    sys.executable, "-m", "tabdiff.main",
+    "--dataname", name, "--mode", "test", "--gpu", "0",
+    "--no_wandb", "--exp_name", r"adapter_learnable",
+    "--ckpt_path", r"/work/output-Benchmark-trainonly-v1/n11/tabdiff/tabdiff-n11-20260521_053348/_tabdiff_runtime/tabdiff/ckpt/pipeline_n11/adapter_learnable/model_800.pt",
+    "--num_samples_to_generate", str(int(15215)),
+])
+# test() 写入 tabdiff/result/<dataname>/<exp>/<epoch>/samples.csv
+base = os.path.join(rt, "tabdiff", "result", name, r"adapter_learnable")
+best = None
+best_t = -1.0
+for root, _, files in os.walk(base):
+    if "samples.csv" in files:
+        p = os.path.join(root, "samples.csv")
+        t = os.path.getmtime(p)
+        if t > best_t:
+            best_t = t
+            best = p
+if not best:
+    raise SystemExit("tabdiff: no samples.csv under " + base)
+shutil.copy(best, r"/work/output-Benchmark-trainonly-v1/n11/tabdiff/tabdiff-n11-20260521_053348/tabdiff-n11-15215-20260521_054153.csv")