Resume SynthData0523 main/c17 batch 2

.gitattributes

@@ -2344,3 +2344,44 @@ SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/_tabdiff_runtime/synt
 SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/_tabdiff_runtime/synthetic/pipeline_c17/test.csv filter=lfs diff=lfs merge=lfs -text
 SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/_tabdiff_runtime/synthetic/pipeline_c17/val.csv filter=lfs diff=lfs merge=lfs -text
 SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/_tabdiff_runtime/tabdiff/ckpt/pipeline_c17/adapter_learnable/config.pkl filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/_tabdiff_runtime/tabdiff/ckpt/pipeline_c17/adapter_learnable/ema_model_200.pt filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/_tabdiff_runtime/tabdiff/ckpt/pipeline_c17/adapter_learnable/model_200.pt filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/_tabdiff_runtime/tabdiff/configs/tabdiff_configs.toml filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/_tabdiff_runtime/tabdiff/result/pipeline_c17/adapter_learnable/200/all_results.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/_tabdiff_runtime/tabdiff/result/pipeline_c17/adapter_learnable/200/ema/all_results.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/_tabdiff_runtime/tabdiff/result/pipeline_c17/adapter_learnable/200/ema/samples.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/_tabdiff_runtime/tabdiff/result/pipeline_c17/adapter_learnable/200/ema/shapes.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/_tabdiff_runtime/tabdiff/result/pipeline_c17/adapter_learnable/200/ema/trends.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/_tabdiff_runtime/tabdiff/result/pipeline_c17/adapter_learnable/200/samples.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/_tabdiff_runtime/tabdiff/result/pipeline_c17/adapter_learnable/200/shapes.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/_tabdiff_runtime/tabdiff/result/pipeline_c17/adapter_learnable/200/trends.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/gen_20260513_004055.log filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/input_snapshot.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/models_tabdiff/trained.pt filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/public_gate/normalized_schema_snapshot.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/public_gate/public_gate_report.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/public_gate/staged_input_manifest.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/run_config.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/runtime_result.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/staged/public/staged_features.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/staged/public/test.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/staged/public/train.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/staged/public/val.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/staged/tabdiff/adapter_report.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/staged/tabdiff/adapter_transforms_applied.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/staged/tabdiff/model_input_manifest.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/tabdiff-c17-7045-20260513_004055.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/tabdiff_train_meta.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/tabular_bundle/pipeline_c17/X_cat_test.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/tabular_bundle/pipeline_c17/X_cat_train.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/tabular_bundle/pipeline_c17/X_cat_val.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/tabular_bundle/pipeline_c17/X_num_test.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/tabular_bundle/pipeline_c17/X_num_train.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/tabular_bundle/pipeline_c17/X_num_val.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/tabular_bundle/pipeline_c17/info.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/tabular_bundle/pipeline_c17/real.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/tabular_bundle/pipeline_c17/staged_features.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/tabular_bundle/pipeline_c17/test.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/tabular_bundle/pipeline_c17/train.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/tabular_bundle/pipeline_c17/val.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/tabular_bundle/pipeline_c17/y_test.npy filter=lfs diff=lfs merge=lfs -text

SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/_tabdiff_runtime/tabdiff/ckpt/pipeline_c17/adapter_learnable/ema_model_200.pt

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

SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/_tabdiff_runtime/tabdiff/ckpt/pipeline_c17/adapter_learnable/model_200.pt

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

SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/_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/main/c17/tabdiff/tabdiff-c17-20260513_002853/_tabdiff_runtime/tabdiff/main.py

@@ -0,0 +1,331 @@
+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"])
+
+    ## 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 = 4,
+    )
+    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/main/c17/tabdiff/tabdiff-c17-20260513_002853/_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/main/c17/tabdiff/tabdiff-c17-20260513_002853/_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/main/c17/tabdiff/tabdiff-c17-20260513_002853/_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/main/c17/tabdiff/tabdiff-c17-20260513_002853/_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/main/c17/tabdiff/tabdiff-c17-20260513_002853/_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/main/c17/tabdiff/tabdiff-c17-20260513_002853/_tabdiff_runtime/tabdiff/result/pipeline_c17/adapter_learnable/200/all_results.json

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

SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/_tabdiff_runtime/tabdiff/result/pipeline_c17/adapter_learnable/200/ema/all_results.json

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

SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/_tabdiff_runtime/tabdiff/result/pipeline_c17/adapter_learnable/200/ema/samples.csv

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

SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/_tabdiff_runtime/tabdiff/result/pipeline_c17/adapter_learnable/200/ema/shapes.csv

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

SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/_tabdiff_runtime/tabdiff/result/pipeline_c17/adapter_learnable/200/ema/trends.csv

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

SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/_tabdiff_runtime/tabdiff/result/pipeline_c17/adapter_learnable/200/samples.csv

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

SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/_tabdiff_runtime/tabdiff/result/pipeline_c17/adapter_learnable/200/shapes.csv

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

SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/_tabdiff_runtime/tabdiff/result/pipeline_c17/adapter_learnable/200/trends.csv

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

SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/_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/main/c17/tabdiff/tabdiff-c17-20260513_002853/_tabdiff_runtime/utils_train.py

@@ -0,0 +1,193 @@
+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']
+        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':
+        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:
+                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/main/c17/tabdiff/tabdiff-c17-20260513_002853/_tabdiff_train.py

@@ -0,0 +1,37 @@
+
+import os, shutil, subprocess, sys
+td = r"/workspace/TabDiff"
+name = r"pipeline_c17"
+src = r"/work/output-Benchmark-trainonly-v1/c17/tabdiff/tabdiff-c17-20260513_002853/tabular_bundle/pipeline_c17"
+rt = r"/work/output-Benchmark-trainonly-v1/c17/tabdiff/tabdiff-c17-20260513_002853/_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)
+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"] = "200"
+os.environ["TABDIFF_STEPS"] = "200"
+os.environ["TABDIFF_BATCH_SIZE"] = "256"
+os.environ["TABDIFF_TRAIN_BATCH_SIZE"] = "256"
+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_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/main/c17/tabdiff/tabdiff-c17-20260513_002853/gen_20260513_004055.log

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

SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/input_snapshot.json

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

SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/models_tabdiff/trained.pt

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

SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/public_gate/normalized_schema_snapshot.json

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

SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/public_gate/public_gate_report.json

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

SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/public_gate/staged_input_manifest.json

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

SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/run_config.json

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

SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/runtime_result.json

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

SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/staged/public/staged_features.json

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

SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/staged/public/test.csv

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

SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/staged/public/train.csv

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

SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/staged/public/val.csv

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

SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/staged/tabdiff/adapter_report.json

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

SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/staged/tabdiff/adapter_transforms_applied.json

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

SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/staged/tabdiff/model_input_manifest.json

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

SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/tabdiff-c17-7045-20260513_004055.csv

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

SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/tabdiff_train_meta.json

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

SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/tabular_bundle/pipeline_c17/X_cat_test.npy

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

SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/tabular_bundle/pipeline_c17/X_cat_train.npy

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

SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/tabular_bundle/pipeline_c17/X_cat_val.npy

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

SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/tabular_bundle/pipeline_c17/X_num_test.npy

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

SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/tabular_bundle/pipeline_c17/X_num_train.npy

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

SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/tabular_bundle/pipeline_c17/X_num_val.npy

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

SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/tabular_bundle/pipeline_c17/info.json

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

SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/tabular_bundle/pipeline_c17/real.csv

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

SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/tabular_bundle/pipeline_c17/staged_features.json

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

SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/tabular_bundle/pipeline_c17/test.csv

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

SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/tabular_bundle/pipeline_c17/train.csv

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

SynthData0523/main/c17/tabdiff/tabdiff-c17-20260513_002853/tabular_bundle/pipeline_c17/val.csv

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