Resume SynthData0523 main/n16 batch 2

.gitattributes

@@ -12701,3 +12701,127 @@ SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/_efvfm_runtime/re
 SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/_efvfm_runtime/synthetic/pipeline_n16/real.csv filter=lfs diff=lfs merge=lfs -text
 SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/_efvfm_runtime/synthetic/pipeline_n16/test.csv filter=lfs diff=lfs merge=lfs -text
 SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/_efvfm_runtime/synthetic/pipeline_n16/val.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/gen_20260513_134510.log filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/input_snapshot.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/models_tabbyflow/trained.pt filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/public_gate/normalized_schema_snapshot.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/public_gate/public_gate_report.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/public_gate/staged_input_manifest.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/run_config.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/runtime_result.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/staged/public/staged_features.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/staged/public/test.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/staged/public/train.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/staged/public/val.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/staged/tabbyflow/adapter_report.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/staged/tabbyflow/adapter_transforms_applied.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/staged/tabbyflow/model_input_manifest.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/tabbyflow-n16-227845-20260513_134510.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/tabbyflow_train_meta.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/tabular_bundle/pipeline_n16/X_num_test.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/tabular_bundle/pipeline_n16/X_num_train.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/tabular_bundle/pipeline_n16/X_num_val.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/tabular_bundle/pipeline_n16/info.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/tabular_bundle/pipeline_n16/real.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/tabular_bundle/pipeline_n16/staged_features.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/tabular_bundle/pipeline_n16/test.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/tabular_bundle/pipeline_n16/train.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/tabular_bundle/pipeline_n16/val.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/tabular_bundle/pipeline_n16/y_test.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/tabular_bundle/pipeline_n16/y_train.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/tabular_bundle/pipeline_n16/y_val.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/train_20260513_131701.log filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabddpm/tabddpm-n16-20260321_163935/data/X_num_test.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabddpm/tabddpm-n16-20260321_163935/data/X_num_train.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabddpm/tabddpm-n16-20260321_163935/data/X_num_val.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabddpm/tabddpm-n16-20260321_163935/data/y_test.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabddpm/tabddpm-n16-20260321_163935/data/y_train.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabddpm/tabddpm-n16-20260321_163935/data/y_val.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabddpm/tabddpm-n16-20260321_163935/gen_20260321_164225.log filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabddpm/tabddpm-n16-20260321_163935/gen_20260424_212203.log filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabddpm/tabddpm-n16-20260321_163935/gen_20260425_033728.log filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabddpm/tabddpm-n16-20260321_163935/gen_20260425_080506.log filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabddpm/tabddpm-n16-20260321_163935/output/X_num_train.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabddpm/tabddpm-n16-20260321_163935/output/X_num_unnorm.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabddpm/tabddpm-n16-20260321_163935/output/loss.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabddpm/tabddpm-n16-20260321_163935/output/model.pt filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabddpm/tabddpm-n16-20260321_163935/output/model_ema.pt filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabddpm/tabddpm-n16-20260321_163935/output/y_train.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabddpm/tabddpm-n16-20260321_163935/staged/public/test.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabddpm/tabddpm-n16-20260321_163935/staged/public/train.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabddpm/tabddpm-n16-20260321_163935/staged/public/val.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabddpm/tabddpm-n16-20260321_163935/tabddpm-n16-1000-20260321_164225.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabddpm/tabddpm-n16-20260321_163935/tabddpm-n16-227845-20260425_080506.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabddpm/tabddpm-n16-20260321_163935/train_20260321_164024.log filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabdiff/tabdiff-n16-20260501_191651/gen_20260501_194646.log filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabdiff/tabdiff-n16-20260501_191651/input_snapshot.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabdiff/tabdiff-n16-20260501_191651/models_tabdiff/trained.pt filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabdiff/tabdiff-n16-20260501_191651/public_gate/normalized_schema_snapshot.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabdiff/tabdiff-n16-20260501_191651/public_gate/public_gate_report.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabdiff/tabdiff-n16-20260501_191651/public_gate/staged_input_manifest.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabdiff/tabdiff-n16-20260501_191651/runtime_result.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabdiff/tabdiff-n16-20260501_191651/staged/public/staged_features.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabdiff/tabdiff-n16-20260501_191651/staged/public/test.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabdiff/tabdiff-n16-20260501_191651/staged/public/train.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabdiff/tabdiff-n16-20260501_191651/staged/public/val.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabdiff/tabdiff-n16-20260501_191651/staged/tabdiff/adapter_report.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabdiff/tabdiff-n16-20260501_191651/staged/tabdiff/adapter_transforms_applied.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabdiff/tabdiff-n16-20260501_191651/staged/tabdiff/model_input_manifest.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabdiff/tabdiff-n16-20260501_191651/tabdiff-n16-227845-20260501_194646.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabdiff/tabdiff-n16-20260501_191651/tabdiff_train_meta.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabdiff/tabdiff-n16-20260501_191651/tabular_bundle/pipeline_n16/X_cat_test.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabdiff/tabdiff-n16-20260501_191651/tabular_bundle/pipeline_n16/X_cat_train.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabdiff/tabdiff-n16-20260501_191651/tabular_bundle/pipeline_n16/X_cat_val.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabdiff/tabdiff-n16-20260501_191651/tabular_bundle/pipeline_n16/X_num_test.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabdiff/tabdiff-n16-20260501_191651/tabular_bundle/pipeline_n16/X_num_train.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabdiff/tabdiff-n16-20260501_191651/tabular_bundle/pipeline_n16/X_num_val.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabdiff/tabdiff-n16-20260501_191651/tabular_bundle/pipeline_n16/info.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabdiff/tabdiff-n16-20260501_191651/tabular_bundle/pipeline_n16/real.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabdiff/tabdiff-n16-20260501_191651/tabular_bundle/pipeline_n16/test.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabdiff/tabdiff-n16-20260501_191651/tabular_bundle/pipeline_n16/val.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabdiff/tabdiff-n16-20260501_191651/tabular_bundle/pipeline_n16/y_test.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabdiff/tabdiff-n16-20260501_191651/tabular_bundle/pipeline_n16/y_train.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabdiff/tabdiff-n16-20260501_191651/tabular_bundle/pipeline_n16/y_val.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabdiff/tabdiff-n16-20260501_191651/train_20260501_191724.log filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabpfgen/tabpfgen-n16-20260512_082648/gen_20260512_082701.log filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabpfgen/tabpfgen-n16-20260512_082648/input_snapshot.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabpfgen/tabpfgen-n16-20260512_082648/public_gate/normalized_schema_snapshot.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabpfgen/tabpfgen-n16-20260512_082648/public_gate/public_gate_report.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabpfgen/tabpfgen-n16-20260512_082648/public_gate/staged_input_manifest.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabpfgen/tabpfgen-n16-20260512_082648/run_config.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabpfgen/tabpfgen-n16-20260512_082648/runtime_result.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabpfgen/tabpfgen-n16-20260512_082648/staged/public/staged_features.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabpfgen/tabpfgen-n16-20260512_082648/staged/public/test.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabpfgen/tabpfgen-n16-20260512_082648/staged/public/train.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabpfgen/tabpfgen-n16-20260512_082648/staged/public/val.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabpfgen/tabpfgen-n16-20260512_082648/staged/tabpfgen/adapter_report.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabpfgen/tabpfgen-n16-20260512_082648/staged/tabpfgen/adapter_transforms_applied.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabpfgen/tabpfgen-n16-20260512_082648/staged/tabpfgen/model_input_manifest.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabpfgen/tabpfgen-n16-20260512_082648/tabpfgen-n16-227845-20260512_082701.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabpfgen/tabpfgen-n16-20260512_082648/tabpfgen_meta.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabpfgen/tabpfgen-n16-20260512_082648/train_20260512_082701.log filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabsyn/tabsyn-n16-20260426_220916/data/tabsyn_n16/X_cat_test.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabsyn/tabsyn-n16-20260426_220916/data/tabsyn_n16/X_cat_train.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabsyn/tabsyn-n16-20260426_220916/data/tabsyn_n16/X_num_test.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabsyn/tabsyn-n16-20260426_220916/data/tabsyn_n16/X_num_train.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabsyn/tabsyn-n16-20260426_220916/data/tabsyn_n16/test.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabsyn/tabsyn-n16-20260426_220916/data/tabsyn_n16/train.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabsyn/tabsyn-n16-20260426_220916/data/tabsyn_n16/y_test.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabsyn/tabsyn-n16-20260426_220916/data/tabsyn_n16/y_train.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabsyn/tabsyn-n16-20260426_220916/gen_20260427_002515.log filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabsyn/tabsyn-n16-20260426_220916/staged/public/test.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabsyn/tabsyn-n16-20260426_220916/staged/public/train.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabsyn/tabsyn-n16-20260426_220916/staged/public/val.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabsyn/tabsyn-n16-20260426_220916/synthetic/tabsyn_n16/real.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabsyn/tabsyn-n16-20260426_220916/synthetic/tabsyn_n16/test.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabsyn/tabsyn-n16-20260426_220916/tabsyn-n16-227845-20260427_002515.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tabsyn/tabsyn-n16-20260426_220916/train_20260426_221025.log filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tvae/tvae-n16-20260328_053742/gen_20260328_164845.log filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tvae/tvae-n16-20260328_053742/gen_20260330_070842.log filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tvae/tvae-n16-20260328_053742/models_300epochs/train_20260328_053849.log filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tvae/tvae-n16-20260328_053742/models_300epochs/tvae_300epochs.pt filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tvae/tvae-n16-20260328_053742/staged/public/test.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tvae/tvae-n16-20260328_053742/staged/public/train.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tvae/tvae-n16-20260328_053742/staged/public/val.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tvae/tvae-n16-20260328_053742/tvae-n16-1000-20260328_164845.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/n16/tvae/tvae-n16-20260328_053742/tvae-n16-227845-20260330_070842.csv filter=lfs diff=lfs merge=lfs -text

SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/_efvfm_runtime/tests/test_config.py

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

SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/_efvfm_runtime/tests/test_flow_model.py

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

SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/_efvfm_runtime/tests/test_mlp.py

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

SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/_efvfm_runtime/tests/test_reconstructor.py

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

SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/_efvfm_runtime/tests/test_tokenizer.py

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

SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/_efvfm_runtime/tests/test_trainer.py

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

SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/_efvfm_runtime/tests/test_transformer.py

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

SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/_efvfm_runtime/tests/test_unimodmlp.py

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

SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/_efvfm_runtime/tests/test_utils.py

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

SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/_efvfm_runtime/utils_train.py

@@ -0,0 +1,205 @@
+import numpy as np
+import os
+from pathlib import Path
+
+import src
+from torch.utils.data import Dataset
+
+import torch
+
+
+class TabularDataset(Dataset):
+    def __init__(self, X_num, X_cat):
+        self.X_num = X_num
+        self.X_cat = X_cat
+
+    def __getitem__(self, index):
+        this_num = self.X_num[index]
+        this_cat = self.X_cat[index]
+
+        sample = (this_num, this_cat)
+
+        return sample
+
+    def __len__(self):
+        return self.X_num.shape[0]
+
+
+class EFVFMDataset(Dataset):
+    def __init__(self, dataname, data_dir, info, isTrain=True, dequant_dist='none', int_dequant_factor=0.0):
+        self.dataname = dataname
+        self.data_dir = data_dir
+        self.info = info
+        self.isTrain = isTrain
+
+        X_num, X_cat, categories, d_numerical, num_inverse, int_inverse, cat_inverse = preprocess(
+            data_dir, dequant_dist, int_dequant_factor, task_type=info['task_type'], inverse=True
+        )
+        categories = np.array(categories)
+
+        X_train_num, X_test_num = X_num
+        X_train_cat, X_test_cat = X_cat
+
+        X_train_num = torch.tensor(X_train_num).float()
+        X_test_num = torch.tensor(X_test_num).float()
+        X_train_cat = torch.tensor(X_train_cat)
+        X_test_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 _empty_num_like(y_split):
+    return np.zeros((len(y_split), 0), dtype=np.float32)
+
+
+def _empty_cat_like(y_split):
+    return np.zeros((len(y_split), 0), dtype=np.int64)
+
+
+def preprocess(dataset_path, dequant_dist='none', int_dequant_factor=0.0, task_type='binclass', inverse=False, cat_encoding=None, concat=True):
+
+    T_dict = {}
+
+    T_dict['normalization'] = "quantile"
+    T_dict['num_nan_policy'] = 'mean'
+    T_dict['cat_nan_policy'] = None
+    T_dict['cat_min_frequency'] = None
+    T_dict['cat_encoding'] = cat_encoding
+    T_dict['y_policy'] = "default"
+    T_dict['dequant_dist'] = dequant_dist
+    T_dict['int_dequant_factor'] = int_dequant_factor
+
+    T = src.Transformations(**T_dict)
+
+    dataset = make_dataset(
+        data_path=dataset_path,
+        T=T,
+        task_type=task_type,
+        change_val=False,
+        concat=concat,
+    )
+
+    if cat_encoding is None:
+        X_num = dataset.X_num
+        X_cat = dataset.X_cat
+        y = dataset.y
+
+        if X_num is None:
+            X_train_num = _empty_num_like(y['train'])
+            X_test_num = _empty_num_like(y['test'])
+        else:
+            X_train_num, X_test_num = X_num['train'], X_num['test']
+
+        if X_cat is None:
+            # Some datasets have no categorical features after preprocessing.
+            # For classification tasks, ef-vfm still expects the target to be
+            # concatenated into the categorical block.
+            if task_type in ('binclass', 'multiclass') and concat and y is not None:
+                X_train_cat = y['train'].reshape(-1, 1)
+                X_test_cat = y['test'].reshape(-1, 1)
+            else:
+                X_train_cat = _empty_cat_like(y['train'])
+                X_test_cat = _empty_cat_like(y['test'])
+        else:
+            X_train_cat, X_test_cat = X_cat['train'], X_cat['test']
+
+        categories = src.get_categories(X_train_cat) if X_train_cat.shape[1] > 0 else []
+        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):
+    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,
+):
+
+    if task_type == 'binclass' or task_type == 'multiclass':
+        X_cat = {} if os.path.exists(os.path.join(data_path, 'X_cat_train.npy')) else None
+        X_num = {} if os.path.exists(os.path.join(data_path, 'X_num_train.npy')) else None
+        y = {} if os.path.exists(os.path.join(data_path, 'y_train.npy')) else None
+
+        for split in ['train', 'test']:
+            X_num_t, X_cat_t, y_t = src.read_pure_data(data_path, split)
+            if X_num is not None:
+                X_num[split] = X_num_t
+            if X_cat is not None:
+                if concat:
+                    X_cat_t = concat_y_to_X(X_cat_t, y_t)
+                X_cat[split] = X_cat_t
+            if y is not None:
+                y[split] = y_t
+    else:
+        X_cat = {} if os.path.exists(os.path.join(data_path, 'X_cat_train.npy')) else None
+        X_num = {} if os.path.exists(os.path.join(data_path, 'X_num_train.npy')) else None
+        y = {} if os.path.exists(os.path.join(data_path, 'y_train.npy')) else None
+
+        for split in ['train', 'test']:
+            X_num_t, X_cat_t, y_t = src.read_pure_data(data_path, split)
+            if X_num is not None:
+                if concat:
+                    X_num_t = concat_y_to_X(X_num_t, y_t)
+                X_num[split] = X_num_t
+            if X_cat is not None:
+                X_cat[split] = X_cat_t
+            if y is not None:
+                y[split] = y_t
+
+    info = src.load_json(os.path.join(data_path, 'info.json'))
+    int_col_idx_wrt_num = info['int_col_idx_wrt_num']
+
+    D = src.Dataset(
+        X_num,
+        X_cat,
+        y,
+        int_col_idx_wrt_num,
+        y_info={},
+        task_type=src.TaskType(info['task_type']),
+        n_classes=info.get('n_classes')
+    )
+
+    if change_val:
+        D = src.change_val(D)
+    D = src.transform_dataset(D, T, cache_dir=Path(data_path))
+    return D

SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/_tabbyflow_gen.py

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

SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/_tabbyflow_train.py

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

SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/gen_20260513_134510.log

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

SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/input_snapshot.json

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

SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/models_tabbyflow/trained.pt

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

SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/public_gate/normalized_schema_snapshot.json

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

SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/public_gate/public_gate_report.json

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

SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/public_gate/staged_input_manifest.json

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

SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/run_config.json

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

SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/runtime_result.json

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

SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/staged/public/staged_features.json

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

SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/staged/public/test.csv

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

SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/staged/public/train.csv

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

SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/staged/public/val.csv

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

SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/staged/tabbyflow/adapter_report.json

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

SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/staged/tabbyflow/adapter_transforms_applied.json

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

SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/staged/tabbyflow/model_input_manifest.json

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

SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/tabbyflow-n16-227845-20260513_134510.csv

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

SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/tabbyflow_train_meta.json

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

SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/tabular_bundle/pipeline_n16/X_num_test.npy

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

SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/tabular_bundle/pipeline_n16/X_num_train.npy

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

SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/tabular_bundle/pipeline_n16/X_num_val.npy

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

SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/tabular_bundle/pipeline_n16/info.json

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

SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/tabular_bundle/pipeline_n16/real.csv

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

SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/tabular_bundle/pipeline_n16/staged_features.json

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

SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/tabular_bundle/pipeline_n16/test.csv

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

SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/tabular_bundle/pipeline_n16/train.csv

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

SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/tabular_bundle/pipeline_n16/val.csv

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

SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/tabular_bundle/pipeline_n16/y_test.npy

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

SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/tabular_bundle/pipeline_n16/y_train.npy

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

SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/tabular_bundle/pipeline_n16/y_val.npy

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

SynthData0523/main/n16/tabbyflow/tabbyflow-n16-20260513_131635/train_20260513_131701.log

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

SynthData0523/main/n16/tabddpm/tabddpm-n16-20260321_163935/_tabddpm_sample.py

@@ -0,0 +1,66 @@
+import os, sys, subprocess, json
+import numpy as np
+import pandas as pd
+
+tabddpm_root = "/workspace/tabddpm/code"
+assert os.path.isdir(tabddpm_root), f"TabDDPM source not mounted: {tabddpm_root}"
+env = os.environ.copy()
+env["PYTHONPATH"] = tabddpm_root + (os.pathsep + env.get("PYTHONPATH", ""))
+
+# Reuse the compat wrapper (patches collections.Sequence for skorch)
+wrapper = os.path.join(tabddpm_root, "_compat_run.py")
+if not os.path.exists(wrapper):
+    with open(wrapper, "w") as f:
+        f.write(
+            "import collections, collections.abc\n"
+            "for _a in ('Sequence','MutableSequence','MutableMapping','Mapping',"
+            "'MutableSet','Set','Callable','Iterable','Iterator'):\n"
+            "    if not hasattr(collections, _a): setattr(collections, _a, getattr(collections.abc, _a, None))\n"
+            "import sys, runpy\n"
+            "sys.argv = sys.argv[1:]\n"
+            "runpy.run_path(sys.argv[0], run_name='__main__')\n"
+        )
+
+print(f"[TabDDPM] Sampling 227845 rows")
+ret = subprocess.run(
+    [sys.executable, wrapper, "scripts/pipeline.py",
+     "--config", "/work/output-SpecializedModels/n16/tabddpm/tabddpm-n16-20260321_163935/config_sample_20260425_080506.toml",
+     "--sample"],
+    cwd=tabddpm_root,
+    env=env
+)
+if ret.returncode != 0:
+    sys.exit(ret.returncode)
+
+# 将 .npy 输出转为 CSV（npy 在 TabDDPM 的 parent_dir，即 npy_dir）
+info_path = "/work/output-SpecializedModels/n16/tabddpm/tabddpm-n16-20260321_163935/data/info.json"
+with open(info_path) as f:
+    info = json.load(f)
+
+output_dir = "/work/output-SpecializedModels/n16/tabddpm/tabddpm-n16-20260321_163935/output"
+col_names = info.get("column_names", [])
+
+parts = []
+x_num_path = os.path.join(output_dir, "X_num_train.npy")
+x_cat_path = os.path.join(output_dir, "X_cat_train.npy")
+y_path = os.path.join(output_dir, "y_train.npy")
+
+if os.path.exists(x_num_path):
+    parts.append(np.load(x_num_path, allow_pickle=True))
+if os.path.exists(x_cat_path):
+    parts.append(np.load(x_cat_path, allow_pickle=True).astype(float))
+if os.path.exists(y_path):
+    y = np.load(y_path, allow_pickle=True)
+    parts.append(y.reshape(-1, 1) if y.ndim == 1 else y)
+
+if parts:
+    combined = np.concatenate(parts, axis=1)
+    if col_names and len(col_names) == combined.shape[1]:
+        df = pd.DataFrame(combined, columns=col_names)
+    else:
+        df = pd.DataFrame(combined)
+    df.to_csv("/work/output-SpecializedModels/n16/tabddpm/tabddpm-n16-20260321_163935/tabddpm-n16-227845-20260425_080506.csv", index=False)
+    print(f"[TabDDPM] Saved {len(df)} rows -> /work/output-SpecializedModels/n16/tabddpm/tabddpm-n16-20260321_163935/tabddpm-n16-227845-20260425_080506.csv")
+else:
+    print("[TabDDPM] WARNING: No output .npy files found")
+    sys.exit(1)

SynthData0523/main/n16/tabddpm/tabddpm-n16-20260321_163935/_tabddpm_train.py

@@ -0,0 +1,32 @@
+import os, sys, subprocess
+
+tabddpm_root = "/workspace/tabddpm/code"
+assert os.path.isdir(tabddpm_root), f"TabDDPM source not mounted: {tabddpm_root}"
+env = os.environ.copy()
+env["PYTHONPATH"] = tabddpm_root + (os.pathsep + env.get("PYTHONPATH", ""))
+
+# Write a wrapper that patches collections.Sequence (removed in Python 3.10+)
+# before running pipeline.py - needed because skorch uses old API
+wrapper = os.path.join(tabddpm_root, "_compat_run.py")
+with open(wrapper, "w") as f:
+    f.write(
+        "import collections, collections.abc\n"
+        "for _a in ('Sequence','MutableSequence','MutableMapping','Mapping',"
+        "'MutableSet','Set','Callable','Iterable','Iterator'):\n"
+        "    if not hasattr(collections, _a): setattr(collections, _a, getattr(collections.abc, _a, None))\n"
+        "import sys, runpy\n"
+        "sys.argv = sys.argv[1:]\n"
+        "runpy.run_path(sys.argv[0], run_name='__main__')\n"
+    )
+
+print(f"[TabDDPM] Training, config=/work/output-SpecializedModels/n16/tabddpm/tabddpm-n16-20260321_163935/config.toml")
+ret = subprocess.run(
+    [sys.executable, wrapper, "scripts/pipeline.py",
+     "--config", "/work/output-SpecializedModels/n16/tabddpm/tabddpm-n16-20260321_163935/config.toml",
+     "--train"],
+    cwd=tabddpm_root,
+    env=env
+)
+if ret.returncode != 0:
+    sys.exit(ret.returncode)
+print("[TabDDPM] Training complete")

SynthData0523/main/n16/tabddpm/tabddpm-n16-20260321_163935/config.toml

@@ -0,0 +1,39 @@
+seed = 0
+parent_dir = "/work/output-SpecializedModels/n16/tabddpm/tabddpm-n16-20260321_163935/output"
+real_data_path = "/work/output-SpecializedModels/n16/tabddpm/tabddpm-n16-20260321_163935/data"
+model_type = "mlp"
+num_numerical_features = 30
+device = "cuda:0"
+
+[model_params]
+d_in = 30
+num_classes = 2
+is_y_cond = true
+
+[model_params.rtdl_params]
+d_layers = [256, 256]
+dropout = 0.0
+
+[diffusion_params]
+num_timesteps = 1000
+gaussian_loss_type = "mse"
+
+[train.main]
+steps = 5000
+lr = 0.001
+weight_decay = 0.0
+batch_size = 256
+
+[train.T]
+seed = 0
+normalization = "quantile"
+num_nan_policy = "__none__"
+cat_nan_policy = "__none__"
+cat_min_frequency = "__none__"
+cat_encoding = "__none__"
+y_policy = "default"
+
+[sample]
+num_samples = 1000
+batch_size = 1000
+seed = 0

SynthData0523/main/n16/tabddpm/tabddpm-n16-20260321_163935/config_sample_20260424_212203.toml

@@ -0,0 +1,39 @@
+seed = 0
+parent_dir = "/work/output-SpecializedModels/n16/tabddpm/tabddpm-n16-20260321_163935/output"
+real_data_path = "/work/output-SpecializedModels/n16/tabddpm/tabddpm-n16-20260321_163935/data"
+model_type = "mlp"
+num_numerical_features = 30
+device = "cuda:0"
+
+[model_params]
+d_in = 30
+num_classes = 2
+is_y_cond = true
+
+[model_params.rtdl_params]
+d_layers = [256, 256]
+dropout = 0.0
+
+[diffusion_params]
+num_timesteps = 1000
+gaussian_loss_type = "mse"
+
+[train.main]
+steps = 5000
+lr = 0.001
+weight_decay = 0.0
+batch_size = 256
+
+[train.T]
+seed = 0
+normalization = "quantile"
+num_nan_policy = "__none__"
+cat_nan_policy = "__none__"
+cat_min_frequency = "__none__"
+cat_encoding = "__none__"
+y_policy = "default"
+
+[sample]
+num_samples = 227845
+batch_size = 1000
+seed = 0

SynthData0523/main/n16/tabddpm/tabddpm-n16-20260321_163935/config_sample_20260425_033728.toml

@@ -0,0 +1,39 @@
+seed = 0
+parent_dir = "/work/output-SpecializedModels/n16/tabddpm/tabddpm-n16-20260321_163935/output"
+real_data_path = "/work/output-SpecializedModels/n16/tabddpm/tabddpm-n16-20260321_163935/data"
+model_type = "mlp"
+num_numerical_features = 30
+device = "cuda:0"
+
+[model_params]
+d_in = 30
+num_classes = 2
+is_y_cond = true
+
+[model_params.rtdl_params]
+d_layers = [256, 256]
+dropout = 0.0
+
+[diffusion_params]
+num_timesteps = 1000
+gaussian_loss_type = "mse"
+
+[train.main]
+steps = 5000
+lr = 0.001
+weight_decay = 0.0
+batch_size = 256
+
+[train.T]
+seed = 0
+normalization = "quantile"
+num_nan_policy = "__none__"
+cat_nan_policy = "__none__"
+cat_min_frequency = "__none__"
+cat_encoding = "__none__"
+y_policy = "default"
+
+[sample]
+num_samples = 227845
+batch_size = 1000
+seed = 0

SynthData0523/main/n16/tabddpm/tabddpm-n16-20260321_163935/config_sample_20260425_080506.toml

@@ -0,0 +1,39 @@
+seed = 0
+parent_dir = "/work/output-SpecializedModels/n16/tabddpm/tabddpm-n16-20260321_163935/output"
+real_data_path = "/work/output-SpecializedModels/n16/tabddpm/tabddpm-n16-20260321_163935/data"
+model_type = "mlp"
+num_numerical_features = 30
+device = "cuda:0"
+
+[model_params]
+d_in = 30
+num_classes = 2
+is_y_cond = true
+
+[model_params.rtdl_params]
+d_layers = [256, 256]
+dropout = 0.0
+
+[diffusion_params]
+num_timesteps = 1000
+gaussian_loss_type = "mse"
+
+[train.main]
+steps = 5000
+lr = 0.001
+weight_decay = 0.0
+batch_size = 256
+
+[train.T]
+seed = 0
+normalization = "quantile"
+num_nan_policy = "__none__"
+cat_nan_policy = "__none__"
+cat_min_frequency = "__none__"
+cat_encoding = "__none__"
+y_policy = "default"
+
+[sample]
+num_samples = 227845
+batch_size = 1000
+seed = 0

SynthData0523/main/n16/tabddpm/tabddpm-n16-20260321_163935/data/X_num_test.npy

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