Resume SynthData0523 main/c15 batch 2

.gitattributes

@@ -1729,3 +1729,198 @@ SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/re
 SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/40/samples.csv filter=lfs diff=lfs merge=lfs -text
 SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/40/shapes.csv filter=lfs diff=lfs merge=lfs -text
 SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/40/trends.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/50/all_results.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/50/ema/all_results.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/50/ema/samples.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/50/ema/shapes.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/50/ema/trends.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/50/samples.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/50/shapes.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/50/trends.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/60/all_results.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/60/ema/all_results.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/60/ema/samples.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/60/ema/shapes.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/60/ema/trends.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/60/samples.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/60/shapes.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/60/trends.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/70/all_results.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/70/ema/all_results.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/70/ema/samples.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/70/ema/shapes.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/70/ema/trends.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/70/samples.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/70/shapes.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/70/trends.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/80/all_results.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/80/ema/all_results.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/80/ema/samples.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/80/ema/shapes.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/80/ema/trends.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/80/samples.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/80/shapes.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/80/trends.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/90/all_results.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/90/ema/all_results.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/90/ema/samples.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/90/ema/shapes.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/90/ema/trends.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/90/samples.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/90/shapes.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/90/trends.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/synthetic/pipeline_c15/real.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/synthetic/pipeline_c15/test.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/synthetic/pipeline_c15/val.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/gen_20260513_074701.log filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/input_snapshot.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/models_tabbyflow/trained.pt filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/public_gate/normalized_schema_snapshot.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/public_gate/public_gate_report.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/public_gate/staged_input_manifest.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/run_config.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/runtime_result.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/staged/public/staged_features.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/staged/public/test.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/staged/public/train.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/staged/public/val.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/staged/tabbyflow/adapter_report.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/staged/tabbyflow/adapter_transforms_applied.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/staged/tabbyflow/model_input_manifest.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/tabbyflow-c15-480000-20260513_074701.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/tabbyflow_train_meta.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/tabular_bundle/pipeline_c15/X_cat_test.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/tabular_bundle/pipeline_c15/X_cat_train.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/tabular_bundle/pipeline_c15/X_cat_val.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/tabular_bundle/pipeline_c15/X_num_test.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/tabular_bundle/pipeline_c15/X_num_train.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/tabular_bundle/pipeline_c15/X_num_val.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/tabular_bundle/pipeline_c15/info.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/tabular_bundle/pipeline_c15/real.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/tabular_bundle/pipeline_c15/staged_features.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/tabular_bundle/pipeline_c15/test.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/tabular_bundle/pipeline_c15/train.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/tabular_bundle/pipeline_c15/val.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/tabular_bundle/pipeline_c15/y_test.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/tabular_bundle/pipeline_c15/y_train.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/tabular_bundle/pipeline_c15/y_val.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/train_20260513_061607.log filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabdiff/tabdiff-c15-20260513_004629/_tabdiff_runtime/data/pipeline_c15/X_cat_test.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabdiff/tabdiff-c15-20260513_004629/_tabdiff_runtime/data/pipeline_c15/X_cat_train.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabdiff/tabdiff-c15-20260513_004629/_tabdiff_runtime/data/pipeline_c15/X_cat_val.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabdiff/tabdiff-c15-20260513_004629/_tabdiff_runtime/data/pipeline_c15/X_num_test.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabdiff/tabdiff-c15-20260513_004629/_tabdiff_runtime/data/pipeline_c15/X_num_train.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabdiff/tabdiff-c15-20260513_004629/_tabdiff_runtime/data/pipeline_c15/X_num_val.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabdiff/tabdiff-c15-20260513_004629/_tabdiff_runtime/data/pipeline_c15/info.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabdiff/tabdiff-c15-20260513_004629/_tabdiff_runtime/data/pipeline_c15/real.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabdiff/tabdiff-c15-20260513_004629/_tabdiff_runtime/data/pipeline_c15/staged_features.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabdiff/tabdiff-c15-20260513_004629/_tabdiff_runtime/data/pipeline_c15/test.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabdiff/tabdiff-c15-20260513_004629/_tabdiff_runtime/data/pipeline_c15/train.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabdiff/tabdiff-c15-20260513_004629/_tabdiff_runtime/data/pipeline_c15/val.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabdiff/tabdiff-c15-20260513_004629/_tabdiff_runtime/data/pipeline_c15/y_test.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabdiff/tabdiff-c15-20260513_004629/_tabdiff_runtime/data/pipeline_c15/y_train.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabdiff/tabdiff-c15-20260513_004629/_tabdiff_runtime/data/pipeline_c15/y_val.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabdiff/tabdiff-c15-20260513_004629/_tabdiff_runtime/images/tabdiff_demo.gif filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabdiff/tabdiff-c15-20260513_004629/_tabdiff_runtime/images/tabdiff_demo.mp4 filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabdiff/tabdiff-c15-20260513_004629/_tabdiff_runtime/synthetic/pipeline_c15/real.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabdiff/tabdiff-c15-20260513_004629/_tabdiff_runtime/synthetic/pipeline_c15/test.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabdiff/tabdiff-c15-20260513_004629/_tabdiff_runtime/synthetic/pipeline_c15/val.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabdiff/tabdiff-c15-20260513_004629/_tabdiff_runtime/tabdiff/ckpt/pipeline_c15/adapter_learnable/config.pkl filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabdiff/tabdiff-c15-20260513_004629/_tabdiff_runtime/tabdiff/ckpt/pipeline_c15/adapter_learnable/ema_model_200.pt filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabdiff/tabdiff-c15-20260513_004629/_tabdiff_runtime/tabdiff/ckpt/pipeline_c15/adapter_learnable/model_200.pt filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabdiff/tabdiff-c15-20260513_004629/_tabdiff_runtime/tabdiff/configs/tabdiff_configs.toml filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabdiff/tabdiff-c15-20260513_004629/_tabdiff_runtime/tabdiff/result/pipeline_c15/adapter_learnable/200/all_results.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabdiff/tabdiff-c15-20260513_004629/_tabdiff_runtime/tabdiff/result/pipeline_c15/adapter_learnable/200/ema/all_results.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabdiff/tabdiff-c15-20260513_004629/_tabdiff_runtime/tabdiff/result/pipeline_c15/adapter_learnable/200/ema/samples.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabdiff/tabdiff-c15-20260513_004629/_tabdiff_runtime/tabdiff/result/pipeline_c15/adapter_learnable/200/ema/shapes.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabdiff/tabdiff-c15-20260513_004629/_tabdiff_runtime/tabdiff/result/pipeline_c15/adapter_learnable/200/ema/trends.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabdiff/tabdiff-c15-20260513_004629/_tabdiff_runtime/tabdiff/result/pipeline_c15/adapter_learnable/200/samples.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabdiff/tabdiff-c15-20260513_004629/_tabdiff_runtime/tabdiff/result/pipeline_c15/adapter_learnable/200/shapes.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabdiff/tabdiff-c15-20260513_004629/_tabdiff_runtime/tabdiff/result/pipeline_c15/adapter_learnable/200/trends.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabdiff/tabdiff-c15-20260513_004629/gen_20260513_043834.log filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabdiff/tabdiff-c15-20260513_004629/input_snapshot.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabdiff/tabdiff-c15-20260513_004629/models_tabdiff/trained.pt filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabdiff/tabdiff-c15-20260513_004629/public_gate/normalized_schema_snapshot.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabdiff/tabdiff-c15-20260513_004629/public_gate/public_gate_report.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabdiff/tabdiff-c15-20260513_004629/public_gate/staged_input_manifest.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabdiff/tabdiff-c15-20260513_004629/run_config.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabdiff/tabdiff-c15-20260513_004629/runtime_result.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabdiff/tabdiff-c15-20260513_004629/staged/public/staged_features.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabdiff/tabdiff-c15-20260513_004629/staged/public/test.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabdiff/tabdiff-c15-20260513_004629/staged/public/train.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabdiff/tabdiff-c15-20260513_004629/staged/public/val.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabdiff/tabdiff-c15-20260513_004629/staged/tabdiff/adapter_report.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabdiff/tabdiff-c15-20260513_004629/staged/tabdiff/adapter_transforms_applied.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabdiff/tabdiff-c15-20260513_004629/staged/tabdiff/model_input_manifest.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabdiff/tabdiff-c15-20260513_004629/tabdiff-c15-480000-20260513_043834.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabdiff/tabdiff-c15-20260513_004629/tabdiff_train_meta.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabdiff/tabdiff-c15-20260513_004629/tabular_bundle/pipeline_c15/X_cat_test.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabdiff/tabdiff-c15-20260513_004629/tabular_bundle/pipeline_c15/X_cat_train.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabdiff/tabdiff-c15-20260513_004629/tabular_bundle/pipeline_c15/X_cat_val.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabdiff/tabdiff-c15-20260513_004629/tabular_bundle/pipeline_c15/X_num_test.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabdiff/tabdiff-c15-20260513_004629/tabular_bundle/pipeline_c15/X_num_train.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabdiff/tabdiff-c15-20260513_004629/tabular_bundle/pipeline_c15/X_num_val.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabdiff/tabdiff-c15-20260513_004629/tabular_bundle/pipeline_c15/info.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabdiff/tabdiff-c15-20260513_004629/tabular_bundle/pipeline_c15/real.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabdiff/tabdiff-c15-20260513_004629/tabular_bundle/pipeline_c15/staged_features.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabdiff/tabdiff-c15-20260513_004629/tabular_bundle/pipeline_c15/test.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabdiff/tabdiff-c15-20260513_004629/tabular_bundle/pipeline_c15/train.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabdiff/tabdiff-c15-20260513_004629/tabular_bundle/pipeline_c15/val.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabdiff/tabdiff-c15-20260513_004629/tabular_bundle/pipeline_c15/y_test.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabdiff/tabdiff-c15-20260513_004629/tabular_bundle/pipeline_c15/y_train.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabdiff/tabdiff-c15-20260513_004629/tabular_bundle/pipeline_c15/y_val.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabdiff/tabdiff-c15-20260513_004629/train_20260513_004644.log filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabpfgen/tabpfgen-c15-20260512_144203/gen_20260512_144211.log filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabpfgen/tabpfgen-c15-20260512_144203/input_snapshot.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabpfgen/tabpfgen-c15-20260512_144203/public_gate/normalized_schema_snapshot.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabpfgen/tabpfgen-c15-20260512_144203/public_gate/public_gate_report.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabpfgen/tabpfgen-c15-20260512_144203/public_gate/staged_input_manifest.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabpfgen/tabpfgen-c15-20260512_144203/run_config.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabpfgen/tabpfgen-c15-20260512_144203/runtime_result.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabpfgen/tabpfgen-c15-20260512_144203/staged/public/staged_features.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabpfgen/tabpfgen-c15-20260512_144203/staged/public/test.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabpfgen/tabpfgen-c15-20260512_144203/staged/public/train.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabpfgen/tabpfgen-c15-20260512_144203/staged/public/val.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabpfgen/tabpfgen-c15-20260512_144203/staged/tabpfgen/adapter_report.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabpfgen/tabpfgen-c15-20260512_144203/staged/tabpfgen/adapter_transforms_applied.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabpfgen/tabpfgen-c15-20260512_144203/staged/tabpfgen/model_input_manifest.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabpfgen/tabpfgen-c15-20260512_144203/tabpfgen-c15-480000-20260512_144211.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabpfgen/tabpfgen-c15-20260512_144203/tabpfgen_meta.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabpfgen/tabpfgen-c15-20260512_144203/train_20260512_144211.log filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabsyn/tabsyn-c15-20260426_203054/data/tabsyn_c15/X_cat_test.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabsyn/tabsyn-c15-20260426_203054/data/tabsyn_c15/X_cat_train.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabsyn/tabsyn-c15-20260426_203054/data/tabsyn_c15/X_num_test.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabsyn/tabsyn-c15-20260426_203054/data/tabsyn_c15/X_num_train.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabsyn/tabsyn-c15-20260426_203054/data/tabsyn_c15/info.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabsyn/tabsyn-c15-20260426_203054/data/tabsyn_c15/test.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabsyn/tabsyn-c15-20260426_203054/data/tabsyn_c15/train.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabsyn/tabsyn-c15-20260426_203054/data/tabsyn_c15/y_test.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabsyn/tabsyn-c15-20260426_203054/data/tabsyn_c15/y_train.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabsyn/tabsyn-c15-20260426_203054/gen_20260427_004432.log filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabsyn/tabsyn-c15-20260426_203054/input_snapshot.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabsyn/tabsyn-c15-20260426_203054/public_gate/normalized_schema_snapshot.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabsyn/tabsyn-c15-20260426_203054/public_gate/public_gate_report.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabsyn/tabsyn-c15-20260426_203054/public_gate/staged_input_manifest.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabsyn/tabsyn-c15-20260426_203054/runtime_result.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabsyn/tabsyn-c15-20260426_203054/staged/public/staged_features.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabsyn/tabsyn-c15-20260426_203054/staged/public/test.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabsyn/tabsyn-c15-20260426_203054/staged/public/train.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabsyn/tabsyn-c15-20260426_203054/staged/public/val.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabsyn/tabsyn-c15-20260426_203054/staged/tabsyn/adapter_report.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabsyn/tabsyn-c15-20260426_203054/staged/tabsyn/adapter_transforms_applied.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabsyn/tabsyn-c15-20260426_203054/staged/tabsyn/model_input_manifest.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabsyn/tabsyn-c15-20260426_203054/synthetic/tabsyn_c15/real.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabsyn/tabsyn-c15-20260426_203054/synthetic/tabsyn_c15/test.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabsyn/tabsyn-c15-20260426_203054/tabsyn-c15-480000-20260427_004432.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tabsyn/tabsyn-c15-20260426_203054/train_20260426_203129.log filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tvae/tvae-c15-20260419_073541/gen_20260419_133821.log filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tvae/tvae-c15-20260419_073541/gen_20260419_181017.log filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tvae/tvae-c15-20260419_073541/input_snapshot.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tvae/tvae-c15-20260419_073541/models_300epochs/train_20260419_073620.log filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tvae/tvae-c15-20260419_073541/models_300epochs/tvae_300epochs.pt filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tvae/tvae-c15-20260419_073541/public_gate/normalized_schema_snapshot.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tvae/tvae-c15-20260419_073541/public_gate/public_gate_report.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tvae/tvae-c15-20260419_073541/public_gate/staged_input_manifest.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tvae/tvae-c15-20260419_073541/runtime_result.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tvae/tvae-c15-20260419_073541/staged/public/staged_features.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c15/tvae/tvae-c15-20260419_073541/staged/public/test.csv filter=lfs diff=lfs merge=lfs -text

SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/50/all_results.json

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

SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/50/ema/all_results.json

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

SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/50/ema/samples.csv

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

SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/50/ema/shapes.csv

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

SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/50/ema/trends.csv

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

SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/50/samples.csv

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

SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/50/shapes.csv

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

SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/50/trends.csv

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

SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/60/all_results.json

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

SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/60/ema/all_results.json

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

SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/60/ema/samples.csv

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

SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/60/ema/shapes.csv

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

SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/60/ema/trends.csv

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

SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/60/samples.csv

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

SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/60/shapes.csv

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

SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/60/trends.csv

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

SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/70/all_results.json

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

SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/70/ema/all_results.json

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

SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/70/ema/samples.csv

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

SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/70/ema/shapes.csv

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

SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/70/ema/trends.csv

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

SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/70/samples.csv

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

SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/70/shapes.csv

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

SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/70/trends.csv

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

SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/80/all_results.json

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

SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/80/ema/all_results.json

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

SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/80/ema/samples.csv

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

SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/80/ema/shapes.csv

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

SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/80/ema/trends.csv

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

SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/80/samples.csv

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

SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/80/shapes.csv

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

SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/80/trends.csv

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

SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/90/all_results.json

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

SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/90/ema/all_results.json

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

SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/90/ema/samples.csv

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

SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/90/ema/shapes.csv

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

SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/90/ema/trends.csv

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

SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/90/samples.csv

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

SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/90/shapes.csv

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

SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/result/pipeline_c15/adapter_efvfm/90/trends.csv

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

SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/src/__init__.py

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

SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/src/data.py

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

SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/src/env.py

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

SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/src/metrics.py

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

SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/src/util.py

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

SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/synthetic/pipeline_c15/real.csv

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

SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/synthetic/pipeline_c15/test.csv

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

SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/synthetic/pipeline_c15/val.csv

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

SynthData0523/main/c15/tabbyflow/tabbyflow-c15-20260513_061551/_efvfm_runtime/tests/conftest.py

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