Resume SynthData0523 main/c19 batch 4

.gitattributes

@@ -2790,3 +2790,32 @@ SynthData0523/main/c19/realtabformer/rtf-c19-20260513_062753/staged/public/val.c
 SynthData0523/main/c19/realtabformer/rtf-c19-20260513_062753/staged/realtabformer/adapter_report.json filter=lfs diff=lfs merge=lfs -text
 SynthData0523/main/c19/realtabformer/rtf-c19-20260513_062753/staged/realtabformer/adapter_transforms_applied.json filter=lfs diff=lfs merge=lfs -text
 SynthData0523/main/c19/realtabformer/rtf-c19-20260513_062753/staged/realtabformer/model_input_manifest.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c19/realtabformer/rtf-c19-20260513_062753/train_20260513_062755.log filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/data/pipeline_c19/X_cat_test.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/data/pipeline_c19/X_cat_train.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/data/pipeline_c19/X_cat_val.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/data/pipeline_c19/X_num_test.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/data/pipeline_c19/X_num_train.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/data/pipeline_c19/X_num_val.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/data/pipeline_c19/info.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/data/pipeline_c19/real.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/data/pipeline_c19/staged_features.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/data/pipeline_c19/test.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/data/pipeline_c19/train.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/data/pipeline_c19/val.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/data/pipeline_c19/y_test.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/data/pipeline_c19/y_train.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/data/pipeline_c19/y_val.npy filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/ef_vfm/ckpt/pipeline_c19/adapter_efvfm/config.pkl filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/ef_vfm/ckpt/pipeline_c19/adapter_efvfm/ema_model_100.pt filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/ef_vfm/ckpt/pipeline_c19/adapter_efvfm/model_100.pt filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/ef_vfm/configs/ef_vfm_configs.toml filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/ef_vfm/result/pipeline_c19/adapter_efvfm/100/all_results.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/ef_vfm/result/pipeline_c19/adapter_efvfm/100/ema/all_results.json filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/ef_vfm/result/pipeline_c19/adapter_efvfm/100/ema/samples.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/ef_vfm/result/pipeline_c19/adapter_efvfm/100/ema/shapes.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/ef_vfm/result/pipeline_c19/adapter_efvfm/100/ema/trends.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/ef_vfm/result/pipeline_c19/adapter_efvfm/100/samples.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/ef_vfm/result/pipeline_c19/adapter_efvfm/100/shapes.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/ef_vfm/result/pipeline_c19/adapter_efvfm/100/trends.csv filter=lfs diff=lfs merge=lfs -text
+SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/pyproject.toml filter=lfs diff=lfs merge=lfs -text

SynthData0523/main/c19/realtabformer/rtf-c19-20260513_062753/train_20260513_062755.log

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

SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/.gitignore

@@ -0,0 +1,174 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+.DS_Store
+# data/adult
+data/beijing
+data/default
+data/magic
+data/news
+data/shoppers
+
+wandb/
+
+*.DS_Store

SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/LICENCE

@@ -0,0 +1,7 @@
+Copyright 2024 Andrés Guzmán-Cordero
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/README.md

@@ -0,0 +1,128 @@
+# Exponential Family Variational Flow Matching for Tabular Data Generation
+
+<p align="center">
+  <a href="https://github.com/andresguzco/ef-vfm/blob/main/LICENSE.txt">
+    <img alt="MIT License" src="https://img.shields.io/badge/License-MIT-yellow.svg">
+  </a>
+  <a href="https://openreview.net/pdf?id=kjtvCSkSsy">
+    <img alt="Openreview" src="https://img.shields.io/badge/review-OpenReview-blue">
+  </a>
+  <a href="https://arxiv.org/pdf/2506.05940">
+    <img alt="Paper URL" src="https://img.shields.io/badge/cs.LG-2506.05940-B31B1B.svg">
+  </a>
+</p>
+
+<div align="center">
+  <img src="images/demo.jpg" alt="Model Logo" width="800" style="margin-left:'auto' margin-right:'auto' display:'block'"/>
+  <p><em> Figure 1: Exponential Family Variational Flow Matching (EF-VFM) is a generative modeling framework designed for mixed continuous
+and discrete variables. By leveraging the exponential family and a mean-field assumption, EF-VFM efficiently matches the sufficient
+statistics of the distributions via learned probability paths, ensuring state-of-the-art fidelity and diversity in synthetic data.</a></em></p>
+</div>
+
+This repository provides the prototypical implementation of EF-VFM: TabbyFlow (ICML, 2025).
+
+## Latest Update
+
+- [2025.09]：We are finally releasing our code! To speed the release and avoid compatibility isues, we removed the hyperparameter scripts we use to launch out experiments in our available cluster. Contact us if you have any questions!
+
+## Introduction
+
+EF-VFM uses the exponential family to jointly model different distributions with a single variational flow matching framework. Its key contributions are:  
+
+1) We propose Exponential Family Variational Flow Matching (EF-VFM), an extension of VFM that incorporates exponential family distributions that facilitates efficient training via moment matching.
+2) We establish a deep connection between VFM and a generalized flow matching objective through the lens of Bregman divergences, offering a theoretical foundation for learning probability paths over mixed data types.
+3) To demonstrate the effectiveness of EF-VFM, we introduce TabbyFlow, a model that achieves state-of-the-art performance on standard tabular benchmarks, improving both fidelity and diversity in synthetic data generation.
+
+The schema of EF-VFM is presented in the figure above. For more details, please refer to [our paper](https://arxiv.org/pdf/2506.05940).
+
+## Environment Setup
+
+Create the main environment with [ef_vfm.yaml](ef_vfm.yaml). This environment will be used for all tasks except for the evaluation of additional data fidelity metrics (i.e., $\alpha$-precision and $\beta$-recall scores)
+
+```conda env create -f ef_vfm.yaml```
+
+Create another environment with [synthcity.yaml](synthcity.yaml) to evaluate additional data fidelity metrics
+
+```conda env create -f synthcity.yaml```
+
+## Datasets Preparation
+
+### Using the datasets experimented in the paper
+
+Download raw datasets:
+
+```python download_dataset.py```
+
+Process datasets:
+
+```python process_dataset.py```
+
+## Training TabbyFlow
+
+To train an unconditional EF-VFM model across the entire table, run
+
+```python main.py --dataname <NAME_OF_DATASET> --mode train --exp_name <EXP_NAME>```
+
+where ```<NAME_OF_DATASET>``` is the name of the dataset you want to train on, and ```<EXP_NAME>``` is the name of your experiment.
+
+Current Options of ```<NAME_OF_DATASET>``` are: adult, default, shoppers, magic, beijing, news
+
+Wanb logging is enabled by default. To disable it and log locally, add the ```--no_wandb``` flag.
+
+You must specify the experiment name, which will be used for logging and saving files, add ```--exp_name <your experiment name>```.
+
+## Sampling and Evaluating TabbyFlow (Density, MLE, C2ST)
+
+To sample synthetic tables from trained EF-VFM models and evaluate them, run
+
+```python main.py --dataname <NAME_OF_DATASET> --mode test --report --no_wandb --exp_name <EXP_NAME>```
+
+where ```<NAME_OF_DATASET>``` and ```<EXP_NAME>``` should be the same as those used in training.
+
+This will sample 20 synthetic tables randomly. Meanwhile, it will evaluate the density, mle, and c2st scores for each sample and report their average and standard deviation. The results will be printed out in the terminal, and the samples and detailed evaluation results will be placed in ./eval/report_runs/<EXP_NAME>/<NAME_OF_DATASET>/.
+
+## Evaluating on Additional Fidelity Metrics ($\alpha$-precision and $\beta$-recall scores)
+
+To evaluate EF-VFM on the additional fidelity metrics ($\alpha$-precision and $\beta$-recall scores), you need to first make sure that you have already generated some samples by the previous commands. Then, you need to switch to the `synthcity` environment (as the synthcity packet used to compute those metrics conflicts with the main environment), by running
+
+```conda activate synthcity```
+
+Then, evaluate the metrics by running
+
+```python eval/eval_quality.py --dataname <NAME_OF_DATASET>```
+
+Similarly, the results will be printed out in the terminal and added to ./eval/report_runs/<EXP_NAME>/<NAME_OF_DATASET>/
+
+## Evaluating Data Privacy (DCR score)
+
+To evalute the privacy metric DCR score, you first need to retrain all the models, as the metric requires an equal split between the training and testing data (our initial splits employ a 90/10 ratio). To retrain with an equal split, run the training command but append `_dcr` to ```<NAME_OF_DATASET>```
+
+```python main.py --dataname <NAME_OF_DATASET>_dcr --mode train```
+
+Then, test the models on DCR with the same `_dcr` suffix
+
+```python main.py --dataname <NAME_OF_DATASET>_dcr --mode test --report --no_wandb```
+
+## License
+
+This work is licensed under the MIT License.
+
+## Acknowledgement
+
+This repo is built upon the previous work TabDiff's [[codebase]](https://github.com/MinkaiXu/TabDiff). Many thanks to Juntong, Minkai, Harper and Hengrui!
+
+## Citation
+
+```@inproceedings{
+guzmancordero2025exponentialfamily,
+title={Exponential Family Variational Flow Matching for Tabular Data Generation},
+author={Andr\'es Guzm\'an-Cordero and Floor Eijkelboom and Jan-Willem van de Meent},
+booktitle={The Forty-Second International Conference on Machine Learning},
+year={2025},
+url={https://openreview.net/forum?id=kjtvCSkSsy}
+}
+```
+
+## Contact
+
+If you encounter any problem or you have any question regarding the paper, please contact [Andrés](andresguzco@gmail.com).

SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/data/pipeline_c19/X_cat_test.npy

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

SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/data/pipeline_c19/X_cat_train.npy

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

SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/data/pipeline_c19/X_cat_val.npy

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

SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/data/pipeline_c19/X_num_test.npy

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

SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/data/pipeline_c19/X_num_train.npy

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

SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/data/pipeline_c19/X_num_val.npy

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

SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/data/pipeline_c19/info.json

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

SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/data/pipeline_c19/real.csv

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

SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/data/pipeline_c19/staged_features.json

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

SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/data/pipeline_c19/test.csv

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

SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/data/pipeline_c19/train.csv

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

SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/data/pipeline_c19/val.csv

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

SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/data/pipeline_c19/y_test.npy

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

SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/data/pipeline_c19/y_train.npy

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

SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/data/pipeline_c19/y_val.npy

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

SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/download_dataset.py

@@ -0,0 +1,49 @@
+import os
+from urllib import request
+import zipfile
+
+DATA_DIR = 'data'
+
+
+NAME_URL_DICT_UCI = {
+    'adult': 'https://archive.ics.uci.edu/static/public/2/adult.zip',
+    'default': 'https://archive.ics.uci.edu/static/public/350/default+of+credit+card+clients.zip',
+    'magic': 'https://archive.ics.uci.edu/static/public/159/magic+gamma+telescope.zip',
+    'shoppers': 'https://archive.ics.uci.edu/static/public/468/online+shoppers+purchasing+intention+dataset.zip',
+    'beijing': 'https://archive.ics.uci.edu/static/public/381/beijing+pm2+5+data.zip',
+    'news': 'https://archive.ics.uci.edu/static/public/332/online+news+popularity.zip',
+    'news_nocat': 'https://archive.ics.uci.edu/static/public/332/online+news+popularity.zip',
+    'adult_dcr': 'https://archive.ics.uci.edu/static/public/2/adult.zip',
+    'default_dcr': 'https://archive.ics.uci.edu/static/public/350/default+of+credit+card+clients.zip',
+    'magic_dcr': 'https://archive.ics.uci.edu/static/public/159/magic+gamma+telescope.zip',
+    'shoppers_dcr': 'https://archive.ics.uci.edu/static/public/468/online+shoppers+purchasing+intention+dataset.zip',
+    'beijing_dcr': 'https://archive.ics.uci.edu/static/public/381/beijing+pm2+5+data.zip',
+    'news_dcr': 'https://archive.ics.uci.edu/static/public/332/online+news+popularity.zip',
+}
+
+def unzip_file(zip_filepath, dest_path):
+    with zipfile.ZipFile(zip_filepath, 'r') as zip_ref:
+        zip_ref.extractall(dest_path)
+
+
+def download_from_uci(name):
+
+    print(f'Start processing dataset {name} from UCI.')
+    save_dir = f'{DATA_DIR}/{name}'
+    if not os.path.exists(save_dir):
+        os.makedirs(save_dir)
+
+        url = NAME_URL_DICT_UCI[name]
+        request.urlretrieve(url, f'{save_dir}/{name}.zip')
+        print(f'Finish downloading dataset from {url}, data has been saved to {save_dir}.')
+        
+        unzip_file(f'{save_dir}/{name}.zip', save_dir)
+        print(f'Finish unzipping {name}.')
+    
+    else:
+        print('Aready downloaded.')
+
+if __name__ == '__main__':
+    for name in NAME_URL_DICT_UCI.keys():
+        download_from_uci(name)
+    

SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/ef_vfm/ckpt/pipeline_c19/adapter_efvfm/config.pkl

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

SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/ef_vfm/ckpt/pipeline_c19/adapter_efvfm/ema_model_100.pt

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

SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/ef_vfm/ckpt/pipeline_c19/adapter_efvfm/model_100.pt

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

SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/ef_vfm/configs/ef_vfm_configs.toml

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

SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/ef_vfm/main.py

@@ -0,0 +1,246 @@
+import glob
+import json
+import os
+import pickle
+import random
+
+import numpy as np
+from ef_vfm.metrics import TabMetrics
+from ef_vfm.modules.main_modules import UniModMLP
+from ef_vfm.models.flow_model import ExpVFM
+from ef_vfm.trainer import Trainer
+import src
+import torch
+
+from torch.utils.data import DataLoader
+import argparse
+import warnings
+
+import wandb
+
+
+from utils_train import EFVFMDataset
+
+warnings.filterwarnings('ignore')
+
+
+def main(args):
+    device = args.device
+
+    ## Disable scientific numerical format
+    np.set_printoptions(suppress=True)
+    torch.set_printoptions(sci_mode=False)
+
+    ## Get data info
+    dataname = args.dataname
+    data_dir = f'data/{dataname}'
+    info_path = f'data/{dataname}/info.json'
+    with open(info_path, 'r') as f:
+        info = json.load(f)
+    
+    ## Set up flags
+    is_dcr = 'dcr' in dataname
+
+    ## Set experiment name
+    exp_name = args.exp_name
+    assert args.exp_name is not None, "Experiment name must be provided"
+    
+    ## Load configs
+    curr_dir = os.path.dirname(os.path.abspath(__file__))
+    config_path = f'{curr_dir}/configs/ef_vfm_configs.toml'
+    raw_config = src.load_config(config_path)
+    
+    print(f"{args.mode.capitalize()} Mode is Enabled")
+    num_samples_to_generate = None
+    ckpt_path = None
+    if args.mode == 'train':
+        print("NEW training is started")
+    elif args.mode == 'test':
+        num_samples_to_generate = args.num_samples_to_generate
+        ckpt_path = args.ckpt_path
+        if ckpt_path is None:
+            ckpt_parent_path = f"{curr_dir}/ckpt/{dataname}/{exp_name}"
+            ckpt_path_arr = glob.glob(f"{ckpt_parent_path}/best_ema_model*")
+            assert ckpt_path_arr, f"Cannot not infer ckpt_path from {ckpt_parent_path}, please make sure that you first train a model before testing!"
+            ckpt_path = ckpt_path_arr[0]
+        config_path = os.path.join(os.path.dirname(ckpt_path), 'config.pkl')
+        if os.path.exists(config_path):
+            with open(config_path, 'rb') as f:
+                cached_raw_config = pickle.load(f)
+                print(f"Found cached config at {config_path}")
+        raw_config = cached_raw_config
+    
+    
+    ## Creat model_save and result paths
+    model_save_path, result_save_path = None, None
+    if args.mode == 'train':
+        model_save_path = 'debug/ckpt' if args.debug else f'{curr_dir}/ckpt/{dataname}/{exp_name}'
+        result_save_path = model_save_path.replace('ckpt', 'result')  #i.e., f'{curr_dir}/results/{dataname}/{exp_name}'
+    elif args.mode == 'test':
+        if args.report:
+            result_save_path = f"eval/report_runs/{exp_name}/{dataname}"
+        else:
+            result_save_path = os.path.dirname(ckpt_path).replace('ckpt', 'result')    # infer the exp_name from the ckpt_name
+    raw_config['model_save_path'] = model_save_path
+    raw_config['result_save_path'] = result_save_path
+    if model_save_path is not None:
+        if not os.path.exists(model_save_path):
+            os.makedirs(model_save_path)
+    if result_save_path is not None:
+        if not os.path.exists(result_save_path):
+            os.makedirs(result_save_path)
+    
+    ## Make everything determinstic if needed
+    raw_config['deterministic'] = args.deterministic
+    if args.deterministic:
+        print("DETERMINISTIC MODE is enabled!!!")
+        ## Set global random seeds
+        torch.manual_seed(0)
+        random.seed(0)
+        np.random.seed(0)
+
+        ## Ensure deterministic CUDA operations
+        os.environ['PYTHONHASHSEED'] = '0'
+        os.environ['CUBLAS_WORKSPACE_CONFIG'] = ':4096:8'  # or ':16:8'
+        torch.use_deterministic_algorithms(True)
+        if torch.cuda.is_available():
+            torch.cuda.manual_seed(0)
+            torch.cuda.manual_seed_all(0)
+            torch.backends.cudnn.deterministic = True
+            torch.backends.cudnn.benchmark = False
+    
+    ## Set debug mode parameters
+    if args.debug:  # fast eval for DEBUG mode
+        raw_config['train']['main']['check_val_every'] = 2
+        raw_config['train']['main']['batch_size'] = 4096
+        raw_config['sample']['batch_size'] = 10000
+
+    _smoke = os.environ.get("EFVFM_SMOKE_STEPS", "").strip()
+    if _smoke and args.mode == "train":
+        n = max(1, int(_smoke))
+        raw_config["train"]["main"]["steps"] = n
+        raw_config["train"]["main"]["check_val_every"] = max(
+            1, min(n, raw_config["train"]["main"]["check_val_every"])
+        )
+    if os.environ.get("EFVFM_ADAPTER_TRAIN", "").strip() and args.mode == "train":
+        raw_config["train"]["main"]["check_val_every"] = int(raw_config["train"]["main"]["steps"])
+
+    _sample_batch = os.environ.get("EFVFM_SAMPLE_BATCH_SIZE", "").strip()
+    if _sample_batch:
+        raw_config["sample"]["batch_size"] = max(1, int(_sample_batch))
+    _train_workers = os.environ.get("EFVFM_TRAIN_NUM_WORKERS", "").strip()
+    train_num_workers = max(0, int(_train_workers)) if _train_workers else 4
+
+    ## Load training data
+    batch_size = raw_config['train']['main']['batch_size']
+
+    train_data = EFVFMDataset(dataname, data_dir, info, isTrain=True, dequant_dist=raw_config['data']['dequant_dist'], int_dequant_factor=raw_config['data']['int_dequant_factor'])
+    train_loader = DataLoader(
+        train_data,
+        batch_size = batch_size,
+        shuffle = True,
+        num_workers = train_num_workers,
+    )
+    d_numerical, categories = train_data.d_numerical, train_data.categories
+    
+    val_data = EFVFMDataset(dataname, data_dir, info, isTrain=False, dequant_dist=raw_config['data']['dequant_dist'], int_dequant_factor=raw_config['data']['int_dequant_factor'])
+
+    ## Load Metrics
+    real_data_path = f'synthetic/{dataname}/real.csv'
+    test_data_path = f'synthetic/{dataname}/test.csv'
+    val_data_path = f'synthetic/{dataname}/val.csv'
+    if not os.path.exists(val_data_path):
+        print(f"{args.dataname} does not have its validation set. During MLE evaluation, a validation set will be splitted from the training set!")
+        val_data_path = None
+    if args.mode == 'train':
+        metric_list = ["density"]
+    else:
+        if is_dcr:
+            metric_list = ["dcr"]
+        else:
+            metric_list = [
+                "density", 
+                "mle", 
+                "c2st",
+            ]
+    metrics = TabMetrics(real_data_path, test_data_path, val_data_path, info, device, metric_list=metric_list)
+    
+    ## Load the module and models
+    raw_config['unimodmlp_params']['d_numerical'] = d_numerical
+    raw_config['unimodmlp_params']['categories'] = (categories).tolist() 
+    model = UniModMLP(**raw_config['unimodmlp_params'])
+    model.to(device)
+    
+    flow_model = ExpVFM(
+        num_classes=categories,
+        num_numerical_features=d_numerical,
+        vf_fn=model,
+        device=device,
+    )
+    num_params = sum(p.numel() for p in flow_model.parameters())
+    print("The number of parameters = ", num_params)
+    flow_model.to(device)
+    flow_model.train()
+
+    ## Print the configs
+    printed_configs = json.dumps(raw_config, default=lambda x: int(x) if isinstance(x, np.int64) else x, indent=4)
+    print(f"The config of the current run is : \n {printed_configs}")
+    
+    ## Enable Wandb
+    project_name = f"XVFM_{dataname}"
+    raw_config['project_name'] = project_name
+    logger = wandb.init(
+        project=raw_config['project_name'], 
+        name=exp_name,
+        config=raw_config,
+        mode='disabled' if args.debug or args.no_wandb else 'online',
+    )
+
+    ## Load Trainer
+    sample_batch_size = raw_config['sample']['batch_size']
+    trainer = Trainer(
+        flow_model,
+        train_loader,
+        train_data,
+        val_data,
+        metrics,
+        logger,
+        **raw_config['train']['main'],
+        sample_batch_size=sample_batch_size,
+        num_samples_to_generate=num_samples_to_generate,
+        model_save_path=raw_config['model_save_path'],
+        result_save_path=raw_config['result_save_path'],
+        device=device,
+        ckpt_path=ckpt_path,
+    )
+    if args.mode == 'test':
+        if args.report:
+            if  is_dcr:
+                trainer.report_test_dcr(args.num_runs)
+            else:
+                trainer.report_test(args.num_runs)
+        else:
+            trainer.test()
+    else:
+        ## Save config
+        config_save_path = raw_config['model_save_path']
+        with open (os.path.join(config_save_path, 'config.pkl'), 'wb') as f:
+            pickle.dump(raw_config, f)
+        trainer.run_loop()
+
+
+
+if __name__ == '__main__':
+
+    parser = argparse.ArgumentParser(description='Training of TabbyFlow')
+
+    parser.add_argument('--dataname', type=str, default='adult', help='Name of dataset.')
+    parser.add_argument('--gpu', type=int, default=0, help='GPU index.')
+
+    args = parser.parse_args()
+
+    # check cuda
+    if args.gpu != -1 and torch.cuda.is_available():
+        args.device = f'cuda:{args.gpu}'
+    else:
+        args.device = 'cpu'

SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/ef_vfm/metrics.py

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

SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/ef_vfm/models/flow_model.py

@@ -0,0 +1,195 @@
+import torch.nn.functional as F
+import torch
+import numpy as np
+from torchdiffeq import odeint_adjoint as odeint
+
+
+class ExpVFM(torch.nn.Module):
+    def __init__(
+            self,
+            num_classes: np.array,
+            num_numerical_features: int,
+            vf_fn,
+            device=torch.device('cpu'),
+            **kwargs
+        ):
+
+        super(ExpVFM, self).__init__()
+
+        self.num_numerical_features = num_numerical_features
+        self.num_classes = num_classes # it as a vector [K1, K2, ..., Km]
+        self.num_classes_expanded = torch.from_numpy(
+            np.concatenate([num_classes[i].repeat(num_classes[i]) for i in range(len(num_classes))])
+        ).to(device) if len(num_classes)>0 else torch.tensor([]).to(device).int()
+        self.neg_infinity = -1000000.0 
+
+        offsets = np.cumsum(self.num_classes)
+        offsets = np.append([0], offsets)
+        self.slices_for_classes = []
+        for i in range(1, len(offsets)):
+            self.slices_for_classes.append(np.arange(offsets[i - 1], offsets[i]))
+        self.offsets = torch.from_numpy(offsets).to(device)
+        
+        offsets = np.cumsum(self.num_classes) + np.arange(1, len(self.num_classes)+1)
+        offsets = np.append([0], offsets)
+
+        self._vf_fn = vf_fn
+        self.device = device
+    
+
+    def mixed_loss(self, x):
+        b = x.shape[0]
+        dev = x.device
+
+        x_num = x[:, :self.num_numerical_features]
+        x_cat = x[:, self.num_numerical_features:].long()
+
+        t = torch.rand(b, device=dev, dtype=x_num.dtype)
+        t = t[:, None]
+            
+        # Continuous interpolation
+        x_num_t = x_num
+        if x_num.shape[1] > 0:
+            noise = torch.randn_like(x_num)
+            x_num_t = t * x_num + (1 - t) * noise # + noise * sigma_num
+        
+        # Discrete interpolation
+        x_cat_oh = self.to_one_hot(x_cat).float()
+        x_cat_t = x_cat_oh
+        if x_cat.shape[1] > 0:
+            x_cat_t = t * x_cat_oh + (1 - t) * torch.randn_like(x_cat_oh)
+
+        # Predict orignal data (distribution)
+        model_out_num, model_out_cat = self._vf_fn(x_num_t, x_cat_t, t.squeeze())
+
+        d_loss = torch.zeros((1,)).float()
+        c_loss = torch.zeros((1,)).float()
+
+        # Compute the loss
+        if x_num.shape[1] > 0:
+            c_loss = self._mvgloss(model_out_num, x_num, t)
+
+        if x_cat.shape[1] > 0:
+            d_loss = self._absorbed_closs(model_out_cat, x_cat, self._vf_fn.categories)
+            
+        return d_loss.mean(), c_loss.mean()
+    
+    def _mvgloss(self, mu_t, x_num_t, t):
+        n, k = mu_t.shape
+        dev = mu_t.device
+        dt = mu_t.dtype
+
+        identity = torch.eye(k, device=dev, dtype=dt).unsqueeze(0).expand(n, -1, -1)
+        scale = 1 - (1 - 0.01) * t.unsqueeze(1) ** 2
+        sigma = scale * identity
+        dist = torch.distributions.MultivariateNormal(mu_t, sigma)
+        return -dist.log_prob(x_num_t).mean()
+
+    @torch.no_grad()
+    def sample(self, num_samples):
+        dev = self.device
+        dt = torch.float32
+        d_in = self.num_numerical_features + sum(self.num_classes)
+        d_out = self.num_numerical_features + len(self.num_classes)
+
+        x0 = torch.randn(num_samples, d_in, device=dev)
+        t = torch.tensor([0.0, 0.999]).to(dev)
+        vf = Velocity(self._vf_fn)
+        trajectory = odeint(vf, x0, t, method="dopri5", rtol=1e-5, atol=1e-5)
+        out = trajectory[1]
+
+        sample = torch.zeros(num_samples, d_out, device=dev, dtype=dt)
+        sample[:, :self.num_numerical_features] = out[:, :self.num_numerical_features].to(torch.float32)
+        if sum(self.num_classes) != 0:
+            idx = self.num_numerical_features
+            for i, val in enumerate(self.num_classes):
+                col = self.num_numerical_features + i
+                sample[:, col] = torch.argmax(out[:, idx:idx + val], dim=1)
+                idx += val
+                assert val >= sample[:, col].max() >= 0, f"Sampled value {sample[:, col].max()} is out of range for categorical feature {i} with {val} classes."
+
+        return sample.cpu()
+    
+    def sample_all(self, num_samples, batch_size, keep_nan_samples=False):        
+        b = batch_size
+
+        all_samples = []
+        num_generated = 0
+        while num_generated < num_samples:
+            print(f"Samples left to generate: {num_samples-num_generated}")
+            sample = self.sample(b)
+            mask_nan = torch.any(sample.isnan(), dim=1)
+            if keep_nan_samples:
+                # If the sample instances that contains Nan are decided to be kept, the row with Nan will be foreced to all zeros
+                sample = sample * (~mask_nan)[:, None]
+            else:
+                # Otherwise the instances with Nan will be eliminated
+                sample = sample[~mask_nan]
+
+            all_samples.append(sample)
+            num_generated += sample.shape[0]
+
+        x_gen = torch.cat(all_samples, dim=0)[:num_samples]
+
+        return x_gen
+
+    def to_one_hot(self, x_cat):
+        if len(self.num_classes) == 0:
+            return torch.zeros(x_cat.shape[0], 0, device=x_cat.device, dtype=torch.long)
+        x_cat_oh = torch.cat(
+            [F.one_hot(x_cat[:, i], num_classes=self.num_classes[i]) for i in range(len(self.num_classes))],
+            dim=-1
+        )
+        return x_cat_oh
+    
+    def _absorbed_closs(self, model_output, x0, cats): #, sigma, dsigma):
+        """
+            alpha: (bs,)
+        """
+        cum_sum =0
+        losses = torch.zeros(len(cats), device=model_output.device)
+        for i, val in enumerate(cats):
+            dist = torch.distributions.Categorical(logits=model_output[:, cum_sum:cum_sum+val])
+            losses[i] = -dist.log_prob(x0[:, i]).mean()
+            cum_sum += val
+
+        loss = losses.sum()
+        return loss
+    
+
+class Velocity(torch.nn.Module):
+    def __init__(self, model):
+        super(Velocity, self).__init__()
+        self.model = model
+
+    def forward(self, t, x):
+        t = t * torch.ones(x.shape[0]).to(x.device)
+
+        x_num = x[:, :self.model.d_numerical]
+        x_cat = x[:, self.model.d_numerical:]
+        mu, logits = self.model(x_num, x_cat, t)
+
+        # Numerical velocity
+        if self.model.d_numerical > 0:
+            v_num = (mu - (1 - 0.01) * x_num) / (1 - (1 - 0.01) * t.unsqueeze(1))
+        else:
+            v_num = torch.zeros_like(x_num)
+
+        # Categorical velocity: normalize logits into probability space before computing velocity
+        if len(self.model.categories) > 0:
+            v_cat_parts = []
+            logit_idx = 0
+            oh_idx = 0
+            for k in self.model.categories:
+                probs_k = F.softmax(logits[:, logit_idx:logit_idx + k], dim=-1)
+                x_k = x_cat[:, oh_idx:oh_idx + k]
+                v_k = (probs_k - (1 - 0.01) * x_k) / (1 - (1 - 0.01) * t.unsqueeze(1))
+                v_cat_parts.append(v_k)
+                logit_idx += k
+                oh_idx += k
+            v_cat = torch.cat(v_cat_parts, dim=1)
+        else:
+            v_cat = torch.zeros_like(x_cat)
+
+        v_t = torch.cat([v_num, v_cat], dim=1)
+        return v_t

SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/ef_vfm/modules/main_modules.py

@@ -0,0 +1,102 @@
+from typing import Callable, Union
+
+from ef_vfm.modules.transformer import Reconstructor, Tokenizer, Transformer
+import torch
+import torch.nn as nn
+import torch.optim
+
+ModuleType = Union[str, Callable[..., nn.Module]]
+
+class SiLU(nn.Module):
+    def forward(self, x):
+        return x * torch.sigmoid(x)
+
+
+class PositionalEmbedding(torch.nn.Module):
+    def __init__(self, num_channels, max_positions=10000, endpoint=False):
+        super().__init__()
+        self.num_channels = num_channels
+        self.max_positions = max_positions
+        self.endpoint = endpoint
+
+    def forward(self, x):
+        freqs = torch.arange(start=0, end=self.num_channels//2, dtype=torch.float32, device=x.device)
+        freqs = freqs / (self.num_channels // 2 - (1 if self.endpoint else 0))
+        freqs = (1 / self.max_positions) ** freqs
+        x = x.ger(freqs.to(x.dtype))
+        x = torch.cat([x.cos(), x.sin()], dim=1)
+        return x
+
+
+class MLP(nn.Module):
+    def __init__(self, d_in, dim_t = 512, use_mlp=True):
+        super().__init__()
+        self.dim_t = dim_t
+
+        self.proj = nn.Linear(d_in, dim_t)
+
+        self.mlp = nn.Sequential(
+            nn.Linear(dim_t, dim_t * 2),
+            nn.SiLU(),
+            nn.Linear(dim_t * 2, dim_t * 2),
+            nn.SiLU(),
+            nn.Linear(dim_t * 2, dim_t),
+            nn.SiLU(),
+            nn.Linear(dim_t, d_in),
+        ) if use_mlp else nn.Linear(dim_t, d_in)
+
+        self.map_noise = PositionalEmbedding(num_channels=dim_t)
+        self.time_embed = nn.Sequential(
+            nn.Linear(dim_t, dim_t),
+            nn.SiLU(),
+            nn.Linear(dim_t, dim_t)
+        )
+        
+        self.use_mlp = use_mlp
+    
+    def forward(self, x, timesteps):
+        emb = self.map_noise(timesteps)
+        emb = emb.reshape(emb.shape[0], 2, -1).flip(1).reshape(*emb.shape) # swap sin/cos
+        emb = self.time_embed(emb)
+    
+        x = self.proj(x) + emb
+        return self.mlp(x)
+    
+
+class UniModMLP(nn.Module):
+    """
+        Input:
+            x_num: [bs, d_numerical]
+            x_cat: [bs, len(categories)]
+        Output:
+            x_num_pred: [bs, d_numerical], the predicted mean for numerical data
+            x_cat_pred: [bs, sum(categories)], the predicted UNORMALIZED logits for categorical data
+    """
+    def __init__(
+            self, d_numerical, categories, num_layers, d_token,
+            n_head = 1, factor = 4, bias = True, dim_t=512, use_mlp=True,
+            activation='gelu', **kwargs
+        ):
+        super().__init__()
+        self.d_numerical = d_numerical
+        self.categories = categories
+
+        self.tokenizer = Tokenizer(d_numerical, categories, d_token, bias = bias)
+        self.encoder = Transformer(num_layers, d_token, n_head, d_token, factor, activation=activation)
+        d_in = d_token * (d_numerical + len(categories))
+        self.mlp = MLP(d_in, dim_t=dim_t, use_mlp=use_mlp)
+        self.decoder = Transformer(num_layers, d_token, n_head, d_token, factor, activation=activation)
+        self.detokenizer = Reconstructor(d_numerical, categories, d_token)
+        
+        self.model = nn.ModuleList([self.tokenizer, self.encoder, self.mlp, self.decoder, self.detokenizer])
+
+    def forward(self, x_num, x_cat, timesteps):
+        e = self.tokenizer(x_num, x_cat)
+        decoder_input = e[:, 1:, :]        # ignore the first CLS token. 
+        y = self.encoder(decoder_input)
+        pred_y = self.mlp(y.reshape(y.shape[0], -1), timesteps)
+        pred_e = self.decoder(pred_y.reshape(*y.shape))
+        x_num_pred, x_cat_pred = self.detokenizer(pred_e)
+        x_cat_pred = torch.cat(x_cat_pred, dim=-1) if len(x_cat_pred)>0 else torch.zeros_like(x_cat).to(x_num_pred.dtype)
+
+        return x_num_pred, x_cat_pred

SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/ef_vfm/modules/transformer.py

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

SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/ef_vfm/result/pipeline_c19/adapter_efvfm/100/all_results.json

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

SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/ef_vfm/result/pipeline_c19/adapter_efvfm/100/ema/all_results.json

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

SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/ef_vfm/result/pipeline_c19/adapter_efvfm/100/ema/samples.csv

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

SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/ef_vfm/result/pipeline_c19/adapter_efvfm/100/ema/shapes.csv

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

SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/ef_vfm/result/pipeline_c19/adapter_efvfm/100/ema/trends.csv

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

SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/ef_vfm/result/pipeline_c19/adapter_efvfm/100/samples.csv

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

SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/ef_vfm/result/pipeline_c19/adapter_efvfm/100/shapes.csv

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

SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/ef_vfm/result/pipeline_c19/adapter_efvfm/100/trends.csv

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

SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/ef_vfm/trainer.py

@@ -0,0 +1,557 @@
+import os
+import glob
+import time
+import torch
+from torch.optim.lr_scheduler import ReduceLROnPlateau
+import numpy as np
+import pandas as pd
+import json
+
+from copy import deepcopy
+
+from utils_train import update_ema
+
+from tqdm import tqdm
+
+BAR = "=============="
+def print_with_bar(log_msg):
+    log_msg = BAR + log_msg + BAR
+    if "End" in log_msg:
+         log_msg += "\n"
+    print(log_msg)
+
+class Trainer:
+    def __init__(
+            self, flow, train_iter, dataset, test_dataset,  metrics, logger,
+            lr, weight_decay,
+            steps, batch_size, check_val_every,
+            sample_batch_size, model_save_path, result_save_path,
+            num_samples_to_generate=None,
+            lr_scheduler='reduce_lr_on_plateau',
+            reduce_lr_patience=100, factor=0.9,
+            ema_decay=0.997,
+            closs_weight_schedule = "fixed",
+            c_lambda = 1.0,
+            d_lambda = 1.0,
+            max_grad_norm = 1.0,
+            warmup_epochs = 0,
+            device=torch.device('cuda:1'),
+            ckpt_path = None,
+            **kwargs
+    ):
+        self.flow = flow
+        self.ema_model = deepcopy(self.flow._vf_fn)
+        for param in self.ema_model.parameters():
+            param.detach_()
+
+        self.train_iter = train_iter
+        self.dataset = dataset
+        self.test_dataset = test_dataset
+        self.steps = steps
+        self.init_lr = lr
+        self.optimizer = torch.optim.AdamW(self.flow.parameters(), lr=lr, weight_decay=weight_decay)
+        self.ema_decay = ema_decay
+        self.lr_scheduler = lr_scheduler
+        self.scheduler = ReduceLROnPlateau(self.optimizer, mode='min', factor=factor, patience=reduce_lr_patience)
+        self.closs_weight_schedule = closs_weight_schedule
+        self.c_lambda = c_lambda
+        self.d_lambda = d_lambda
+        self.max_grad_norm = max_grad_norm
+        self.warmup_epochs = warmup_epochs
+
+        self.batch_size = batch_size
+        self.sample_batch_size = sample_batch_size
+        self.num_samples_to_generate = num_samples_to_generate
+        self.metrics = metrics
+        self.logger = logger
+        self.check_val_every = check_val_every
+
+        self.device = device
+        self.model_save_path = model_save_path
+        self.result_save_path = result_save_path
+        self.ckpt_path = ckpt_path
+        if self.ckpt_path is not None:
+            state_dicts = torch.load(self.ckpt_path, map_location=self.device)
+            self.flow._vf_fn.load_state_dict(state_dicts['vf_fn'])
+            print(f"Weights are loaded from {self.ckpt_path}")
+
+        self.curr_epoch = int(os.path.basename(self.ckpt_path).split('_')[-1].split('.')[0]) if self.ckpt_path is not None else 0
+
+    def _anneal_lr(self, step):
+        frac_done = step / self.steps
+        lr = self.init_lr * (1 - frac_done)
+        for param_group in self.optimizer.param_groups:
+            param_group["lr"] = lr
+
+    def _run_step(self, x, closs_weight, dloss_weight):
+        x = x.to(self.device)
+        
+        self.flow.train()
+
+        self.optimizer.zero_grad()
+
+        dloss, closs = self.flow.mixed_loss(x)
+
+        loss = dloss_weight * dloss + closs_weight * closs
+        loss.backward()
+        if self.max_grad_norm > 0:
+            torch.nn.utils.clip_grad_norm_(self.flow.parameters(), self.max_grad_norm)
+        self.optimizer.step()
+
+        return dloss, closs
+    
+    def compute_loss(self):      # eval loss is not weighted
+        curr_dloss = 0.0
+        curr_closs = 0.0
+        curr_count = 0
+        data_iter = self.train_iter
+        for batch in data_iter:
+            x = batch.float().to(self.device)
+            self.flow.eval()
+            with torch.no_grad():
+                batch_dloss, batch_closs = self.flow.mixed_loss(x)
+            curr_dloss += batch_dloss.item() * len(x)
+            curr_closs += batch_closs.item() * len(x)
+            curr_count += len(x)
+        mloss = np.around(curr_dloss / curr_count, 4)
+        gloss = np.around(curr_closs / curr_count, 4)
+        return mloss, gloss
+    
+    def run_loop(self):
+        patience = 0
+        closs_weight, dloss_weight = self.c_lambda, self.d_lambda
+        best_loss = np.inf
+        best_ema_loss = np.inf
+        best_val_loss = np.inf
+        start_time = time.time()
+        print_with_bar(f"Starting Trainin Loop, total number of epoch = {self.steps}")
+        # Set up wandb's step metric
+        self.logger.define_metric("epoch")
+        self.logger.define_metric("*", step_metric="epoch")
+        
+        start_epoch = self.curr_epoch
+        if start_epoch > 0:
+            print_with_bar(f"Resuming training from epoch {start_epoch}, with validation check every {self.check_val_every} epoches")
+        for epoch in range (start_epoch, self.steps):
+            self.curr_epoch = epoch+1
+            # Set up pbar
+            pbar = tqdm(self.train_iter, total=len(self.train_iter))
+            pbar.set_description(f"Epoch {epoch+1}/{self.steps}")
+            
+            # Compute the loss weights
+            if self.closs_weight_schedule == "fixed":
+                pass
+            elif self.closs_weight_schedule == "anneal":
+                frac_done = epoch / self.steps
+                closs_weight = self.c_lambda * (1 - frac_done)
+            else:
+                raise NotImplementedError(f"The continuous loss weight schedule {self.closs_weight_schedule} is not implemneted")
+
+            # Training Step
+            curr_dloss = 0.0
+            curr_closs = 0.0
+            curr_count = 0
+            curr_lr = self.optimizer.param_groups[0]['lr']
+            for batch in pbar:
+                x = batch.float().to(self.device)
+                batch_dloss, batch_closs = self._run_step(x, closs_weight, dloss_weight)
+                curr_dloss += batch_dloss.item() * len(x)
+                curr_closs += batch_closs.item() * len(x)
+                curr_count += len(x)
+                pbar.set_postfix({
+                    "lr": curr_lr,
+                    "DLoss": np.around(curr_dloss/curr_count, 4),
+                    "CLoss": np.around(curr_closs/curr_count, 4),
+                    "TotalLoss": np.around((curr_dloss + curr_closs)/curr_count, 4),
+                    "closs_weight": closs_weight,
+                    "dloss_weight": dloss_weight,
+                })
+                
+            # Log training Loss
+            log_dict = {}
+            mloss = np.around(curr_dloss / curr_count, 4)
+            gloss = np.around(curr_closs / curr_count, 4)
+            total_loss = mloss + gloss
+            if np.isnan(gloss):
+                    print('Finding Nan in gaussian loss')
+                    break
+            loss_dict = {
+                "epoch": epoch + 1,
+                "lr": curr_lr,
+                "closs_weight": closs_weight,
+                "dloss_weight": dloss_weight,
+                "loss/c_loss": gloss,
+                "loss/d_loss": mloss,
+                "loss/total_loss": total_loss
+            }
+            log_dict.update(loss_dict)
+            
+            # Adjust learning rate (warmup overrides during early epochs)
+            if self.warmup_epochs > 0 and (epoch + 1) <= self.warmup_epochs:
+                warmup_lr = self.init_lr * (epoch + 1) / self.warmup_epochs
+                for param_group in self.optimizer.param_groups:
+                    param_group["lr"] = warmup_lr
+            elif self.lr_scheduler == 'reduce_lr_on_plateau':
+                self.scheduler.step(total_loss)
+            elif self.lr_scheduler == 'anneal':
+                self._anneal_lr(epoch)
+            elif self.lr_scheduler == 'fixed':
+                pass
+            else:
+                raise NotImplementedError(f"LR scheduler with name '{self.lr_scheduler}' is not implemented")
+            
+            # Update EMA models
+            update_ema(self.ema_model.parameters(), self.flow._vf_fn.parameters(), rate=self.ema_decay)
+
+            # Save ckpt base on the best training loss
+            if total_loss < best_loss and self.curr_epoch > 4000:
+                best_loss = total_loss
+                to_remove = glob.glob(os.path.join(self.model_save_path, f"best_model_*"))
+                if to_remove:
+                    os.remove(to_remove[0])
+                state_dicts = {
+                    'vf_fn': self.flow._vf_fn.state_dict(),
+                }
+                torch.save(state_dicts, os.path.join(self.model_save_path, f'best_model_{np.round(total_loss,4)}_{epoch+1}.pt'))
+                patience = 0
+            else:
+                patience += 1   # increment patience if best loss is not surpassed
+            
+            # Compute and log EMA model loss
+            curr_model = self.to_ema_model()
+            ema_mloss, ema_gloss = self.compute_loss()
+            self.to_model(curr_model)
+            ema_total_loss = ema_mloss + ema_gloss
+            ema_loss_dict = {
+                "ema_loss/c_loss": ema_gloss,
+                "ema_loss/d_loss": ema_mloss,
+                "ema_loss/total_loss": ema_total_loss
+            }
+            
+            # Save the best ema ckpt
+            if ema_total_loss < best_ema_loss and self.curr_epoch > 4000:
+                best_ema_loss = ema_total_loss
+                to_remove = glob.glob(os.path.join(self.model_save_path, f"best_ema_model_*"))
+                if to_remove:
+                    os.remove(to_remove[0])
+                state_dicts = {
+                    'vf_fn': self.ema_model.state_dict(), 
+                }
+                torch.save(state_dicts, os.path.join(self.model_save_path, f'best_ema_model_{np.round(ema_total_loss,4)}_{epoch+1}.pt'))
+            
+            # Evaluate Sample Quality
+            if (epoch+1) % self.check_val_every == 0:
+                state_dicts = {
+                    'vf_fn': self.flow._vf_fn.state_dict(), 
+                }
+                torch.save(state_dicts, os.path.join(self.model_save_path, f'model_{epoch+1}.pt'))
+                
+                print_with_bar(f"Routine Generation Evaluation every {self.check_val_every}, currently at epoch #{epoch+1}, wiht total_loss={total_loss}.")
+                _plot_density = os.environ.get("EFVFM_ADAPTER_TRAIN", "").strip().lower() not in ("1", "true", "yes")
+                out_metrics, _, _ = self.evaluate_generation(save_metric_details=True, plot_density=_plot_density)
+                log_dict.update(out_metrics)
+                print(f"Eval Resutls of the Non-EMA model:\n {out_metrics}")
+
+                # Evaluate the EMA model
+                torch.save(self.ema_model.state_dict(), os.path.join(self.model_save_path, f'ema_model_{epoch+1}.pt'))
+                ema_out_metrics, _, _ = self.evaluate_generation(ema=True, save_metric_details=True, plot_density=_plot_density)
+                log_dict.update({
+                    "ema": ema_out_metrics,
+                })
+                print(f"Eval Resutls of the EMA model:\n {ema_out_metrics}")
+            # Submit logs
+            self.logger.log(log_dict)
+
+        end_time = time.time()
+        print_with_bar(f"Ending Trainnig Loop, totoal training time = {end_time - start_time}")
+        self.logger.log({
+            'training_time': end_time - start_time
+        })
+        
+    def report_test(self, num_runs):
+        save_dir = self.result_save_path
+        
+        shape_ = []
+        trend_ = []
+        mle_ = []
+        c2st_ = []
+        for i in range(num_runs):
+            print_with_bar(f"GENERAL Evaluation Run {i}")
+            out_metrics, extras, syn_df = self.evaluate_generation()
+            print(f"Results of Run {i} are: \n{out_metrics}")
+            shape_.append(out_metrics["density/Shape"])
+            trend_.append(out_metrics["density/Trend"])
+            mle_.append(out_metrics["mle"])
+            c2st_.append(out_metrics["c2st"])
+            # Save samples for quality evaluation
+            save_path = os.path.join(save_dir, "all_samples")
+            if not os.path.exists(save_path):
+                os.makedirs(save_path)
+            syn_df.to_csv(os.path.join(save_path, f"samples_{i}.csv"), index=False)
+
+        shape_ = np.array(shape_)
+        trend_ = np.array(trend_)
+        mle_ = np.array(mle_)
+        c2st_ = np.array(c2st_)
+        
+        shape_error = (1 - shape_)*100
+        trend_error = (1 - trend_)*100
+        c2st_percent = c2st_ * 100
+        
+        all_results = pd.DataFrame({
+            "shape": shape_error,
+            "trend": trend_error,
+            "mle": mle_,
+            "c2st": c2st_percent,
+        })
+        avg = all_results.mean(axis=0).round(3)
+        std = all_results.std(axis=0).round(3)
+        avg_std = pd.concat([avg, std], axis=1, ignore_index=True)
+        avg_std.columns = ["avg", "std"]
+        avg_std.index = [
+            "shape", 
+            "trend", 
+            "mle", 
+            "c2st", 
+        ]
+        
+        # Savings
+        all_results.to_csv(f"{save_dir}/all_results.csv", index=True)
+        avg_std.to_csv(f"{save_dir}/avg_std.csv", index=True)
+        print_with_bar(f"The AVG over {num_runs} runs are: \n{avg_std}")
+        
+    def report_test_dcr(self, num_runs):
+        save_dir = self.result_save_path
+        
+        dcr_ = []
+        dcr_real_ = []
+        dcr_test_ = []
+        for i in range(num_runs):
+            print_with_bar(f"DCR Evaluation Run {i}")
+            out_metrics, extras, syn_df = self.evaluate_generation()
+            print(f"Results of Run {i} are: \n{out_metrics}")
+            dcr_.append(out_metrics["dcr"])
+            dcr_real_.append(extras["dcr_real"])
+            dcr_test_.append(extras["dcr_test"])
+            save_path = os.path.join(save_dir, "all_samples")
+            if not os.path.exists(save_path):
+                os.makedirs(save_path)
+            syn_df.to_csv(os.path.join(save_path, f"samples_{i}.csv"), index=False)
+
+        dcr_ = np.array(dcr_)
+        
+        dcr_percent = dcr_ * 100
+        
+        all_results = pd.DataFrame({
+            "dcr": dcr_percent,
+        })
+        avg = all_results.mean(axis=0).round(3)
+        std = all_results.std(axis=0).round(3)
+        avg_std = pd.concat([avg, std], axis=1, ignore_index=True)
+        avg_std.columns = ["avg", "std"]
+        avg_std.index = [
+            "dcr", 
+        ]
+        
+        # Savings
+        all_results.to_csv(f"{save_dir}/all_results.csv", index=True)
+        avg_std.to_csv(f"{save_dir}/avg_std.csv", index=True)
+        dcr_real = np.concatenate(dcr_real_, axis=0)
+        dcr_test = np.concatenate(dcr_test_, axis=0)
+        dcr_df = pd.DataFrame({
+            "dcr_real": dcr_real,
+            "dcr_test": dcr_test
+        })
+        dcr_df.to_csv(f"{save_dir}/dcr.csv", index=False)
+        
+        print_with_bar(f"The AVG over {num_runs} runs are: \n{avg_std}")
+        
+    def test(self):
+        _plot_density = os.environ.get("EFVFM_ADAPTER_TRAIN", "").strip().lower() not in ("1", "true", "yes")
+        out_metrics, _, _ = self.evaluate_generation(save_metric_details=True, plot_density=_plot_density)
+        print_with_bar(f"Results of the test are: \n{out_metrics}")
+        self.logger.log(out_metrics)
+        print(out_metrics)
+
+    def evaluate_generation(self, save_metric_details=False, plot_density=False, ema=False):
+        self.flow.eval()
+        
+        # Sample a synthetic table
+        env_num_samples = os.environ.get("EFVFM_EVAL_NUM_SAMPLES", "").strip()
+        if self.num_samples_to_generate:
+            num_samples = self.num_samples_to_generate
+        elif env_num_samples:
+            num_samples = max(1, int(env_num_samples))
+        else:
+            num_samples = self.metrics.real_data_size # By default, num_samples_to_generate is not specified. In this case, we generate the same number of samples as the real dataset. This approach is consistently used across all experiments in the paper.
+        syn_df = self.sample_synthetic(num_samples, ema=ema)
+        
+        # Save the sample
+        save_path = os.path.join(self.result_save_path, str(self.curr_epoch), "ema" if ema else "")
+        if not os.path.exists(save_path):
+            os.makedirs(save_path)
+        path = os.path.join(save_path, "samples.csv")
+        syn_df.to_csv(path, index=False)
+        print(
+            f"Samples are saved at {path}"
+        )
+
+        if os.environ.get("EFVFM_ADAPTER_SAMPLE_ONLY", "").strip().lower() in ("1", "true", "yes"):
+            return {}, {}, syn_df
+        
+        # Compute evaluation metrics on the sample
+        syn_df_loaded = pd.read_csv(os.path.join(save_path, "samples.csv")) # In the original tabsyn code, syn_data is implicitly casted into float.64 when it gets loaded with pd.read_csv in the evaluation script. If we don't cast, the density evluation for some columns (especially those with tailed and peaked distribution) will collapse.
+        out_metrics, extras = self.metrics.evaluate(syn_df_loaded)
+        
+        # Save metrics and metric details
+        path = os.path.join(save_path, "all_results.json")
+        with open(path, "w") as json_file:
+            json.dump(out_metrics, json_file, indent=4, separators=(", ", ": "))        # always locally save the output metrics
+        if save_metric_details:
+            for name, extra in extras.items():
+                if isinstance(extra, pd.DataFrame):
+                    extra.to_csv(os.path.join(save_path, f"{name}.csv"))
+                elif isinstance(extra, dict):
+                    with open(os.path.join(save_path, f"{name}.json"), "w") as json_file:
+                        json.dump(extra, json_file, indent=4, separators=(", ", ": "))
+                else:
+                    raise NotImplementedError(f"Extra file generated during evaluations has type {type(extra)}, and code to save this type of file is not implemented")
+        
+        # Plot density figures
+        if plot_density:
+            img = self.metrics.plot_density(syn_df_loaded)
+            path = os.path.join(save_path, "density_plots.png")
+            img.save(path)
+            print(
+                f"The density plots are saved at {path}"
+            )
+        return out_metrics, extras, syn_df      
+
+    def sample_synthetic(self, num_samples, keep_nan_samples=True, ema=False):
+        if ema:
+            curr_model = self.to_ema_model()
+
+        info = self.metrics.info
+        
+        print_with_bar(f"Starting Sampling, total samples to generate = {num_samples}")
+        start_time = time.time()
+        
+        syn_data = self.flow.sample_all(num_samples, self.sample_batch_size, keep_nan_samples=keep_nan_samples)
+        print(f"Shape of the generated sample = {syn_data.shape}")
+        
+        if keep_nan_samples:
+            num_all_zero_row = (syn_data.sum(dim=1) == 0).sum()
+            if num_all_zero_row:
+                print(f"The generated samples contain {num_all_zero_row} Nan instances!!!")
+                self.logger.log({
+                    'num_Nan_sample': num_all_zero_row
+                })
+
+        # Recover tables
+        num_inverse = self.dataset.num_inverse
+        int_inverse = self.dataset.int_inverse
+        cat_inverse = self.dataset.cat_inverse
+        
+        syn_num, syn_cat, syn_target = split_num_cat_target(syn_data, info, num_inverse, int_inverse, cat_inverse) 
+        syn_df = recover_data(syn_num, syn_cat, syn_target, info)
+
+        idx_name_mapping = info['idx_name_mapping']
+        idx_name_mapping = {int(key): value for key, value in idx_name_mapping.items()}
+
+        syn_df.rename(columns = idx_name_mapping, inplace=True)
+        
+        end_time = time.time()
+        print_with_bar(f"Ending Sampling, totoal sampling time = {end_time - start_time}")
+        
+        if ema:
+            self.to_model(curr_model)
+
+        return syn_df
+    
+    def to_ema_model(self):
+        curr_model = self.flow._vf_fn
+        self.flow._vf_fn = self.ema_model  # temporarily install the ema parameters into the model
+        
+        return curr_model
+
+    def to_model(self, curr_model):
+        self.flow._vf_fn = curr_model      # give back the parameters
+        
+
+def _as_numpy_float32(x):
+    if x is None:
+        return np.array([], dtype=np.float32)
+    if isinstance(x, torch.Tensor):
+        x = x.detach().cpu().numpy()
+    return np.asarray(x, dtype=np.float32)
+
+
+@torch.no_grad()
+def split_num_cat_target(syn_data, info, num_inverse, int_inverse, cat_inverse):
+    task_type = info['task_type']
+
+    num_col_idx = info['num_col_idx']
+    cat_col_idx = info['cat_col_idx']
+    target_col_idx = info['target_col_idx']
+
+    n_num_feat = len(num_col_idx)
+    n_cat_feat = len(cat_col_idx)
+
+    if task_type == 'regression':
+        n_num_feat += len(target_col_idx)
+    else:
+        n_cat_feat += len(target_col_idx)
+
+    syn_num = syn_data[:, :n_num_feat]
+    syn_cat = syn_data[:, n_num_feat:]
+
+    if n_num_feat > 0:
+        syn_num = _as_numpy_float32(num_inverse(syn_num))
+        syn_num = _as_numpy_float32(int_inverse(syn_num))
+    else:
+        syn_num = np.zeros((syn_data.shape[0], 0), dtype=np.float32)
+    syn_cat = cat_inverse(syn_cat)
+
+
+    if info['task_type'] == 'regression':
+        syn_target = syn_num[:, :len(target_col_idx)]
+        syn_num = syn_num[:, len(target_col_idx):]
+    
+    else:
+        syn_target = syn_cat[:, :len(target_col_idx)]
+        syn_cat = syn_cat[:, len(target_col_idx):]
+
+    return syn_num, syn_cat, syn_target
+
+def recover_data(syn_num, syn_cat, syn_target, info):
+
+    num_col_idx = info['num_col_idx']
+    cat_col_idx = info['cat_col_idx']
+    target_col_idx = info['target_col_idx']
+
+
+    idx_mapping = info['idx_mapping']
+    idx_mapping = {int(key): value for key, value in idx_mapping.items()}
+
+    syn_df = pd.DataFrame()
+
+    if info['task_type'] == 'regression':
+        for i in range(len(num_col_idx) + len(cat_col_idx) + len(target_col_idx)):
+            if i in set(num_col_idx):
+                syn_df[i] = syn_num[:, idx_mapping[i]] 
+            elif i in set(cat_col_idx):
+                syn_df[i] = syn_cat[:, idx_mapping[i] - len(num_col_idx)]
+            else:
+                syn_df[i] = syn_target[:, idx_mapping[i] - len(num_col_idx) - len(cat_col_idx)]
+
+
+    else:
+        for i in range(len(num_col_idx) + len(cat_col_idx) + len(target_col_idx)):
+            if i in set(num_col_idx):
+                syn_df[i] = syn_num[:, idx_mapping[i]]
+            elif i in set(cat_col_idx):
+                syn_df[i] = syn_cat[:, idx_mapping[i] - len(num_col_idx)]
+            else:
+                syn_df[i] = syn_target[:, idx_mapping[i] - len(num_col_idx) - len(cat_col_idx)]
+
+    return syn_df

SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/eval/eval_quality.py

@@ -0,0 +1,149 @@
+import glob
+import numpy as np
+import pandas as pd
+import os 
+import sys
+import json
+
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+from sklearn.preprocessing import OneHotEncoder
+from synthcity.metrics import eval_statistical
+from synthcity.plugins.core.dataloader import GenericDataLoader
+
+pd.options.mode.chained_assignment = None
+
+import argparse
+
+parser = argparse.ArgumentParser()
+parser.add_argument('--dataname', type=str)
+parser.add_argument('--exp_name', type=str, default=None)
+
+
+args = parser.parse_args()
+
+def evaluate_quality(real_path, syn_path, info_path):
+    with open(info_path, 'r') as f:
+        info = json.load(f)
+
+    syn_data = pd.read_csv(syn_path)
+    real_data = pd.read_csv(real_path)
+
+
+    ''' Special treatment for default dataset and CoDi model '''
+
+    real_data.columns = range(len(real_data.columns))
+    syn_data.columns = range(len(syn_data.columns))
+
+    num_col_idx = info['num_col_idx']
+    cat_col_idx = info['cat_col_idx']
+    target_col_idx = info['target_col_idx']
+    if info['task_type'] == 'regression':
+        num_col_idx += target_col_idx
+    else:
+        cat_col_idx += target_col_idx
+        
+    num_real_data = real_data[num_col_idx]
+    cat_real_data = real_data[cat_col_idx]
+
+    num_real_data_np = num_real_data.to_numpy()
+    cat_real_data_np = cat_real_data.to_numpy().astype('str')
+        
+
+    num_syn_data = syn_data[num_col_idx]
+    cat_syn_data = syn_data[cat_col_idx]
+
+    num_syn_data_np = num_syn_data.to_numpy()
+
+    # cat_syn_data_np = np.array
+    cat_syn_data_np = cat_syn_data.to_numpy().astype('str')
+
+    encoder = OneHotEncoder()
+    encoder.fit(cat_real_data_np)
+
+
+    cat_real_data_oh = encoder.transform(cat_real_data_np).toarray()
+    cat_syn_data_oh = encoder.transform(cat_syn_data_np).toarray()
+
+    le_real_data = pd.DataFrame(np.concatenate((num_real_data_np, cat_real_data_oh), axis = 1)).astype(float)
+    le_real_num = pd.DataFrame(num_real_data_np).astype(float)
+    le_real_cat = pd.DataFrame(cat_real_data_oh).astype(float)
+
+
+    le_syn_data = pd.DataFrame(np.concatenate((num_syn_data_np, cat_syn_data_oh), axis = 1)).astype(float)
+    le_syn_num = pd.DataFrame(num_syn_data_np).astype(float)
+    le_syn_cat = pd.DataFrame(cat_syn_data_oh).astype(float)
+    
+     # Check for nan
+    if le_syn_data.isnull().values.any():
+        nan_coordinate = np.isnan(le_syn_data.to_numpy()).nonzero()
+        nan_row = np.unique(nan_coordinate[0])
+        print(f"Synthetic data contains NaN at row {nan_row}: ")
+        print(le_syn_data.iloc[nan_row])
+        return None, None
+        
+
+    np.set_printoptions(precision=4)
+
+    result = []
+
+    print('=========== All Features ===========')
+    print('Data shape: ', le_syn_data.shape)
+
+    X_syn_loader = GenericDataLoader(le_syn_data)
+    X_real_loader = GenericDataLoader(le_real_data)
+
+    quality_evaluator = eval_statistical.AlphaPrecision()
+    qual_res = quality_evaluator.evaluate(X_real_loader, X_syn_loader)
+    qual_res = {
+        k: v for (k, v) in qual_res.items() if "naive" in k
+    }  # use the naive implementation of AlphaPrecision
+    qual_score = np.mean(list(qual_res.values()))
+
+    print('alpha precision: {:.6f}, beta recall: {:.6f}'.format(qual_res['delta_precision_alpha_naive'], qual_res['delta_coverage_beta_naive'] ))
+
+    Alpha_Precision_all = qual_res['delta_precision_alpha_naive']
+    Beta_Recall_all = qual_res['delta_coverage_beta_naive']
+
+    return Alpha_Precision_all, Beta_Recall_all
+
+if __name__ == '__main__':
+    exp_name = args.exp_name
+    assert exp_name is not None, "Experiment name must be provided"
+    dataname = args.dataname
+    data_dir = f'data/{dataname}' 
+    info_path = f'{data_dir}/info.json'
+    real_path = f'synthetic/{dataname}/real.csv'
+    
+    sample_dir = f"eval/report_runs/{exp_name}/{dataname}/all_samples"
+    sample_paths = glob.glob(os.path.join(sample_dir, "*.csv"))
+    print(f"{len(sample_paths )} samples loaded from {sample_dir}")
+
+    alphas, betas = [], []
+    for syn_path in sample_paths:
+        alpha_precision, beta_recall = evaluate_quality(real_path, syn_path, info_path)
+        if (alpha_precision is None) or (beta_recall is None):
+            continue
+        alphas.append(alpha_precision)
+        betas.append(beta_recall)
+
+    alphas = np.array(alphas)
+    betas = np.array(betas)
+    alpha_percent = alphas * 100
+    beta_percent = betas * 100
+    
+    quality = pd.DataFrame({
+        'alpha': alpha_percent, 
+        'beta': beta_percent
+    })
+    avg = quality.mean(axis=0).round(2)
+    std = quality.std(axis=0).round(2)
+    quality_avg_std = pd.concat([avg, std], axis=1, ignore_index=True)
+    quality_avg_std.columns = ["avg", "std"]
+    quality_avg_std.index = ["alpha", "beta"]
+    
+    save_dir = os.path.dirname(sample_dir)
+    quality.to_csv(os.path.join(save_dir, "quality.csv"), index=True)
+    avg_std = pd.read_csv(os.path.join(save_dir, "avg_std.csv"), index_col=0)
+    avg_std = pd.concat([avg_std, quality_avg_std])
+    print(avg_std)
+    avg_std.to_csv(os.path.join(save_dir, "avg_std.csv"), index=True)

SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/eval/mle/mle.py

@@ -0,0 +1,781 @@
+import numpy as np
+import pandas as pd
+from xgboost import XGBClassifier, XGBRegressor
+from sklearn.ensemble import AdaBoostClassifier, RandomForestClassifier, RandomForestRegressor
+from sklearn.linear_model import LogisticRegression, LinearRegression
+from sklearn.neural_network import MLPClassifier, MLPRegressor
+from sklearn.preprocessing import OneHotEncoder, LabelEncoder
+from sklearn.tree import DecisionTreeClassifier
+from sklearn.metrics import classification_report, accuracy_score, f1_score, precision_score, recall_score, roc_auc_score
+from sklearn.metrics import explained_variance_score, mean_squared_error, mean_absolute_error, r2_score
+from sklearn.model_selection import ParameterGrid
+from sklearn.utils._testing import ignore_warnings
+from sklearn.exceptions import ConvergenceWarning
+import logging
+from prdc import compute_prdc
+from tqdm import tqdm
+
+CATEGORICAL = "categorical"
+CONTINUOUS = "continuous"
+
+_MODELS = {
+    'binclass': [ # 184
+        #  {
+        #      'class': DecisionTreeClassifier, # 48
+        #      'kwargs': {
+        #          'max_depth': [4, 8, 16, 32], 
+        #          'min_samples_split': [2, 4, 8],
+        #          'min_samples_leaf': [1, 2, 4, 8]
+        #      }
+        #  },
+        #  {
+        #      'class': AdaBoostClassifier, # 4
+        #      'kwargs': {
+        #          'n_estimators': [10, 50, 100, 200]
+        #      }
+        #  },
+        #  {
+        #     'class': LogisticRegression, # 36
+        #     'kwargs': {
+        #          'solver': ['lbfgs'],
+        #          'n_jobs': [-1],
+        #          'max_iter': [10, 50, 100, 200],
+        #          'C': [0.01, 0.1, 1.0],
+        #          'tol': [1e-01, 1e-02, 1e-04]
+        #      }
+        #  },
+        # {
+        #     'class': MLPClassifier, # 12
+        #     'kwargs': {
+        #         'hidden_layer_sizes': [(100, ), (200, ), (100, 100)],
+        #         'max_iter': [50, 100],
+        #         'alpha': [0.0001, 0.001]
+        #     }
+        # },
+        # {
+        #     'class': RandomForestClassifier, # 48
+        #     'kwargs': {
+        #          'max_depth': [8, 16, None], 
+        #          'min_samples_split': [2, 4, 8],
+        #          'min_samples_leaf': [1, 2, 4, 8],
+        #         'n_jobs': [-1]
+
+        #     }
+        # },
+        {
+            'class': XGBClassifier, # 36
+            'kwargs': {
+                 'n_estimators': [10, 50, 100],
+                 'min_child_weight': [1, 10], 
+                 'max_depth': [5, 10, 20],
+                 'gamma': [0.0, 1.0],
+                 'objective': ['binary:logistic'],
+                 'nthread': [-1],
+                 'tree_method': ['gpu_hist']
+            },
+        }
+
+    ],
+    'multiclass': [ # 132
+        
+        # {
+        #     'class': MLPClassifier, # 12
+        #     'kwargs': {
+        #         'hidden_layer_sizes': [(100, ), (200, ), (100, 100)],
+        #         'max_iter': [50, 100],
+        #         'alpha': [0.0001, 0.001]
+        #     }
+        # },
+        #  {
+        #      'class': DecisionTreeClassifier, # 48
+        #      'kwargs': {
+        #          'max_depth': [4, 8, 16, 32], 
+        #          'min_samples_split': [2, 4, 8],
+        #          'min_samples_leaf': [1, 2, 4, 8]
+        #      }
+        #  },
+        # {
+        #     'class': RandomForestClassifier, # 36
+        #     'kwargs': {
+        #          'max_depth': [8, 16, None], 
+        #          'min_samples_split': [2, 4, 8],
+        #          'min_samples_leaf': [1, 2, 4, 8],
+        #          'n_jobs': [-1]
+
+        #     }
+        # },
+        {
+            'class': XGBClassifier, # 36
+            'kwargs': {
+                 'n_estimators': [10, 50, 100],
+                 'min_child_weight': [1, 10], 
+                 'max_depth': [5, 10, 20],
+                 'gamma': [0.0, 1.0],
+                 'objective': ['binary:logistic'],
+                 'nthread': [-1],
+                 'tree_method': ['gpu_hist']
+            }
+        }
+
+    ],
+    'regression': [ # 84
+        # {
+        #     'class': LinearRegression,
+        # },
+        # {
+        #    'class': MLPRegressor, # 12
+        #    'kwargs': {
+        #        'hidden_layer_sizes': [(100, ), (200, ), (100, 100)],
+        #        'max_iter': [50, 100],
+        #        'alpha': [0.0001, 0.001]
+        #    }
+        #},
+        {
+            'class': XGBRegressor, # 36 
+            'kwargs': {
+                 'n_estimators': [10, 50, 100],
+                 'min_child_weight': [1, 10], 
+                 'max_depth': [5, 10, 20],
+                 'gamma': [0.0, 1.0],
+                 'objective': ['reg:linear'],
+                 'nthread': [-1],
+                 'tree_method': ['gpu_hist']
+            }
+        },
+        # {
+        #     'class': RandomForestRegressor, # 36
+        #     'kwargs': {
+        #          'max_depth': [8, 16, None], 
+        #          'min_samples_split': [2, 4, 8],
+        #          'min_samples_leaf': [1, 2, 4, 8],
+        #          'n_jobs': [-1]
+        #     }
+        # }
+    ]
+}
+
+def feat_transform(data, info, label_encoder = None, encoders = None, cmax = None, cmin = None):
+    num_col_idx = info['num_col_idx']
+    cat_col_idx = info['cat_col_idx']
+    target_col_idx = info['target_col_idx']
+
+    num_cols = len(num_col_idx + cat_col_idx + target_col_idx)
+    features = [] 
+    
+    if not encoders:
+        encoders = dict()
+    for idx in range(num_cols):
+        col = data[:, idx]
+
+        if idx in target_col_idx:
+
+            if info['task_type'] != 'regression':
+                
+                if not label_encoder:
+                    label_encoder = LabelEncoder()
+                    label_encoder.fit(col)
+
+                encoded_labels = label_encoder.transform(col)
+                labels = encoded_labels
+            else:
+                col = col.astype(np.float32)
+                labels = col.astype(np.float32)
+            
+            continue
+
+        if idx in num_col_idx:
+            col = col.astype(np.float32)
+
+            if not cmin:
+                cmin = col.min()
+            
+            if not cmax:
+                cmax = col.max()
+
+            if cmin >= 0 and cmax >= 1e3:
+                feature = np.log(np.maximum(col, 1e-2))
+
+            else:
+                feature = (col - cmin) / (cmax - cmin) * 5
+
+        elif idx in cat_col_idx:
+            encoder = encoders.get(idx)
+            col = col.reshape(-1, 1)
+            if encoder:
+                feature = encoder.transform(col)
+            else:
+                # encoder = OneHotEncoder(sparse=False, handle_unknown='ignore')
+                encoder = OneHotEncoder(sparse_output=False, handle_unknown='ignore') # New in version 1.2: sparse was renamed to sparse_output
+                encoders[idx] = encoder
+                feature = encoder.fit_transform(col)
+                
+
+        features.append(feature)
+    features = np.column_stack(features)
+    return features, labels, label_encoder, encoders, cmax, cmin
+
+
+def prepare_ml_problem(train, test, info, val=None):
+    # test_X, test_y, label_encoder, encoders = feat_transform(test, info)
+    # train_X, train_y, _, _ = feat_transform(train, info, label_encoder, encoders)
+    
+    train_X, train_y, label_encoder, encoders, cmax, cmin = feat_transform(train, info)
+    test_X, test_y, _, _ , _, _ = feat_transform(test, info, label_encoder, encoders, cmax, cmin)
+
+    if val is not None:
+        val_X, val_y, _, _, _, _ = feat_transform(val, info, label_encoder, encoders, cmax, cmin)
+    else:
+        total_train_num = train_X.shape[0]
+        val_num = int(total_train_num / 9)
+
+        total_train_idx = np.arange(total_train_num)
+        np.random.shuffle(total_train_idx)
+        train_idx = total_train_idx[val_num:]
+        val_idx = total_train_idx[:val_num]
+
+
+
+        # val_X, val_y = train_X[val_idx], train_y[val_idx]
+        # train_X, train_y = train_X[train_idx], train_y[train_idx]
+        
+        # model = _MODELS[info['task_type']]
+        
+        # return train_X, train_y, train_X, train_y, test_X, test_y, model
+
+
+
+        val_X, val_y = train_X[val_idx], train_y[val_idx]
+        train_X, train_y = train_X[train_idx], train_y[train_idx]
+    
+    model = _MODELS[info['task_type']]
+    
+    return train_X, train_y, val_X, val_y, test_X, test_y, model
+
+class FeatureMaker:
+
+    def __init__(self, metadata, label_column='label', label_type='int', sample=50000):
+        self.columns = metadata['columns']
+        self.label_column = label_column
+        self.label_type = label_type
+        self.sample = sample
+        self.encoders = dict()
+
+    def make_features(self, data):
+        data = data.copy()
+        np.random.shuffle(data)
+        data = data[:self.sample]
+
+        features = []
+        labels = []
+
+        for index, cinfo in enumerate(self.columns):
+            col = data[:, index]
+            if cinfo['name'] == self.label_column:
+                if self.label_type == 'int':
+                    labels = col.astype(int)
+                elif self.label_type == 'float':
+                    labels = col.astype(float)
+                else:
+                    assert 0, 'unkown label type'
+                continue
+
+            if cinfo['type'] == CONTINUOUS:
+                cmin = cinfo['min']
+                cmax = cinfo['max']
+                if cmin >= 0 and cmax >= 1e3:
+                    feature = np.log(np.maximum(col, 1e-2))
+
+                else:
+                    feature = (col - cmin) / (cmax - cmin) * 5
+
+            else:
+                if cinfo['size'] <= 2:
+                    feature = col
+
+                else:
+                    encoder = self.encoders.get(index)
+                    col = col.reshape(-1, 1)
+                    if encoder:
+                        feature = encoder.transform(col)
+                    else:
+                        encoder = OneHotEncoder(sparse=False, handle_unknown='ignore')
+                        self.encoders[index] = encoder
+                        feature = encoder.fit_transform(col)
+
+            features.append(feature)
+
+        features = np.column_stack(features)
+
+        return features, labels
+
+
+def _prepare_ml_problem(train, val, test, metadata, eval): 
+    fm = FeatureMaker(metadata)
+    x_trains, y_trains = [], []
+
+    for i in train:
+        x_train, y_train = fm.make_features(i)
+        x_trains.append(x_train)
+        y_trains.append(y_train)
+
+    x_val, y_val = fm.make_features(val)
+    if eval is None:
+        x_test = None
+        y_test = None
+    else:
+        x_test, y_test = fm.make_features(test)
+    model = _MODELS[metadata['problem_type']]
+
+    return x_trains, y_trains, x_val, y_val, x_test, y_test, model
+
+
+def _weighted_f1(y_test, pred):
+    report = classification_report(y_test, pred, output_dict=True)
+    classes = list(report.keys())[:-3]
+    proportion = [  report[i]['support'] / len(y_test) for i in classes]
+    weighted_f1 = np.sum(list(map(lambda i, prop: report[i]['f1-score']* (1-prop)/(len(classes)-1), classes, proportion)))
+    return weighted_f1 
+
+
+@ignore_warnings(category=ConvergenceWarning)
+def _evaluate_multi_classification(train, test, info, val=None):
+    x_trains, y_trains, x_valid, y_valid, x_test, y_test, classifiers = prepare_ml_problem(train, test, info, val=val)
+    best_f1_scores = []
+    unique_labels = np.unique(y_trains)
+
+
+    best_f1_scores = []
+    best_weighted_scores = []
+    best_auroc_scores = []
+    best_acc_scores = []
+    best_avg_scores = []
+
+    for model_spec in classifiers:
+        model_class = model_spec['class']
+        model_kwargs = model_spec.get('kwargs', dict())
+        model_repr = model_class.__name__
+
+        unique_labels = np.unique(y_trains)
+
+        param_set = list(ParameterGrid(model_kwargs))
+
+        results = []
+        for param in tqdm(param_set):
+            model = model_class(**param)
+
+            try:
+                model.fit(x_trains, y_trains)
+            except:
+                pass 
+
+            if len(unique_labels) != len(np.unique(y_valid)):
+                pred = [unique_labels[0]] * len(x_valid)
+                pred_prob = np.array([1.] * len(x_valid))
+            else:
+                pred = model.predict(x_valid)
+                pred_prob = model.predict_proba(x_valid)
+
+            macro_f1 = f1_score(y_valid, pred, average='macro')
+            weighted_f1 = _weighted_f1(y_valid, pred)
+            acc = accuracy_score(y_valid, pred)
+
+            # 3. auroc
+    #         size = [a["size"] for a in metadata["columns"] if a["name"] == "label"][0]
+            size = len(set(unique_labels))
+            rest_label = set(range(size)) - set(unique_labels)
+            tmp = []
+            j = 0
+            for i in range(size):
+                if i in rest_label:
+                    tmp.append(np.array([0] * y_valid.shape[0])[:,np.newaxis])
+                else:
+                    try:
+                        tmp.append(pred_prob[:,[j]])
+                    except:
+                        tmp.append(pred_prob[:, np.newaxis])
+                    j += 1
+
+            roc_auc = roc_auc_score(np.eye(size)[y_valid], np.hstack(tmp), multi_class='ovr')
+
+            results.append(
+                {   
+                    "name": model_repr,
+                    "param": param,
+                    "macro_f1": macro_f1,
+                    "weighted_f1": weighted_f1,
+                    "roc_auc": roc_auc, 
+                    "accuracy": acc
+                }
+            )
+
+        results = pd.DataFrame(results)
+        results['avg'] = results.loc[:, ['macro_f1', 'weighted_f1', 'roc_auc']].mean(axis=1)        
+        best_f1_param = results.param[results.macro_f1.idxmax()]
+        best_weighted_param = results.param[results.weighted_f1.idxmax()]
+        best_auroc_param = results.param[results.roc_auc.idxmax()]
+        best_acc_param = results.param[results.accuracy.idxmax()]
+        best_avg_param = results.param[results.avg.idxmax()]
+
+
+        # test the best model
+        results = pd.DataFrame(results)
+        # best_param = results.param[results.macro_f1.idxmax()]
+
+        def _calc(best_model):
+            best_scores = []
+            
+            x_train = x_trains
+            y_train = y_trains
+            
+            try:
+                best_model.fit(x_train, y_train)
+            except:
+                pass 
+
+            if len(unique_labels) != len(np.unique(y_test)):
+                pred = [unique_labels[0]] * len(x_test)
+                pred_prob = np.array([1.] * len(x_test))
+            else:
+                pred = best_model.predict(x_test)
+                pred_prob = best_model.predict_proba(x_test)
+
+            macro_f1 = f1_score(y_test, pred, average='macro')
+            weighted_f1 = _weighted_f1(y_test, pred)
+            acc = accuracy_score(y_test, pred)
+
+            # 3. auroc
+            size = len(set(unique_labels))
+            rest_label = set(range(size)) - set(unique_labels)
+            tmp = []
+            j = 0
+            for i in range(size):
+                if i in rest_label:
+                    tmp.append(np.array([0] * y_test.shape[0])[:,np.newaxis])
+                else:
+                    try:
+                        tmp.append(pred_prob[:,[j]])
+                    except:
+                        tmp.append(pred_prob[:, np.newaxis])
+                    j += 1
+            roc_auc = roc_auc_score(np.eye(size)[y_test], np.hstack(tmp), multi_class='ovr')
+
+            best_scores.append(
+                {   
+                    "name": model_repr,
+                    "macro_f1": macro_f1,
+                    "weighted_f1": weighted_f1,
+                    "roc_auc": roc_auc, 
+                    "accuracy": acc
+                }
+            )
+            return pd.DataFrame(best_scores)
+
+        def _df(dataframe):
+            return {
+                "name": model_repr,
+                "macro_f1": dataframe.macro_f1.values[0],
+                "roc_auc": dataframe.roc_auc.values[0],
+                "weighted_f1": dataframe.weighted_f1.values[0],
+                "accuracy": dataframe.accuracy.values[0],
+            }
+
+        best_f1_scores.append(_df(_calc(model_class(**best_f1_param))))
+        best_weighted_scores.append(_df(_calc(model_class(**best_weighted_param))))
+        best_auroc_scores.append(_df(_calc(model_class(**best_auroc_param))))
+        best_acc_scores.append(_df(_calc(model_class(**best_acc_param))))
+        best_avg_scores.append(_df(_calc(model_class(**best_avg_param))))
+
+    return best_f1_scores, best_weighted_scores, best_auroc_scores, best_acc_scores, best_avg_scores
+
+@ignore_warnings(category=ConvergenceWarning)
+def _evaluate_binary_classification(train, test, info, val=None):
+    x_trains, y_trains, x_valid, y_valid, x_test, y_test, classifiers = prepare_ml_problem(train, test, info, val=val)
+
+    unique_labels = np.unique(y_trains)
+
+    best_f1_scores = []
+    best_weighted_scores = []
+    best_auroc_scores = []
+    best_acc_scores = []
+    best_avg_scores = []
+
+    for model_spec in classifiers:
+
+        model_class = model_spec['class']
+        model_kwargs = model_spec.get('kwargs', dict())
+        model_repr = model_class.__name__
+
+        unique_labels = np.unique(y_trains)
+
+        param_set = list(ParameterGrid(model_kwargs))
+
+        results = []
+        for param in tqdm(param_set):
+            model = model_class(**param)
+
+            try:
+                model.fit(x_trains, y_trains)
+            except ValueError:
+                pass
+
+            if len(unique_labels) == 1:
+                pred = [unique_labels[0]] * len(x_valid)
+                pred_prob = np.array([1.] * len(x_valid))
+            else:
+                pred = model.predict(x_valid)
+                pred_prob = model.predict_proba(x_valid)
+
+            binary_f1 = f1_score(y_valid, pred, average='binary')
+            weighted_f1 = _weighted_f1(y_valid, pred)
+            acc = accuracy_score(y_valid, pred)
+            precision = precision_score(y_valid, pred, average='binary')
+            recall = recall_score(y_valid, pred, average='binary')
+            macro_f1 = f1_score(y_valid, pred, average='macro')
+
+            # auroc
+            size = 2
+            rest_label = set(range(size)) - set(unique_labels)
+            tmp = []
+            j = 0
+            for i in range(size):
+                if i in rest_label:
+                    tmp.append(np.array([0] * y_valid.shape[0])[:,np.newaxis])
+                else:
+                    try:
+                        tmp.append(pred_prob[:,[j]])
+                    except:
+                        tmp.append(pred_prob[:, np.newaxis])
+                    j += 1
+            roc_auc = roc_auc_score(np.eye(size)[y_valid], np.hstack(tmp))
+
+            results.append(
+                {   
+                    "name": model_repr,
+                    "param": param,
+                    "binary_f1": binary_f1,
+                    "weighted_f1": weighted_f1,
+                    "roc_auc": roc_auc, 
+                    "accuracy": acc, 
+                    "precision": precision, 
+                    "recall": recall, 
+                    "macro_f1": macro_f1
+                }
+            )
+
+
+        # test the best model
+        results = pd.DataFrame(results)
+        results['avg'] = results.loc[:, ['binary_f1', 'weighted_f1', 'roc_auc']].mean(axis=1)        
+        best_f1_param = results.param[results.binary_f1.idxmax()]
+        best_weighted_param = results.param[results.weighted_f1.idxmax()]
+        best_auroc_param = results.param[results.roc_auc.idxmax()]
+        best_acc_param = results.param[results.accuracy.idxmax()]
+        best_avg_param = results.param[results.avg.idxmax()]
+
+
+        def _calc(best_model):
+            best_scores = []
+
+            best_model.fit(x_trains, y_trains)
+
+            if len(unique_labels) == 1:
+                pred = [unique_labels[0]] * len(x_test)
+                pred_prob = np.array([1.] * len(x_test))
+            else:
+                pred = best_model.predict(x_test)
+                pred_prob = best_model.predict_proba(x_test)
+
+            binary_f1 = f1_score(y_test, pred, average='binary')
+            weighted_f1 = _weighted_f1(y_test, pred)
+            acc = accuracy_score(y_test, pred)
+            precision = precision_score(y_test, pred, average='binary')
+            recall = recall_score(y_test, pred, average='binary')
+            macro_f1 = f1_score(y_test, pred, average='macro')
+
+            # auroc
+            size = 2
+            rest_label = set(range(size)) - set(unique_labels)
+            tmp = []
+            j = 0
+            for i in range(size):
+                if i in rest_label:
+                    tmp.append(np.array([0] * y_test.shape[0])[:,np.newaxis])
+                else:
+                    try:
+                        tmp.append(pred_prob[:,[j]])
+                    except:
+                        tmp.append(pred_prob[:, np.newaxis])
+                    j += 1
+            try:
+                roc_auc = roc_auc_score(np.eye(size)[y_test], np.hstack(tmp))
+            except ValueError:
+                tmp[1] = tmp[1].reshape(20000, 1)
+                roc_auc = roc_auc_score(np.eye(size)[y_test], np.hstack(tmp))
+
+            best_scores.append(
+                {   
+                    "name": model_repr,
+                    # "param": param,
+                    "binary_f1": binary_f1,
+                    "weighted_f1": weighted_f1,
+                    "roc_auc": roc_auc, 
+                    "accuracy": acc, 
+                    "precision": precision, 
+                    "recall": recall, 
+                    "macro_f1": macro_f1
+                }
+            )
+
+            return pd.DataFrame(best_scores)
+        def _df(dataframe):
+            return {
+                "name": model_repr,
+                "binary_f1": dataframe.binary_f1.values[0],
+                "roc_auc": dataframe.roc_auc.values[0],
+                "weighted_f1": dataframe.weighted_f1.values[0],
+                "accuracy": dataframe.accuracy.values[0],
+            }
+        
+        best_f1_scores.append(_df(_calc(model_class(**best_f1_param))))
+        best_weighted_scores.append(_df(_calc(model_class(**best_weighted_param))))
+        best_auroc_scores.append(_df(_calc(model_class(**best_auroc_param))))
+        best_acc_scores.append(_df(_calc(model_class(**best_acc_param))))
+        best_avg_scores.append(_df(_calc(model_class(**best_avg_param))))
+
+    return best_f1_scores, best_weighted_scores, best_auroc_scores, best_acc_scores, best_avg_scores
+
+@ignore_warnings(category=ConvergenceWarning)
+def _evaluate_regression(train, test, info, val=None):
+    
+    x_trains, y_trains, x_valid, y_valid, x_test, y_test, regressors = prepare_ml_problem(train, test, info, val=val)
+
+    
+    best_r2_scores = []
+    best_ev_scores = []
+    best_mae_scores = []
+    best_rmse_scores = []
+    best_avg_scores = []
+
+    y_trains = np.log(np.clip(y_trains, 1, 20000))
+    y_test = np.log(np.clip(y_test, 1, 20000))
+
+    for model_spec in regressors:
+        model_class = model_spec['class']
+        model_kwargs = model_spec.get('kwargs', dict())
+        model_repr = model_class.__name__
+
+        param_set = list(ParameterGrid(model_kwargs))
+
+        results = []
+        for param in tqdm(param_set):
+            model = model_class(**param)
+            model.fit(x_trains, y_trains)
+            pred = model.predict(x_valid)
+
+            r2 = r2_score(y_valid, pred)
+            explained_variance = explained_variance_score(y_valid, pred)
+            mean_squared = mean_squared_error(y_valid, pred)
+            root_mean_squared = np.sqrt(mean_squared)
+            mean_absolute = mean_absolute_error(y_valid, pred)
+
+            results.append(
+                {   
+                    "name": model_repr,
+                    "param": param,
+                    "r2": r2,
+                    "explained_variance": explained_variance,
+                    "mean_squared": mean_squared, 
+                    "mean_absolute": mean_absolute, 
+                    "rmse": root_mean_squared
+                }
+            )
+
+        results = pd.DataFrame(results)
+        # results['avg'] = results.loc[:, ['r2', 'rmse']].mean(axis=1)        
+        best_r2_param = results.param[results.r2.idxmax()]
+        best_ev_param = results.param[results.explained_variance.idxmax()]
+        best_mae_param = results.param[results.mean_absolute.idxmin()]
+        best_rmse_param = results.param[results.rmse.idxmin()]
+        # best_avg_param = results.param[results.avg.idxmax()]
+
+        def _calc(best_model):
+            best_scores = []
+            x_train, y_train = x_trains, y_trains
+            
+            best_model.fit(x_train, y_train)
+            pred = best_model.predict(x_test)
+
+            r2 = r2_score(y_test, pred)
+            explained_variance = explained_variance_score(y_test, pred)
+            mean_squared = mean_squared_error(y_test, pred)
+            root_mean_squared = np.sqrt(mean_squared)
+            mean_absolute = mean_absolute_error(y_test, pred)
+
+            best_scores.append(
+                {   
+                    "name": model_repr,
+                    "param": param,
+                    "r2": r2,
+                    "explained_variance": explained_variance,
+                    "mean_squared": mean_squared, 
+                    "mean_absolute": mean_absolute, 
+                    "rmse": root_mean_squared
+                }
+            )
+
+            return pd.DataFrame(best_scores)
+
+        def _df(dataframe):
+            return {
+                "name": model_repr,
+                "r2": dataframe.r2.values[0].astype(float),
+                "explained_variance": dataframe.explained_variance.values[0].astype(float),
+                "MAE": dataframe.mean_absolute.values[0].astype(float),
+                "RMSE": dataframe.rmse.values[0].astype(float),
+            }
+
+        best_r2_scores.append(_df(_calc(model_class(**best_r2_param))))
+        best_ev_scores.append(_df(_calc(model_class(**best_ev_param))))
+        best_mae_scores.append(_df(_calc(model_class(**best_mae_param))))
+        best_rmse_scores.append(_df(_calc(model_class(**best_rmse_param))))
+
+    return best_r2_scores, best_rmse_scores
+
+@ignore_warnings(category=ConvergenceWarning)
+def compute_diversity(train, fake):
+    nearest_k = 5
+    if train.shape[0] >= 50000:
+        num = np.random.randint(0, train.shape[0], 50000)
+        real_features = train[num]
+        fake_features_lst = [i[num] for i in fake]
+    else:
+        num = train.shape[0]
+        real_features = train[:num]
+        fake_features_lst = [i[:num] for i in fake]
+    scores = []
+    for i, data in enumerate(fake_features_lst):
+        fake_features = data
+        metrics = compute_prdc(real_features=real_features,
+                        fake_features=fake_features,
+                        nearest_k=nearest_k)
+        metrics['i'] = i
+        scores.append(metrics)
+    return pd.DataFrame(scores).mean(axis=0), pd.DataFrame(scores).std(axis=0)
+
+_EVALUATORS = {
+    'binclass': _evaluate_binary_classification,
+    'multiclass': _evaluate_multi_classification,
+    'regression': _evaluate_regression
+}
+
+def get_evaluator(problem_type):
+    return _EVALUATORS[problem_type]
+
+
+def compute_scores(train, test, synthesized_data, metadata, eval):
+    a, b, c = _EVALUATORS[metadata['problem_type']](train=train, test=test, fake=synthesized_data, metadata=metadata, eval=eval)
+    if eval is None:
+        return a.mean(axis=0), a.std(axis=0), a[['name','param']]
+    else:
+        return a.mean(axis=0), a.std(axis=0)
+

SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/eval/mle/tabular_dataload.py

@@ -0,0 +1,111 @@
+# coding=utf-8
+# Copyright 2020 The Google Research Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# pylint: skip-file
+"""Return training and evaluation/test datasets from config files."""
+import torch
+import numpy as np
+import pandas as pd
+from tabular_transformer import GeneralTransformer
+import json
+import logging
+import os
+
+CATEGORICAL = "categorical"
+CONTINUOUS = "continuous"
+
+LOGGER = logging.getLogger(__name__)
+
+DATA_PATH = os.path.join(os.path.dirname(__file__), 'tabular_datasets')
+
+def _load_json(path):
+    with open(path) as json_file:
+        return json.load(json_file)
+
+
+def _load_file(filename, loader):
+    local_path = os.path.join(DATA_PATH, filename)
+    
+    if loader == np.load:
+        return loader(local_path, allow_pickle=True)
+    return loader(local_path)
+
+
+def _get_columns(metadata):
+    categorical_columns = list()
+
+    for column_idx, column in enumerate(metadata['columns']):
+        if column['type'] == CATEGORICAL:
+            categorical_columns.append(column_idx)
+
+    return categorical_columns
+
+
+def load_data(name):
+    data_dir = f'data/{name}'
+    info_path = f'{data_dir}/info.json'
+
+    train = pd.read_csv(f'{data_dir}/train.csv').to_numpy()
+    test = pd.read_csv(f'{data_dir}/test.csv').to_numpy()
+
+    with open(f'{data_dir}/info.json', 'r') as f:
+        info = json.load(f)
+
+    task_type = info['task_type']
+
+    num_cols = info['num_col_idx']
+    cat_cols = info['cat_col_idx']
+    target_cols = info['target_col_idx']
+
+    if task_type != 'regression':
+        cat_cols = cat_cols + target_cols
+
+    return train, test, (cat_cols, info)
+        
+
+def get_dataset(FLAGS, evaluation=False):
+
+    batch_size = FLAGS.training_batch_size if not evaluation else FLAGS.eval_batch_size
+
+    if batch_size % torch.cuda.device_count() != 0:
+        raise ValueError(f'Batch sizes ({batch_size} must be divided by'
+                            f'the number of devices ({torch.cuda.device_count()})')
+
+
+    # Create dataset builders for tabular data.
+    train, test, cols = load_data(FLAGS.dataname)
+    cols_idx = list(np.arange(train.shape[1]))
+    dis_idx = cols[0]
+    con_idx = [x for x in cols_idx if x not in dis_idx]
+
+    #split continuous and categorical
+    train_con = train[:,con_idx]
+    train_dis = train[:,dis_idx]
+
+    #new index
+    cat_idx_ = list(np.arange(train_dis.shape[1]))[:len(cols[0])]
+
+    transformer_con = GeneralTransformer()
+    transformer_dis = GeneralTransformer()
+
+    transformer_con.fit(train_con, [])
+    transformer_dis.fit(train_dis, cat_idx_)
+
+    train_con_data = transformer_con.transform(train_con)
+    train_dis_data = transformer_dis.transform(train_dis)
+
+
+    return train, train_con_data, train_dis_data, test, (transformer_con, transformer_dis, cols[1]), con_idx, dis_idx
+        

SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/eval/mle/tabular_transformer.py

@@ -0,0 +1,110 @@
+import numpy as np
+import pandas as pd
+
+CATEGORICAL = "categorical"
+CONTINUOUS = "continuous"
+
+class Transformer:
+
+    @staticmethod
+    def get_metadata(data, categorical_columns=tuple()):
+        meta = []
+
+        df = pd.DataFrame(data)
+        for index in df:
+            column = df[index]
+
+            if index in categorical_columns:
+                mapper = column.value_counts().index.tolist()
+                meta.append({
+                    "name": index,
+                    "type": CATEGORICAL,
+                    "size": len(mapper),
+                    "i2s": mapper
+                })
+            else: 
+                meta.append({
+                    "name": index,
+                    "type": CONTINUOUS,
+                    "min": column.min(),
+                    "max": column.max(),
+                })
+
+        return meta
+
+    def fit(self, data, categorical_columns=tuple()):
+        raise NotImplementedError
+
+    def transform(self, data):
+        raise NotImplementedError
+
+    def inverse_transform(self, data):
+        raise NotImplementedError
+
+
+class GeneralTransformer(Transformer):
+
+    def __init__(self, act='tanh'):
+        self.act = act
+        self.meta = None
+        self.output_dim = None
+
+    def fit(self, data, categorical_columns=tuple()):
+        self.meta = self.get_metadata(data, categorical_columns)
+        self.output_dim = 0
+        for info in self.meta:
+            if info['type'] in [CONTINUOUS]:
+                self.output_dim += 1
+            else:
+                self.output_dim += info['size']
+
+    def transform(self, data):
+        data_t = []
+        self.output_info = []
+        for id_, info in enumerate(self.meta):
+            col = data[:, id_]
+            if info['type'] == CONTINUOUS:
+                col = (col - (info['min'])) / (info['max'] - info['min'])
+                if self.act == 'tanh':
+                    col = col * 2 - 1
+                data_t.append(col.reshape([-1, 1]))
+                self.output_info.append((1, self.act))
+
+            else:
+                col_t = np.zeros([len(data), info['size']])
+                idx = list(map(info['i2s'].index, col))
+                col_t[np.arange(len(data)), idx] = 1
+                data_t.append(col_t)
+                self.output_info.append((info['size'], 'softmax'))
+
+        return np.concatenate(data_t, axis=1)
+
+    def inverse_transform(self, data):
+        if self.meta[1]['type'] == CONTINUOUS:
+            data_t = np.zeros([len(data), len(self.meta)])
+        else:
+            dtype = np.dtype('U50') 
+            data_t = np.empty([len(data), len(self.meta)], dtype=dtype)
+
+
+        data = data.copy()
+        for id_, info in enumerate(self.meta):
+            
+            if info['type'] == CONTINUOUS:
+                current = data[:, 0]
+                data = data[:, 1:]
+
+                if self.act == 'tanh':
+                    current = (current + 1) / 2
+
+                current = np.clip(current, 0, 1)
+                data_t[:, id_] = current * (info['max'] - info['min']) + info['min']
+
+            else:
+                current = data[:, :info['size']]
+                data = data[:, info['size']:]
+                idx = np.argmax(current, axis=1)
+                recovered  = list(map(info['i2s'].__getitem__, idx))
+
+                data_t[:, id_] = recovered
+        return data_t

SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/eval/visualize_density.py

@@ -0,0 +1,85 @@
+# %%
+import numpy as np
+import pandas as pd
+import torch
+import os 
+
+import json
+
+# Metrics
+from sdmetrics.visualization import get_column_plot
+
+import plotly.io as pio
+from PIL import Image
+from io import BytesIO
+
+from tqdm import tqdm
+import argparse
+
+def main(args):
+    dataname = args.dataname        
+    sample_file_name = args.sample_file_name
+
+    syn_path = f'synthetic/{dataname}/{sample_file_name}'
+    real_path = f'synthetic/{dataname}/real.csv'
+
+    syn_data = pd.read_csv(syn_path)
+    real_data = pd.read_csv(real_path)
+
+    print((real_data[:2]))
+
+    data_dir = f'data/{dataname}' 
+    with open(f'{data_dir}/info.json', 'r') as f:
+        info = json.load(f)
+
+    big_img = plot_density(syn_data, real_data, info)
+
+    save_dir =  f"eval/density_graphs/{dataname}"
+    if not os.path.exists(save_dir):
+        os.makedirs(save_dir)
+    save_path = os.path.join(save_dir, sample_file_name.replace('.csv', '.png'))
+    big_img.save(save_path)
+    print(f"Saved density graph to {save_path}")
+
+def plot_density(syn_data, real_data, info, num_per_row=3):
+    column_names = info['column_names']
+    num_cat = len(column_names)
+    num_col = num_per_row
+    num_row = (num_cat-1)//num_col+1
+
+    imgs = []
+    for i, col in tqdm(enumerate(column_names), total = len(column_names)):
+        # plot_type = 'bar' if i in info['cat_col_idx'] else 'distplot'
+        plot_type = 'bar' if info['metadata']['columns'][str(i)]['sdtype'] == 'categorical' else 'distplot'
+        if plot_type == 'distplot' and (syn_data[col][0] == syn_data[col]).all():     # to tackle a very weird bug 
+        # If the continuous data all aggregate at a single value, get_column_plot() cannot plot a density curve for it.
+        # So, we perturb one entry of the cont data by a small amount
+            print(f"\n ALERT: the generated samples column_{i} with name '{col}' all has the same value of {syn_data[col][0]} \n")
+            syn_data[col][0] += 1e-5
+        fig = get_column_plot(
+            real_data=real_data,
+            synthetic_data=syn_data,
+            column_name=col,
+            plot_type=plot_type
+        )
+        
+        img_bytes = pio.to_image(fig, format='png')
+        img = Image.open(BytesIO(img_bytes))
+        imgs.append(img)
+        
+    width, height = imgs[0].size
+    big_img = Image.new('RGB', (width * num_col, height * num_row))
+    for i, img in enumerate(imgs):
+        coordinate = (i%num_col * width, i//num_col * height)
+        big_img.paste(img, coordinate)
+    return big_img
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser()
+    
+    parser.add_argument('--dataname', type=str, default='adult')
+    parser.add_argument('--sample_file_name', type=str, default='tabsyn.csv')
+
+    args = parser.parse_args()
+    
+    main(args)

SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/images/demo.pdf

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

SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/main.py

@@ -0,0 +1,32 @@
+import torch
+from ef_vfm.main import main as ef_vfm_main
+import argparse
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description='Training of EF-VFM (TabbyFlow) for tabular data generation')
+
+    # General configs
+    parser.add_argument('--dataname', type=str, default='adult', help='Name dataset, one of those in data/ dir')
+    parser.add_argument('--mode', type=str, default='train', help='train or test')
+    parser.add_argument('--method', type=str, default='ef_vfm', help='Currently we only release our model EF-VFM. Baselines will be released soon.')
+    parser.add_argument('--gpu', type=int, default=0, help='GPU index')
+    parser.add_argument('--debug', action='store_true', help='Enable debug mode')
+    parser.add_argument('--no_wandb', action='store_true', help='disable wandb')
+    parser.add_argument('--exp_name', type=str, default=None, help='Experiment name, used to name log directories and the wandb run name')
+    parser.add_argument('--deterministic', action='store_true', help='Whether to make the entire process deterministic, i.e., fix global random seeds')
+    
+    # Configs for testing ef_vfm
+    parser.add_argument('--num_samples_to_generate', type=int, default=None, help='Number of samples to be generated while testing')
+    parser.add_argument('--ckpt_path', type=str, default=None, help='Path to the model checkpoint to be tested')
+    parser.add_argument('--report', action='store_true', help="Report testing mode: this mode sequentially runs <num_runs> test runs and report the avg and std")
+    parser.add_argument('--num_runs', type=int, default=20, help="Number of runs to be averaged in the report testing mode")
+
+    args = parser.parse_args()
+
+    # check cuda
+    if args.gpu != -1 and torch.cuda.is_available():
+        args.device = f'cuda:{args.gpu}'
+    else:
+        args.device = 'cpu'
+    
+    ef_vfm_main(args)

SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/process_dataset.py

@@ -0,0 +1,492 @@
+import numpy as np
+import pandas as pd
+import os
+import sys
+import json
+import argparse
+
+from sklearn.preprocessing import OrdinalEncoder
+from sklearn import model_selection
+
+TYPE_TRANSFORM ={
+    'float', np.float32,
+    'str', str,
+    'int', int
+}
+
+INFO_PATH = 'data/Info'
+
+parser = argparse.ArgumentParser(description='process dataset')
+
+# General configs
+parser.add_argument('--dataname', type=str, default=None, help='Name of dataset.')
+args = parser.parse_args()
+
+def preprocess_beijing():
+    with open(f'{INFO_PATH}/beijing.json', 'r') as f:
+        info = json.load(f)
+    
+    data_path = info['raw_data_path']
+
+    data_df = pd.read_csv(data_path)
+    columns = data_df.columns
+
+    data_df = data_df[columns[1:]]
+
+
+    df_cleaned = data_df.dropna()
+    df_cleaned.to_csv(info['data_path'], index = False)
+    
+def preprocess_beijing_dcr():
+    with open(f'{INFO_PATH}/beijing_dcr.json', 'r') as f:
+        info = json.load(f)
+    
+    data_path = info['raw_data_path']
+
+    data_df = pd.read_csv(data_path)
+    columns = data_df.columns
+
+    data_df = data_df[columns[1:]]
+
+    df_cleaned = data_df.dropna()
+    df_cleaned.to_csv(info['data_path'], index = False)
+
+def preprocess_news(remove_cat=False):
+    name = 'news' if not remove_cat else 'news_nocat'
+    with open(f'{INFO_PATH}/{name}.json', 'r') as f:
+        info = json.load(f)
+
+    data_path = info['raw_data_path']
+    data_df = pd.read_csv(data_path)
+    data_df = data_df.drop('url', axis=1)
+
+    columns = np.array(data_df.columns.tolist())
+
+    cat_columns1 = columns[list(range(12,18))]
+    cat_columns2 = columns[list(range(30,38))]
+    
+    if not remove_cat:
+        cat_col1 = data_df[cat_columns1].astype(int).to_numpy().argmax(axis = 1)
+        cat_col2 = data_df[cat_columns2].astype(int).to_numpy().argmax(axis = 1)
+
+    data_df = data_df.drop(cat_columns2, axis=1)
+    data_df = data_df.drop(cat_columns1, axis=1)
+
+    if not remove_cat:
+        data_df['data_channel'] = cat_col1
+        data_df['weekday'] = cat_col2
+    
+    data_save_path = f'data/{name}/{name}.csv'
+    data_df.to_csv(f'{data_save_path}', index = False)
+
+    columns = np.array(data_df.columns.tolist())
+    num_columns = columns[list(range(45))]
+    cat_columns = ['data_channel', 'weekday'] if not remove_cat else []
+    target_columns = columns[[45]]
+
+    info['num_col_idx'] = list(range(45))
+    info['cat_col_idx'] = [46, 47] if not remove_cat else []
+    info['target_col_idx'] = [45]
+    info['data_path'] = data_save_path
+    
+    with open(f'{INFO_PATH}/{name}.json', 'w') as file:
+        json.dump(info, file, indent=4)
+        
+def preprocess_news_dcr(remove_cat=False):
+    name = 'news_dcr' if not remove_cat else 'news_nocat_dcr'
+    with open(f'{INFO_PATH}/{name}.json', 'r') as f:
+        info = json.load(f)
+
+    data_path = info['raw_data_path']
+    data_df = pd.read_csv(data_path)
+    data_df = data_df.drop('url', axis=1)
+
+    columns = np.array(data_df.columns.tolist())
+
+    cat_columns1 = columns[list(range(12,18))]
+    cat_columns2 = columns[list(range(30,38))]
+    
+    if not remove_cat:
+        cat_col1 = data_df[cat_columns1].astype(int).to_numpy().argmax(axis = 1)
+        cat_col2 = data_df[cat_columns2].astype(int).to_numpy().argmax(axis = 1)
+
+    data_df = data_df.drop(cat_columns2, axis=1)
+    data_df = data_df.drop(cat_columns1, axis=1)
+
+    if not remove_cat:
+        data_df['data_channel'] = cat_col1
+        data_df['weekday'] = cat_col2
+    
+    data_save_path = f'data/{name}/{name}.csv'
+    data_df.to_csv(f'{data_save_path}', index = False)
+
+    columns = np.array(data_df.columns.tolist())
+    num_columns = columns[list(range(45))]
+    cat_columns = ['data_channel', 'weekday'] if not remove_cat else []
+    target_columns = columns[[45]]
+
+    info['num_col_idx'] = list(range(45))
+    info['cat_col_idx'] = [46, 47] if not remove_cat else []
+    info['target_col_idx'] = [45]
+    info['data_path'] = data_save_path
+    
+    with open(f'{INFO_PATH}/{name}.json', 'w') as file:
+        json.dump(info, file, indent=4)   
+
+
+def get_column_name_mapping(data_df, num_col_idx, cat_col_idx, target_col_idx, column_names = None):
+    
+    if not column_names:
+        column_names = np.array(data_df.columns.tolist())
+
+    idx_mapping = {}
+
+    curr_num_idx = 0
+    curr_cat_idx = len(num_col_idx)
+    curr_target_idx = curr_cat_idx + len(cat_col_idx)
+
+    for idx in range(len(column_names)):
+
+        if idx in num_col_idx:
+            idx_mapping[int(idx)] = curr_num_idx
+            curr_num_idx += 1
+        elif idx in cat_col_idx:
+            idx_mapping[int(idx)] = curr_cat_idx
+            curr_cat_idx += 1
+        else:
+            idx_mapping[int(idx)] = curr_target_idx
+            curr_target_idx += 1
+
+    inverse_idx_mapping = {}
+    for k, v in idx_mapping.items():
+        inverse_idx_mapping[int(v)] = k
+        
+    idx_name_mapping = {}
+    
+    for i in range(len(column_names)):
+        idx_name_mapping[int(i)] = column_names[i]
+
+    return idx_mapping, inverse_idx_mapping, idx_name_mapping
+
+
+def train_val_test_split(data_df, cat_columns, num_train = 0, num_test = 0):
+    total_num = data_df.shape[0]
+    idx = np.arange(total_num)
+
+    seed = 1234
+
+    while True:
+        np.random.seed(seed)
+        np.random.shuffle(idx)
+
+        train_idx = idx[:num_train]
+        test_idx = idx[-num_test:]
+
+        train_df = data_df.loc[train_idx]
+        test_df = data_df.loc[test_idx]
+
+        flag = 0
+        for i in cat_columns:
+            if len(set(train_df[i])) != len(set(data_df[i])):
+                flag = 1
+                break
+
+        if flag == 0:
+            break
+        else:
+            seed += 1
+        
+    return train_df, test_df, seed    
+
+
+def process_data(name):
+
+    if name == 'news':
+        preprocess_news()
+    elif name == 'news_nocat':
+        preprocess_news(remove_cat=True)
+    elif name == 'news_dcr':
+        preprocess_news_dcr()
+    elif name == 'beijing':
+        preprocess_beijing()
+    elif name == 'beijing_dcr':
+        preprocess_beijing_dcr()
+
+    with open(f'{INFO_PATH}/{name}.json', 'r') as f:
+        info = json.load(f)
+
+    data_path = info['data_path']
+    if info['file_type'] == 'csv':
+        data_df = pd.read_csv(data_path, header = info['header'])
+
+    elif info['file_type'] == 'xls':
+        data_df = pd.read_excel(data_path, sheet_name='Data', header=1)
+        data_df = data_df.drop('ID', axis=1)
+
+    num_data = data_df.shape[0]
+
+    column_names = info['column_names'] if info['column_names'] else data_df.columns.tolist()
+ 
+    num_col_idx = info['num_col_idx']
+    cat_col_idx = info['cat_col_idx']
+    target_col_idx = info['target_col_idx']
+
+    num_columns = [column_names[i] for i in num_col_idx]
+    cat_columns = [column_names[i] for i in cat_col_idx]
+    target_columns = [column_names[i] for i in target_col_idx]
+    
+    idx_mapping, inverse_idx_mapping, idx_name_mapping = get_column_name_mapping(data_df, num_col_idx, cat_col_idx, target_col_idx, column_names)
+
+    has_val = bool(info['val_path'])
+    val_df = pd.DataFrame(columns=data_df.columns).astype(data_df.dtypes)   # by default (val_path is not provided), set val_Df to be empty
+    if info['test_path']:
+
+        # if testing data is given
+        test_path = info['test_path']
+        
+        if "adult" in name:     # BUG: currently data saved at adult's test_path cannot be directly loaded. Consider integrate the following code to a preprocesing function for adult
+            with open(test_path, 'r') as f:
+                lines = f.readlines()[1:]
+                test_save_path = f'data/{name}/test.data'
+                if not os.path.exists(test_save_path):
+                    with open(test_save_path, 'a') as f1:     
+                        for line in lines:
+                            save_line = line.strip('\n').strip('.')
+                            f1.write(f'{save_line}\n')
+
+            test_df = pd.read_csv(test_save_path, header = None)
+        else:
+            test_df = pd.read_csv(test_path, header = info['header'])
+            
+        if has_val:     # currently you cannot have a val path without a test path
+            val_path = info['val_path']
+            val_df = pd.read_csv(val_path, header = info['header'])
+            
+        train_df = data_df
+        
+        if "dcr" in name and "diabetes" not in name:   # create 50/50 splits for dcr datasets; no need for this for diabetes dataset as it's done in preprocessing
+            complete_df = pd.concat([train_df, test_df, val_df], axis = 0, ignore_index=True)
+            num_data = complete_df.shape[0]
+            num_train = int(num_data*0.5)
+            num_test = num_data - num_train
+            complete_df.rename(columns = idx_name_mapping, inplace=True)
+            train_df, test_df, seed = train_val_test_split(complete_df, cat_columns, num_train, num_test)
+
+    else:  
+        # Train/ Test Split, 90% Training (50% for dcr eval exclusively), 10% Testing (Validation set will be selected from Training set)
+        if "dcr" in name:
+            num_train = int(num_data*0.5)
+        else:
+            num_train = int(num_data*0.9)
+        num_test = num_data - num_train
+
+        train_df, test_df, seed = train_val_test_split(data_df, cat_columns, num_train, num_test)
+    
+    complete_df = pd.concat([train_df, test_df, val_df], axis = 0)
+    name_idx_mapping = {val: key for key, val in idx_name_mapping.items()}
+    int_columns = []
+    int_col_idx = []
+    int_col_idx_wrt_num = []
+    for i, col_idx in enumerate(num_col_idx):
+        col = column_names[col_idx]
+        col_data = complete_df.iloc[:,col_idx]
+        is_int = (col_data%1 == 0).all()
+        if is_int:
+            int_columns.append(col)
+            int_col_idx.append(name_idx_mapping[col])
+            int_col_idx_wrt_num.append(i)
+    info['int_col_idx'] = int_col_idx
+    info['int_columns'] = int_columns
+    info['int_col_idx_wrt_num'] = int_col_idx_wrt_num
+
+    train_df.columns = range(len(train_df.columns))
+    test_df.columns = range(len(test_df.columns))
+    val_df.columns = range(len(val_df.columns))
+
+    print(name, train_df.shape, val_df.shape, test_df.shape, data_df.shape)
+
+    col_info = {}
+    
+    for col_idx in num_col_idx:
+        col_info[col_idx] = {}
+        col_info['type'] = 'numerical'
+        col_info['max'] = float(train_df[col_idx].max())
+        col_info['min'] = float(train_df[col_idx].min())
+     
+    for col_idx in cat_col_idx:
+        col_info[col_idx] = {}
+        col_info['type'] = 'categorical'
+        col_info['categorizes'] = list(set(train_df[col_idx]))    
+
+    for col_idx in target_col_idx:
+        if info['task_type'] == 'regression':
+            col_info[col_idx] = {}
+            col_info['type'] = 'numerical'
+            col_info['max'] = float(train_df[col_idx].max())
+            col_info['min'] = float(train_df[col_idx].min())
+        else:
+            col_info[col_idx] = {}
+            col_info['type'] = 'categorical'
+            col_info['categorizes'] = list(set(train_df[col_idx]))      
+
+    info['column_info'] = col_info
+
+    train_df.rename(columns = idx_name_mapping, inplace=True)
+    test_df.rename(columns = idx_name_mapping, inplace=True)
+    val_df.rename(columns = idx_name_mapping, inplace=True)
+
+    for col in num_columns:
+        if (train_df[col] == ' ?').sum() > 0:
+            print(col)
+            import pdb; pdb.set_trace()
+        if (train_df[col] == '?').sum() > 0:
+            print(col)
+            import pdb; pdb.set_trace()
+        train_df.loc[train_df[col] == '?', col] = np.nan
+    for col in cat_columns:
+        train_df.loc[train_df[col] == '?', col] = 'nan'
+    for col in num_columns:
+        if (test_df[col] == ' ?').sum() > 0:
+            print(col)
+            import pdb; pdb.set_trace()
+        if (test_df[col] == '?').sum() > 0:
+            print(col)
+            import pdb; pdb.set_trace()
+        test_df.loc[test_df[col] == '?', col] = np.nan
+    for col in cat_columns:
+        test_df.loc[test_df[col] == '?', col] = 'nan'
+    for col in num_columns:
+        val_df.loc[val_df[col] == '?', col] = np.nan
+    for col in cat_columns:
+        val_df.loc[val_df[col] == '?', col] = 'nan'
+    
+    if train_df.isna().any().any():
+        print("Training data contains nan in the numerical cols")
+        import pdb; pdb.set_trace()
+    
+    X_num_train = train_df[num_columns].to_numpy().astype(np.float32)
+    X_cat_train = train_df[cat_columns].to_numpy()
+    y_train = train_df[target_columns].to_numpy()
+
+    X_num_test = test_df[num_columns].to_numpy().astype(np.float32)
+    X_cat_test = test_df[cat_columns].to_numpy()
+    y_test = test_df[target_columns].to_numpy()
+
+    X_num_val = val_df[num_columns].to_numpy().astype(np.float32)
+    X_cat_val = val_df[cat_columns].to_numpy()
+    y_val = val_df[target_columns].to_numpy()
+ 
+    save_dir = f'data/{name}'
+    np.save(f'{save_dir}/X_num_train.npy', X_num_train)
+    np.save(f'{save_dir}/X_cat_train.npy', X_cat_train)
+    np.save(f'{save_dir}/y_train.npy', y_train)
+
+    np.save(f'{save_dir}/X_num_test.npy', X_num_test)
+    np.save(f'{save_dir}/X_cat_test.npy', X_cat_test)
+    np.save(f'{save_dir}/y_test.npy', y_test)
+    
+    if has_val:
+        np.save(f'{save_dir}/X_num_val.npy', X_num_val)
+        np.save(f'{save_dir}/X_cat_val.npy', X_cat_val)
+        np.save(f'{save_dir}/y_val.npy', y_val)
+
+    train_df[num_columns] = train_df[num_columns].astype(np.float32)
+    test_df[num_columns] = test_df[num_columns].astype(np.float32)
+    val_df[num_columns] = val_df[num_columns].astype(np.float32)
+
+    train_df.to_csv(f'{save_dir}/train.csv', index = False)
+    test_df.to_csv(f'{save_dir}/test.csv', index = False)
+    if has_val:
+        val_df.to_csv(f'{save_dir}/val.csv', index = False)
+
+    if not os.path.exists(f'synthetic/{name}'):
+        os.makedirs(f'synthetic/{name}')
+    
+    train_df.to_csv(f'synthetic/{name}/real.csv', index = False)
+    test_df.to_csv(f'synthetic/{name}/test.csv', index = False)
+    
+    if has_val:
+        val_df.to_csv(f'synthetic/{name}/val.csv', index = False)
+
+    print('Numerical', X_num_train.shape)
+    print('Categorical', X_cat_train.shape)
+
+    info['column_names'] = column_names
+    info['train_num'] = train_df.shape[0]
+    info['test_num'] = test_df.shape[0]
+    info['val_num'] = val_df.shape[0]
+
+    info['idx_mapping'] = idx_mapping
+    info['inverse_idx_mapping'] = inverse_idx_mapping
+    info['idx_name_mapping'] = idx_name_mapping 
+
+    metadata = {'columns': {}}
+    task_type = info['task_type']
+    num_col_idx = info['num_col_idx']
+    cat_col_idx = info['cat_col_idx']
+    target_col_idx = info['target_col_idx']
+
+    for i in num_col_idx:
+        metadata['columns'][i] = {}
+        metadata['columns'][i]['sdtype'] = 'numerical'
+        metadata['columns'][i]['computer_representation'] = 'Float'
+
+    for i in cat_col_idx:
+        metadata['columns'][i] = {}
+        metadata['columns'][i]['sdtype'] = 'categorical'
+
+    if task_type == 'regression':
+        
+        for i in target_col_idx:
+            metadata['columns'][i] = {}
+            metadata['columns'][i]['sdtype'] = 'numerical'
+            metadata['columns'][i]['computer_representation'] = 'Float'
+
+    else:
+        for i in target_col_idx:
+            metadata['columns'][i] = {}
+            metadata['columns'][i]['sdtype'] = 'categorical'
+
+    info['metadata'] = metadata
+
+    with open(f'{save_dir}/info.json', 'w') as file:
+        json.dump(info, file, indent=4)
+
+    print(f'Processing and Saving {name} Successfully!')
+
+    print(name)
+    print('Total', info['train_num'] + info['test_num'])
+    print('Train', info['train_num'])
+    print('Val', info['val_num'])
+    print('Test', info['test_num'])
+    if info['task_type'] == 'regression':
+        num = len(info['num_col_idx'] + info['target_col_idx'])
+        cat = len(info['cat_col_idx'])
+    else:
+        cat = len(info['cat_col_idx'] + info['target_col_idx'])
+        num = len(info['num_col_idx'])
+    print('Num', num)
+    print('Int', len(info['int_col_idx']))
+    print('Cat', cat)
+
+if __name__ == "__main__":
+
+    if args.dataname:
+        process_data(args.dataname)
+    else:
+        for name in [
+            'adult', 
+            'default', 
+            'shoppers', 
+            'magic', 
+            'beijing', 
+            'news', 
+            'news_nocat',
+            'adult_dcr',
+            'default_dcr',
+            'shoppers_dcr',
+            'beijing_dcr',
+            'news_dcr', 
+        ]:    
+            process_data(name)
+

SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_efvfm_runtime/pyproject.toml

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

SynthData0523/main/c19/tabbyflow/tabbyflow-c19-20260510_210211/_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