Add syntheticFail c16

syntheticFail/c16/tabddpm/tabddpm-c16-20260510_215505/_tabddpm_train.py

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

syntheticFail/c16/tabddpm/tabddpm-c16-20260510_215505/config.toml

@@ -0,0 +1,39 @@
+seed = 0
+parent_dir = "/work/output-Benchmark-trainonly-v1/c16/tabddpm/tabddpm-c16-20260510_215505/output"
+real_data_path = "/work/output-Benchmark-trainonly-v1/c16/tabddpm/tabddpm-c16-20260510_215505/data"
+model_type = "mlp"
+num_numerical_features = 3
+device = "cuda:0"
+
+[model_params]
+d_in = 12
+num_classes = 18
+is_y_cond = true
+
+[model_params.rtdl_params]
+d_layers = [256, 256]
+dropout = 0.0
+
+[diffusion_params]
+num_timesteps = 200
+gaussian_loss_type = "mse"
+
+[train.main]
+steps = 2000
+lr = 0.001
+weight_decay = 0.0
+batch_size = 256
+
+[train.T]
+seed = 0
+normalization = "quantile"
+num_nan_policy = "__none__"
+cat_nan_policy = "__none__"
+cat_min_frequency = "__none__"
+cat_encoding = "__none__"
+y_policy = "default"
+
+[sample]
+num_samples = 1000
+batch_size = 256
+seed = 0

syntheticFail/c16/tabddpm/tabddpm-c16-20260510_215505/data/X_cat_train.npy

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

syntheticFail/c16/tabddpm/tabddpm-c16-20260510_215505/data/X_num_train.npy

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

syntheticFail/c16/tabddpm/tabddpm-c16-20260510_215505/data/info.json

@@ -0,0 +1,42 @@
+{
+  "name": "benchmark_dataset",
+  "task_type": "multiclass",
+  "n_num_features": 3,
+  "n_cat_features": 9,
+  "train_size": 5516,
+  "num_col_idx": [
+    0,
+    1,
+    2
+  ],
+  "cat_col_idx": [
+    3,
+    4,
+    5,
+    6,
+    7,
+    8,
+    9,
+    10,
+    11
+  ],
+  "target_col_idx": [
+    12
+  ],
+  "column_names": [
+    "page_id",
+    "APPEARANCES",
+    "YEAR",
+    "name",
+    "urlslug",
+    "ID",
+    "ALIGN",
+    "HAIR",
+    "SEX",
+    "GSM",
+    "ALIVE",
+    "FIRST APPEARANCE",
+    "EYE"
+  ],
+  "num_classes": 18
+}

syntheticFail/c16/tabddpm/tabddpm-c16-20260510_215505/data/y_train.npy

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

syntheticFail/c16/tabddpm/tabddpm-c16-20260510_215505/input_snapshot.json

@@ -0,0 +1,36 @@
+{
+  "dataset_id": "c16",
+  "model": "tabddpm",
+  "inputs": {
+    "train_csv": {
+      "path": "/data/jialinzhang/SynthesizePipeline-server/DatasetNew/c16/c16-train.csv",
+      "exists": true,
+      "size": 889767,
+      "sha256": "d87fe8c15e5364335255aabe0e5ac068dc98c8c772bcbbc52861739ec34e0914"
+    },
+    "val_csv": {
+      "path": "/data/jialinzhang/SynthesizePipeline-server/DatasetNew/c16/c16-val.csv",
+      "exists": true,
+      "size": 111085,
+      "sha256": "149f25d0314c83ff898ddfd9550fd9b048af51daa289673d6bb491653dd89d83"
+    },
+    "test_csv": {
+      "path": "/data/jialinzhang/SynthesizePipeline-server/DatasetNew/c16/c16-test.csv",
+      "exists": true,
+      "size": 111822,
+      "sha256": "bf819d88a0bc2a2659f0a25aacfe0d15ca1b9d59b498ece178817ba81f76d3bf"
+    },
+    "profile_json": {
+      "path": "/data/jialinzhang/SynthesizePipeline-server/DatasetNew/artifacts/data_core/tabular/c16/c16-dataset_profile.json",
+      "exists": true,
+      "size": 6130,
+      "sha256": "a01e7504e986616f132cc5da119064b3fe1a68c4b0475fe60628cdb608071157"
+    },
+    "contract_json": {
+      "path": "/data/jialinzhang/SynthesizePipeline-server/DatasetNew/artifacts/data_core/tabular/c16/c16-dataset_contract_v1.json",
+      "exists": true,
+      "size": 7074,
+      "sha256": "773f9641fef4054eef8038ec0bd570c990be631ca4c9748324249d2c92645ba6"
+    }
+  }
+}

syntheticFail/c16/tabddpm/tabddpm-c16-20260510_215505/public_gate/normalized_schema_snapshot.json

@@ -0,0 +1,270 @@
+{
+  "dataset_id": "c16",
+  "target_column": "EYE",
+  "task_type": "classification",
+  "columns": [
+    {
+      "name": "page_id",
+      "role": "feature",
+      "semantic_type": "numeric",
+      "nullable": false,
+      "missing_tokens": [],
+      "parse_format": null,
+      "impute_strategy": "median",
+      "profile_stats": {
+        "missing_rate": 0.0,
+        "unique_count": 5516,
+        "unique_ratio": 1.0,
+        "example_values": [
+          "1941",
+          "127435",
+          "268584",
+          "144619",
+          "132754"
+        ]
+      }
+    },
+    {
+      "name": "name",
+      "role": "id",
+      "semantic_type": "id",
+      "nullable": false,
+      "missing_tokens": [],
+      "parse_format": null,
+      "impute_strategy": "keep_raw",
+      "profile_stats": {
+        "missing_rate": 0.0,
+        "unique_count": 5516,
+        "unique_ratio": 1.0,
+        "example_values": [
+          "Jeremy Tell (New Earth)",
+          "Thomas Jarred (New Earth)",
+          "Kusanagi (New Earth)",
+          "Cecile O'Malley (New Earth)",
+          "Rori Stroh (New Earth)"
+        ]
+      }
+    },
+    {
+      "name": "urlslug",
+      "role": "id",
+      "semantic_type": "id",
+      "nullable": false,
+      "missing_tokens": [],
+      "parse_format": null,
+      "impute_strategy": "keep_raw",
+      "profile_stats": {
+        "missing_rate": 0.0,
+        "unique_count": 5516,
+        "unique_ratio": 1.0,
+        "example_values": [
+          "\\/wiki\\/Jeremy_Tell_(New_Earth)",
+          "\\/wiki\\/Thomas_Jarred_(New_Earth)",
+          "\\/wiki\\/Kusanagi_(New_Earth)",
+          "\\/wiki\\/Cecile_O%27Malley_(New_Earth)",
+          "\\/wiki\\/Rori_Stroh_(New_Earth)"
+        ]
+      }
+    },
+    {
+      "name": "ID",
+      "role": "feature",
+      "semantic_type": "text",
+      "nullable": true,
+      "missing_tokens": [],
+      "parse_format": null,
+      "impute_strategy": "keep_raw",
+      "profile_stats": {
+        "missing_rate": 0.292422,
+        "unique_count": 3,
+        "unique_ratio": 0.000769,
+        "example_values": [
+          "Public Identity",
+          "Secret Identity",
+          "Identity Unknown"
+        ]
+      }
+    },
+    {
+      "name": "ALIGN",
+      "role": "feature",
+      "semantic_type": "text",
+      "nullable": true,
+      "missing_tokens": [],
+      "parse_format": null,
+      "impute_strategy": "keep_raw",
+      "profile_stats": {
+        "missing_rate": 0.087563,
+        "unique_count": 4,
+        "unique_ratio": 0.000795,
+        "example_values": [
+          "Bad Characters",
+          "Good Characters",
+          "Neutral Characters",
+          "Reformed Criminals"
+        ]
+      }
+    },
+    {
+      "name": "EYE",
+      "role": "target",
+      "semantic_type": "text",
+      "nullable": true,
+      "missing_tokens": [],
+      "parse_format": null,
+      "impute_strategy": "keep_raw",
+      "profile_stats": {
+        "missing_rate": 0.525381,
+        "unique_count": 17,
+        "unique_ratio": 0.006494,
+        "example_values": [
+          "Black Eyes",
+          "Blue Eyes",
+          "Grey Eyes",
+          "Green Eyes",
+          "Brown Eyes"
+        ]
+      }
+    },
+    {
+      "name": "HAIR",
+      "role": "feature",
+      "semantic_type": "text",
+      "nullable": true,
+      "missing_tokens": [],
+      "parse_format": null,
+      "impute_strategy": "keep_raw",
+      "profile_stats": {
+        "missing_rate": 0.3314,
+        "unique_count": 17,
+        "unique_ratio": 0.00461,
+        "example_values": [
+          "Brown Hair",
+          "Grey Hair",
+          "Red Hair",
+          "Black Hair",
+          "White Hair"
+        ]
+      }
+    },
+    {
+      "name": "SEX",
+      "role": "feature",
+      "semantic_type": "text",
+      "nullable": true,
+      "missing_tokens": [],
+      "parse_format": null,
+      "impute_strategy": "keep_raw",
+      "profile_stats": {
+        "missing_rate": 0.018673,
+        "unique_count": 4,
+        "unique_ratio": 0.000739,
+        "example_values": [
+          "Male Characters",
+          "Female Characters",
+          "Genderless Characters",
+          "Transgender Characters"
+        ]
+      }
+    },
+    {
+      "name": "GSM",
+      "role": "feature",
+      "semantic_type": "text",
+      "nullable": true,
+      "missing_tokens": [],
+      "parse_format": null,
+      "impute_strategy": "keep_raw",
+      "profile_stats": {
+        "missing_rate": 0.990392,
+        "unique_count": 2,
+        "unique_ratio": 0.037736,
+        "example_values": [
+          "Homosexual Characters",
+          "Bisexual Characters"
+        ]
+      }
+    },
+    {
+      "name": "ALIVE",
+      "role": "feature",
+      "semantic_type": "text",
+      "nullable": true,
+      "missing_tokens": [],
+      "parse_format": null,
+      "impute_strategy": "keep_raw",
+      "profile_stats": {
+        "missing_rate": 0.000544,
+        "unique_count": 2,
+        "unique_ratio": 0.000363,
+        "example_values": [
+          "Living Characters",
+          "Deceased Characters"
+        ]
+      }
+    },
+    {
+      "name": "APPEARANCES",
+      "role": "feature",
+      "semantic_type": "numeric",
+      "nullable": true,
+      "missing_tokens": [],
+      "parse_format": null,
+      "impute_strategy": "median",
+      "profile_stats": {
+        "missing_rate": 0.051305,
+        "unique_count": 263,
+        "unique_ratio": 0.050258,
+        "example_values": [
+          "14",
+          "3",
+          "4",
+          "7",
+          "1"
+        ]
+      }
+    },
+    {
+      "name": "FIRST APPEARANCE",
+      "role": "feature",
+      "semantic_type": "datetime",
+      "nullable": true,
+      "missing_tokens": [],
+      "parse_format": "%Y-%m-%d",
+      "impute_strategy": "keep_raw",
+      "profile_stats": {
+        "missing_rate": 0.009608,
+        "unique_count": 758,
+        "unique_ratio": 0.138752,
+        "example_values": [
+          "2001, August",
+          "1990, February",
+          "2008, July",
+          "1984, April",
+          "1961, December"
+        ]
+      }
+    },
+    {
+      "name": "YEAR",
+      "role": "feature",
+      "semantic_type": "numeric",
+      "nullable": true,
+      "missing_tokens": [],
+      "parse_format": null,
+      "impute_strategy": "median",
+      "profile_stats": {
+        "missing_rate": 0.009608,
+        "unique_count": 79,
+        "unique_ratio": 0.014461,
+        "example_values": [
+          "2001",
+          "1990",
+          "2008",
+          "1984",
+          "1961"
+        ]
+      }
+    }
+  ]
+}

syntheticFail/c16/tabddpm/tabddpm-c16-20260510_215505/public_gate/public_gate_report.json

@@ -0,0 +1,37 @@
+{
+  "dataset_id": "c16",
+  "status": "pass",
+  "checks": [
+    {
+      "check_id": "PG001_csv_parse_ok",
+      "status": "pass"
+    },
+    {
+      "check_id": "PG002_split_header_consistent",
+      "status": "pass"
+    },
+    {
+      "check_id": "PG003_profile_header_match",
+      "status": "pass"
+    },
+    {
+      "check_id": "PG004_missing_token_normalized",
+      "status": "pass"
+    },
+    {
+      "check_id": "PG005_semantic_type_validated",
+      "status": "pass"
+    },
+    {
+      "check_id": "PG006_target_defined_and_valid",
+      "status": "pass"
+    }
+  ],
+  "target_column": "EYE",
+  "task_type": "classification",
+  "input_splits": {
+    "train": "/data/jialinzhang/SynthesizePipeline-server/DatasetNew/c16/c16-train.csv",
+    "val": "/data/jialinzhang/SynthesizePipeline-server/DatasetNew/c16/c16-val.csv",
+    "test": "/data/jialinzhang/SynthesizePipeline-server/DatasetNew/c16/c16-test.csv"
+  }
+}

syntheticFail/c16/tabddpm/tabddpm-c16-20260510_215505/public_gate/staged_input_manifest.json

@@ -0,0 +1,275 @@
+{
+  "dataset_id": "c16",
+  "target_column": "EYE",
+  "task_type": "classification",
+  "train_csv": "/data/jialinzhang/SynthesizePipeline-server/output-Benchmark-trainonly-v1/c16/tabddpm/tabddpm-c16-20260510_215505/staged/public/train.csv",
+  "val_csv": "/data/jialinzhang/SynthesizePipeline-server/output-Benchmark-trainonly-v1/c16/tabddpm/tabddpm-c16-20260510_215505/staged/public/val.csv",
+  "test_csv": "/data/jialinzhang/SynthesizePipeline-server/output-Benchmark-trainonly-v1/c16/tabddpm/tabddpm-c16-20260510_215505/staged/public/test.csv",
+  "features_json": "/data/jialinzhang/SynthesizePipeline-server/output-Benchmark-trainonly-v1/c16/tabddpm/tabddpm-c16-20260510_215505/staged/public/staged_features.json",
+  "public_gate_report": "/data/jialinzhang/SynthesizePipeline-server/output-Benchmark-trainonly-v1/c16/tabddpm/tabddpm-c16-20260510_215505/public_gate/public_gate_report.json",
+  "column_schema": [
+    {
+      "name": "page_id",
+      "role": "feature",
+      "semantic_type": "numeric",
+      "nullable": false,
+      "missing_tokens": [],
+      "parse_format": null,
+      "impute_strategy": "median",
+      "profile_stats": {
+        "missing_rate": 0.0,
+        "unique_count": 5516,
+        "unique_ratio": 1.0,
+        "example_values": [
+          "1941",
+          "127435",
+          "268584",
+          "144619",
+          "132754"
+        ]
+      }
+    },
+    {
+      "name": "name",
+      "role": "id",
+      "semantic_type": "id",
+      "nullable": false,
+      "missing_tokens": [],
+      "parse_format": null,
+      "impute_strategy": "keep_raw",
+      "profile_stats": {
+        "missing_rate": 0.0,
+        "unique_count": 5516,
+        "unique_ratio": 1.0,
+        "example_values": [
+          "Jeremy Tell (New Earth)",
+          "Thomas Jarred (New Earth)",
+          "Kusanagi (New Earth)",
+          "Cecile O'Malley (New Earth)",
+          "Rori Stroh (New Earth)"
+        ]
+      }
+    },
+    {
+      "name": "urlslug",
+      "role": "id",
+      "semantic_type": "id",
+      "nullable": false,
+      "missing_tokens": [],
+      "parse_format": null,
+      "impute_strategy": "keep_raw",
+      "profile_stats": {
+        "missing_rate": 0.0,
+        "unique_count": 5516,
+        "unique_ratio": 1.0,
+        "example_values": [
+          "\\/wiki\\/Jeremy_Tell_(New_Earth)",
+          "\\/wiki\\/Thomas_Jarred_(New_Earth)",
+          "\\/wiki\\/Kusanagi_(New_Earth)",
+          "\\/wiki\\/Cecile_O%27Malley_(New_Earth)",
+          "\\/wiki\\/Rori_Stroh_(New_Earth)"
+        ]
+      }
+    },
+    {
+      "name": "ID",
+      "role": "feature",
+      "semantic_type": "text",
+      "nullable": true,
+      "missing_tokens": [],
+      "parse_format": null,
+      "impute_strategy": "keep_raw",
+      "profile_stats": {
+        "missing_rate": 0.292422,
+        "unique_count": 3,
+        "unique_ratio": 0.000769,
+        "example_values": [
+          "Public Identity",
+          "Secret Identity",
+          "Identity Unknown"
+        ]
+      }
+    },
+    {
+      "name": "ALIGN",
+      "role": "feature",
+      "semantic_type": "text",
+      "nullable": true,
+      "missing_tokens": [],
+      "parse_format": null,
+      "impute_strategy": "keep_raw",
+      "profile_stats": {
+        "missing_rate": 0.087563,
+        "unique_count": 4,
+        "unique_ratio": 0.000795,
+        "example_values": [
+          "Bad Characters",
+          "Good Characters",
+          "Neutral Characters",
+          "Reformed Criminals"
+        ]
+      }
+    },
+    {
+      "name": "EYE",
+      "role": "target",
+      "semantic_type": "text",
+      "nullable": true,
+      "missing_tokens": [],
+      "parse_format": null,
+      "impute_strategy": "keep_raw",
+      "profile_stats": {
+        "missing_rate": 0.525381,
+        "unique_count": 17,
+        "unique_ratio": 0.006494,
+        "example_values": [
+          "Black Eyes",
+          "Blue Eyes",
+          "Grey Eyes",
+          "Green Eyes",
+          "Brown Eyes"
+        ]
+      }
+    },
+    {
+      "name": "HAIR",
+      "role": "feature",
+      "semantic_type": "text",
+      "nullable": true,
+      "missing_tokens": [],
+      "parse_format": null,
+      "impute_strategy": "keep_raw",
+      "profile_stats": {
+        "missing_rate": 0.3314,
+        "unique_count": 17,
+        "unique_ratio": 0.00461,
+        "example_values": [
+          "Brown Hair",
+          "Grey Hair",
+          "Red Hair",
+          "Black Hair",
+          "White Hair"
+        ]
+      }
+    },
+    {
+      "name": "SEX",
+      "role": "feature",
+      "semantic_type": "text",
+      "nullable": true,
+      "missing_tokens": [],
+      "parse_format": null,
+      "impute_strategy": "keep_raw",
+      "profile_stats": {
+        "missing_rate": 0.018673,
+        "unique_count": 4,
+        "unique_ratio": 0.000739,
+        "example_values": [
+          "Male Characters",
+          "Female Characters",
+          "Genderless Characters",
+          "Transgender Characters"
+        ]
+      }
+    },
+    {
+      "name": "GSM",
+      "role": "feature",
+      "semantic_type": "text",
+      "nullable": true,
+      "missing_tokens": [],
+      "parse_format": null,
+      "impute_strategy": "keep_raw",
+      "profile_stats": {
+        "missing_rate": 0.990392,
+        "unique_count": 2,
+        "unique_ratio": 0.037736,
+        "example_values": [
+          "Homosexual Characters",
+          "Bisexual Characters"
+        ]
+      }
+    },
+    {
+      "name": "ALIVE",
+      "role": "feature",
+      "semantic_type": "text",
+      "nullable": true,
+      "missing_tokens": [],
+      "parse_format": null,
+      "impute_strategy": "keep_raw",
+      "profile_stats": {
+        "missing_rate": 0.000544,
+        "unique_count": 2,
+        "unique_ratio": 0.000363,
+        "example_values": [
+          "Living Characters",
+          "Deceased Characters"
+        ]
+      }
+    },
+    {
+      "name": "APPEARANCES",
+      "role": "feature",
+      "semantic_type": "numeric",
+      "nullable": true,
+      "missing_tokens": [],
+      "parse_format": null,
+      "impute_strategy": "median",
+      "profile_stats": {
+        "missing_rate": 0.051305,
+        "unique_count": 263,
+        "unique_ratio": 0.050258,
+        "example_values": [
+          "14",
+          "3",
+          "4",
+          "7",
+          "1"
+        ]
+      }
+    },
+    {
+      "name": "FIRST APPEARANCE",
+      "role": "feature",
+      "semantic_type": "datetime",
+      "nullable": true,
+      "missing_tokens": [],
+      "parse_format": "%Y-%m-%d",
+      "impute_strategy": "keep_raw",
+      "profile_stats": {
+        "missing_rate": 0.009608,
+        "unique_count": 758,
+        "unique_ratio": 0.138752,
+        "example_values": [
+          "2001, August",
+          "1990, February",
+          "2008, July",
+          "1984, April",
+          "1961, December"
+        ]
+      }
+    },
+    {
+      "name": "YEAR",
+      "role": "feature",
+      "semantic_type": "numeric",
+      "nullable": true,
+      "missing_tokens": [],
+      "parse_format": null,
+      "impute_strategy": "median",
+      "profile_stats": {
+        "missing_rate": 0.009608,
+        "unique_count": 79,
+        "unique_ratio": 0.014461,
+        "example_values": [
+          "2001",
+          "1990",
+          "2008",
+          "1984",
+          "1961"
+        ]
+      }
+    }
+  ]
+}

syntheticFail/c16/tabddpm/tabddpm-c16-20260510_215505/run_config.json

@@ -0,0 +1,45 @@
+{
+  "schema_version": 1,
+  "recorded_at": "2026-05-10T21:55:05",
+  "dataset_id": "c16",
+  "model": "tabddpm",
+  "work_dir": "/data/jialinzhang/SynthesizePipeline-server/output-Benchmark-trainonly-v1/c16/tabddpm/tabddpm-c16-20260510_215505",
+  "dataset_source_requested": "new",
+  "dataset_source_resolved": "new",
+  "cli_args": {
+    "model": "tabddpm",
+    "dataset": "c16",
+    "dataset_source": "new",
+    "train": true,
+    "generate": true,
+    "num_rows": 0,
+    "epochs": null,
+    "output_dir": null,
+    "model_dir": null,
+    "work_dir": null,
+    "resume": false,
+    "no_stats": false
+  },
+  "resolved": {
+    "num_rows": 5516,
+    "model_path": null,
+    "output_csv": null
+  },
+  "input_artifacts": {
+    "public_gate_report": "/data/jialinzhang/SynthesizePipeline-server/output-Benchmark-trainonly-v1/c16/tabddpm/tabddpm-c16-20260510_215505/public_gate/public_gate_report.json",
+    "public_manifest": "/data/jialinzhang/SynthesizePipeline-server/output-Benchmark-trainonly-v1/c16/tabddpm/tabddpm-c16-20260510_215505/public_gate/staged_input_manifest.json",
+    "model_manifest": "/data/jialinzhang/SynthesizePipeline-server/output-Benchmark-trainonly-v1/c16/tabddpm/tabddpm-c16-20260510_215505/staged/tabddpm/model_input_manifest.json",
+    "train_csv": "/data/jialinzhang/SynthesizePipeline-server/output-Benchmark-trainonly-v1/c16/tabddpm/tabddpm-c16-20260510_215505/staged/public/train.csv",
+    "features_json": "/data/jialinzhang/SynthesizePipeline-server/output-Benchmark-trainonly-v1/c16/tabddpm/tabddpm-c16-20260510_215505/staged/public/staged_features.json",
+    "target_column": "EYE",
+    "task_type": "classification"
+  },
+  "env_overrides": {
+    "BENCHMARK_TABDDPM_GPUS": "device=3",
+    "TABDDPM_NUM_TIMESTEPS": "200",
+    "TABDDPM_SAMPLE_BATCH_SIZE": "256",
+    "TABDDPM_STEPS_PER_EPOCH": "40",
+    "TABDDPM_TRAIN_BATCH_SIZE": "256",
+    "TABDDPM_TRAIN_LR": "0.001"
+  }
+}

syntheticFail/c16/tabddpm/tabddpm-c16-20260510_215505/runtime_result.json

@@ -0,0 +1,24 @@
+{
+  "dataset_id": "c16",
+  "model": "tabddpm",
+  "run_id": "tabddpm-c16-20260510_215505",
+  "public_gate_status": "pass",
+  "adapter_ready_status": "pass",
+  "train_status": "fail",
+  "generate_status": "skipped",
+  "reason_code": "adapter_runtime_error",
+  "reason_detail": "Command '['docker', 'run', '--rm', '--init', '--user', '1005:1005', '-e', 'HOME=/work/.home', '--cidfile', '/tmp/bench_docker_tabddpm_55okq9zk/container.cid', '--gpus', 'device=3', '-v', '/data/jialinzhang/SynthesizePipeline-server:/work', '-w', '/work', '-v', '/data/jialinzhang/synthetic_benchmark/tabddpm/code:/workspace/tabddpm/code', 'benchmark:tabddpm-zjl', 'python', '/work/output-Benchmark-trainonly-v1/c16/tabddpm/tabddpm-c16-20260510_215505/_tabddpm_train.py']' returned non-zero exit status 1.",
+  "artifacts": {},
+  "timings": {
+    "train": {
+      "started_at": "2026-05-10T21:55:05",
+      "ended_at": "2026-05-10T21:55:06",
+      "duration_sec": 0.75
+    },
+    "generate": {
+      "started_at": null,
+      "ended_at": null,
+      "duration_sec": null
+    }
+  }
+}

syntheticFail/c16/tabddpm/tabddpm-c16-20260510_215505/staged/public/staged_features.json

@@ -0,0 +1,67 @@
+[
+  {
+    "feature_name": "page_id",
+    "data_type": "continuous",
+    "is_target": false
+  },
+  {
+    "feature_name": "name",
+    "data_type": "ID",
+    "is_target": false
+  },
+  {
+    "feature_name": "urlslug",
+    "data_type": "ID",
+    "is_target": false
+  },
+  {
+    "feature_name": "ID",
+    "data_type": "categorical",
+    "is_target": false
+  },
+  {
+    "feature_name": "ALIGN",
+    "data_type": "categorical",
+    "is_target": false
+  },
+  {
+    "feature_name": "EYE",
+    "data_type": "categorical",
+    "is_target": true
+  },
+  {
+    "feature_name": "HAIR",
+    "data_type": "categorical",
+    "is_target": false
+  },
+  {
+    "feature_name": "SEX",
+    "data_type": "categorical",
+    "is_target": false
+  },
+  {
+    "feature_name": "GSM",
+    "data_type": "categorical",
+    "is_target": false
+  },
+  {
+    "feature_name": "ALIVE",
+    "data_type": "categorical",
+    "is_target": false
+  },
+  {
+    "feature_name": "APPEARANCES",
+    "data_type": "continuous",
+    "is_target": false
+  },
+  {
+    "feature_name": "FIRST APPEARANCE",
+    "data_type": "timestamp",
+    "is_target": false
+  },
+  {
+    "feature_name": "YEAR",
+    "data_type": "continuous",
+    "is_target": false
+  }
+]

syntheticFail/c16/tabddpm/tabddpm-c16-20260510_215505/staged/public/test.csv

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

syntheticFail/c16/tabddpm/tabddpm-c16-20260510_215505/staged/public/train.csv

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

syntheticFail/c16/tabddpm/tabddpm-c16-20260510_215505/staged/public/val.csv

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

syntheticFail/c16/tabddpm/tabddpm-c16-20260510_215505/staged/tabddpm/adapter_report.json

@@ -0,0 +1,7 @@
+{
+  "adapter_ready_status": "pass",
+  "adapter_fail_reason_code": null,
+  "adapter_fail_detail": null,
+  "adapter_transforms_applied": [],
+  "model_input_manifest": "/data/jialinzhang/SynthesizePipeline-server/output-Benchmark-trainonly-v1/c16/tabddpm/tabddpm-c16-20260510_215505/staged/tabddpm/model_input_manifest.json"
+}

syntheticFail/c16/tabddpm/tabddpm-c16-20260510_215505/staged/tabddpm/adapter_transforms_applied.json

@@ -0,0 +1 @@
+[]

syntheticFail/c16/tabddpm/tabddpm-c16-20260510_215505/staged/tabddpm/model_input_manifest.json

@@ -0,0 +1,277 @@
+{
+  "dataset_id": "c16",
+  "model": "tabddpm",
+  "target_column": "EYE",
+  "task_type": "classification",
+  "column_schema": [
+    {
+      "name": "page_id",
+      "role": "feature",
+      "semantic_type": "numeric",
+      "nullable": false,
+      "missing_tokens": [],
+      "parse_format": null,
+      "impute_strategy": "median",
+      "profile_stats": {
+        "missing_rate": 0.0,
+        "unique_count": 5516,
+        "unique_ratio": 1.0,
+        "example_values": [
+          "1941",
+          "127435",
+          "268584",
+          "144619",
+          "132754"
+        ]
+      }
+    },
+    {
+      "name": "name",
+      "role": "id",
+      "semantic_type": "id",
+      "nullable": false,
+      "missing_tokens": [],
+      "parse_format": null,
+      "impute_strategy": "keep_raw",
+      "profile_stats": {
+        "missing_rate": 0.0,
+        "unique_count": 5516,
+        "unique_ratio": 1.0,
+        "example_values": [
+          "Jeremy Tell (New Earth)",
+          "Thomas Jarred (New Earth)",
+          "Kusanagi (New Earth)",
+          "Cecile O'Malley (New Earth)",
+          "Rori Stroh (New Earth)"
+        ]
+      }
+    },
+    {
+      "name": "urlslug",
+      "role": "id",
+      "semantic_type": "id",
+      "nullable": false,
+      "missing_tokens": [],
+      "parse_format": null,
+      "impute_strategy": "keep_raw",
+      "profile_stats": {
+        "missing_rate": 0.0,
+        "unique_count": 5516,
+        "unique_ratio": 1.0,
+        "example_values": [
+          "\\/wiki\\/Jeremy_Tell_(New_Earth)",
+          "\\/wiki\\/Thomas_Jarred_(New_Earth)",
+          "\\/wiki\\/Kusanagi_(New_Earth)",
+          "\\/wiki\\/Cecile_O%27Malley_(New_Earth)",
+          "\\/wiki\\/Rori_Stroh_(New_Earth)"
+        ]
+      }
+    },
+    {
+      "name": "ID",
+      "role": "feature",
+      "semantic_type": "text",
+      "nullable": true,
+      "missing_tokens": [],
+      "parse_format": null,
+      "impute_strategy": "keep_raw",
+      "profile_stats": {
+        "missing_rate": 0.292422,
+        "unique_count": 3,
+        "unique_ratio": 0.000769,
+        "example_values": [
+          "Public Identity",
+          "Secret Identity",
+          "Identity Unknown"
+        ]
+      }
+    },
+    {
+      "name": "ALIGN",
+      "role": "feature",
+      "semantic_type": "text",
+      "nullable": true,
+      "missing_tokens": [],
+      "parse_format": null,
+      "impute_strategy": "keep_raw",
+      "profile_stats": {
+        "missing_rate": 0.087563,
+        "unique_count": 4,
+        "unique_ratio": 0.000795,
+        "example_values": [
+          "Bad Characters",
+          "Good Characters",
+          "Neutral Characters",
+          "Reformed Criminals"
+        ]
+      }
+    },
+    {
+      "name": "EYE",
+      "role": "target",
+      "semantic_type": "text",
+      "nullable": true,
+      "missing_tokens": [],
+      "parse_format": null,
+      "impute_strategy": "keep_raw",
+      "profile_stats": {
+        "missing_rate": 0.525381,
+        "unique_count": 17,
+        "unique_ratio": 0.006494,
+        "example_values": [
+          "Black Eyes",
+          "Blue Eyes",
+          "Grey Eyes",
+          "Green Eyes",
+          "Brown Eyes"
+        ]
+      }
+    },
+    {
+      "name": "HAIR",
+      "role": "feature",
+      "semantic_type": "text",
+      "nullable": true,
+      "missing_tokens": [],
+      "parse_format": null,
+      "impute_strategy": "keep_raw",
+      "profile_stats": {
+        "missing_rate": 0.3314,
+        "unique_count": 17,
+        "unique_ratio": 0.00461,
+        "example_values": [
+          "Brown Hair",
+          "Grey Hair",
+          "Red Hair",
+          "Black Hair",
+          "White Hair"
+        ]
+      }
+    },
+    {
+      "name": "SEX",
+      "role": "feature",
+      "semantic_type": "text",
+      "nullable": true,
+      "missing_tokens": [],
+      "parse_format": null,
+      "impute_strategy": "keep_raw",
+      "profile_stats": {
+        "missing_rate": 0.018673,
+        "unique_count": 4,
+        "unique_ratio": 0.000739,
+        "example_values": [
+          "Male Characters",
+          "Female Characters",
+          "Genderless Characters",
+          "Transgender Characters"
+        ]
+      }
+    },
+    {
+      "name": "GSM",
+      "role": "feature",
+      "semantic_type": "text",
+      "nullable": true,
+      "missing_tokens": [],
+      "parse_format": null,
+      "impute_strategy": "keep_raw",
+      "profile_stats": {
+        "missing_rate": 0.990392,
+        "unique_count": 2,
+        "unique_ratio": 0.037736,
+        "example_values": [
+          "Homosexual Characters",
+          "Bisexual Characters"
+        ]
+      }
+    },
+    {
+      "name": "ALIVE",
+      "role": "feature",
+      "semantic_type": "text",
+      "nullable": true,
+      "missing_tokens": [],
+      "parse_format": null,
+      "impute_strategy": "keep_raw",
+      "profile_stats": {
+        "missing_rate": 0.000544,
+        "unique_count": 2,
+        "unique_ratio": 0.000363,
+        "example_values": [
+          "Living Characters",
+          "Deceased Characters"
+        ]
+      }
+    },
+    {
+      "name": "APPEARANCES",
+      "role": "feature",
+      "semantic_type": "numeric",
+      "nullable": true,
+      "missing_tokens": [],
+      "parse_format": null,
+      "impute_strategy": "median",
+      "profile_stats": {
+        "missing_rate": 0.051305,
+        "unique_count": 263,
+        "unique_ratio": 0.050258,
+        "example_values": [
+          "14",
+          "3",
+          "4",
+          "7",
+          "1"
+        ]
+      }
+    },
+    {
+      "name": "FIRST APPEARANCE",
+      "role": "feature",
+      "semantic_type": "datetime",
+      "nullable": true,
+      "missing_tokens": [],
+      "parse_format": "%Y-%m-%d",
+      "impute_strategy": "keep_raw",
+      "profile_stats": {
+        "missing_rate": 0.009608,
+        "unique_count": 758,
+        "unique_ratio": 0.138752,
+        "example_values": [
+          "2001, August",
+          "1990, February",
+          "2008, July",
+          "1984, April",
+          "1961, December"
+        ]
+      }
+    },
+    {
+      "name": "YEAR",
+      "role": "feature",
+      "semantic_type": "numeric",
+      "nullable": true,
+      "missing_tokens": [],
+      "parse_format": null,
+      "impute_strategy": "median",
+      "profile_stats": {
+        "missing_rate": 0.009608,
+        "unique_count": 79,
+        "unique_ratio": 0.014461,
+        "example_values": [
+          "2001",
+          "1990",
+          "2008",
+          "1984",
+          "1961"
+        ]
+      }
+    }
+  ],
+  "public_manifest": "/data/jialinzhang/SynthesizePipeline-server/output-Benchmark-trainonly-v1/c16/tabddpm/tabddpm-c16-20260510_215505/public_gate/staged_input_manifest.json",
+  "train_csv": "/data/jialinzhang/SynthesizePipeline-server/output-Benchmark-trainonly-v1/c16/tabddpm/tabddpm-c16-20260510_215505/staged/public/train.csv",
+  "val_csv": "/data/jialinzhang/SynthesizePipeline-server/output-Benchmark-trainonly-v1/c16/tabddpm/tabddpm-c16-20260510_215505/staged/public/val.csv",
+  "test_csv": "/data/jialinzhang/SynthesizePipeline-server/output-Benchmark-trainonly-v1/c16/tabddpm/tabddpm-c16-20260510_215505/staged/public/test.csv",
+  "features_json": "/data/jialinzhang/SynthesizePipeline-server/output-Benchmark-trainonly-v1/c16/tabddpm/tabddpm-c16-20260510_215505/staged/public/staged_features.json",
+  "public_gate_report": "/data/jialinzhang/SynthesizePipeline-server/output-Benchmark-trainonly-v1/c16/tabddpm/tabddpm-c16-20260510_215505/public_gate/public_gate_report.json"
+}

syntheticFail/c16/tabddpm/tabddpm-c16-20260510_215505/train_20260510_215505.log

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

syntheticFail/c16/tabddpm/tabddpm-c16-20260510_223930/_tabddpm_runtime/.gitignore

@@ -0,0 +1,22 @@
+.DS_Store
+__pycache__/
+catboost_info/
+**/**.pt
+**/**.ipynb
+!agg_results.ipynb
+**/**.npy
+**/**.gz
+**/**.sh
+**/**.obj
+**/**.png
+**/**.tar
+**/**.code-workspace
+**/**.csv
+exp/**/**/results_catboost.json
+exp/**/**/results_mlp.json
+
+configs/
+data/
+junk/
+RF/
+exps/

syntheticFail/c16/tabddpm/tabddpm-c16-20260510_223930/_tabddpm_runtime/.gitmodules

@@ -0,0 +1,9 @@
+[submodule "ctgan"]
+	# path = CTGAN/CTGAN
+	url = https://github.com/sdv-dev/CTGAN
+[submodule "ctabgan"]
+	# path = CTAB-GAN
+	url = https://github.com/Team-TUD/CTAB-GAN
+[submodule "ctabgan+"]
+	# path = CTAB-GAN-Plus
+	url = https://github.com/Team-TUD/CTAB-GAN-Plus

syntheticFail/c16/tabddpm/tabddpm-c16-20260510_223930/_tabddpm_runtime/CONFIG_DESCRIPTION.md

@@ -0,0 +1,78 @@
+# Description of .toml config for TabDDPM
+First of all, `train.T` and `eval.T` denote preprocessing for training and for evaluation, respectively.  
+
+Here we list non-obvious parameters.  
+
+Main part:
+- `seed = 0` -- evaluation seed (and training, but for training it is fixed to 0)
+- `parent_dir = "exp/abalone/check"` -- exp folder
+- `real_data_path = "data/abalone/"`
+- `model_type = "mlp"` -- model type that approximates the reverse process
+- `num_numerical_features ` -- a number of numerical features in dataset
+- `device = "cuda:0"`
+
+Model params:
+- `is_y_cond` -- false for regression, true for classification
+- `d_in` -- input dimension (not necessary, since scripts calculate it automatically)
+- `num_calsses` -- zero for regression, a number of classes for classification
+- `rtdl_params` -- MLP parameters
+
+```toml
+seed = 0
+parent_dir = "exp/abalone/check"
+real_data_path = "data/abalone/"
+model_type = "mlp"
+num_numerical_features = 7
+device = "cuda:0"
+
+[model_params]
+is_y_cond = false
+d_in = 11
+num_classes = 0
+
+[model_params.rtdl_params]
+d_layers = [
+    256,
+    256,
+]
+dropout = 0.0
+
+[diffusion_params]
+num_timesteps = 1000
+gaussian_loss_type = "mse"
+scheduler = "cosine"
+
+[train.main]
+steps = 1000
+lr = 0.001
+weight_decay = 1e-05
+batch_size = 4096
+
+[train.T]
+seed = 0
+normalization = "quantile"
+num_nan_policy = "__none__"
+cat_nan_policy = "__none__"
+cat_min_frequency = "__none__"
+cat_encoding = "__none__"
+y_policy = "default"
+
+[sample]
+num_samples = 20800
+batch_size = 10000
+seed = 0
+
+[eval.type]
+eval_model = "catboost"
+eval_type = "synthetic"
+
+[eval.T]
+seed = 0
+normalization = "__none__"
+num_nan_policy = "__none__"
+cat_nan_policy = "__none__"
+cat_min_frequency = "__none__"
+cat_encoding = "__none__"
+y_policy = "default"
+
+```

syntheticFail/c16/tabddpm/tabddpm-c16-20260510_223930/_tabddpm_runtime/CTAB-GAN-Plus/.gitignore

@@ -0,0 +1 @@
+**/**.csv

syntheticFail/c16/tabddpm/tabddpm-c16-20260510_223930/_tabddpm_runtime/CTAB-GAN-Plus/README.md

@@ -0,0 +1,49 @@
+# CTAB-GAN+
+This is the official git paper [CTAB-GAN+: Enhancing Tabular Data Synthesis](https://arxiv.org/abs/2204.00401). Current code is without differential privacy part.
+If you have any question, please contact `z.zhao-8@tudelft.nl` for more information.
+
+
+## Prerequisite
+
+The required package version
+```
+numpy==1.21.0
+torch==1.9.1
+pandas==1.2.4
+sklearn==0.24.1
+dython==0.6.4.post1
+scipy==1.4.1
+```
+The sklean package in newer version has updated its function for `sklearn.mixture.BayesianGaussianMixture`. Therefore, user should use this proposed sklearn version to successfully run the code!
+
+## Example
+`Experiment_Script_Adult.ipynb`  `Experiment_Script_king.ipynb` are two example notebooks for training CTAB-GAN+ with Adult (classification) and king (regression) datasets. The datasets are alread under `Real_Datasets` folder.
+The evaluation code is also provided.
+
+## Problem type
+
+You can either indicate your dataset problem type as Classification, Regression. If there is no problem type, you can leave the problem type as None as follows:
+```
+problem_type= {None: None}
+```
+
+## For large dataset
+
+If your dataset has large number of column, you may encounter the problem that our currnet code cannot encode all of your data since CTAB-GAN+ will wrap the encoded data into an image-like format. What you can do is changing the line 378 and 385 in `model/synthesizer/ctabgan_synthesizer.py`. The number in the `slide` list
+```
+sides = [4, 8, 16, 24, 32]
+```
+is the side size of image. You can enlarge the list to [4, 8, 16, 24, 32, 64] or [4, 8, 16, 24, 32, 64, 128] for accepting larger dataset.
+
+## Bibtex
+
+To cite this paper, you could use this bibtex
+
+```
+@article{zhao2022ctab,
+  title={CTAB-GAN+: Enhancing Tabular Data Synthesis},
+  author={Zhao, Zilong and Kunar, Aditya and Birke, Robert and Chen, Lydia Y},
+  journal={arXiv preprint arXiv:2204.00401},
+  year={2022}
+}
+```

syntheticFail/c16/tabddpm/tabddpm-c16-20260510_223930/_tabddpm_runtime/CTAB-GAN-Plus/columns.json

@@ -0,0 +1,119 @@
+{
+    "churn2": {
+        "categorical_columns": ["7", "8", "9", "10", "y"],
+        "mixed_columns": {"0": [850.0], "3": [0.0]},
+        "integer_columns": ["2", "4"],
+        "general_columns": ["1", "5", "6"],
+        "problem_type": {"Classification": "y"}
+    },
+    "adult": {
+        "categorical_columns": ["6", "7", "8", "9", "10", "11", "12", "13", "y"],
+        "mixed_columns": {"3": [0.0], "4": [0.0]},
+        "integer_columns": ["0", "1", "2", "5"],
+        "general_columns": ["0", "1", "7"],
+        "problem_type": {"Classification": "y"}
+    },
+    "california": {
+        "categorical_columns": [],
+        "mixed_columns": {"1": [52.0]},
+        "integer_columns": ["4"],
+        "general_columns": ["0"],
+        "problem_type": {"Regression": "y"}
+    },
+    "default": {
+        "categorical_columns": ["20", "21", "22", "y"],
+        "mixed_columns": {},
+        "general_columns": [],
+        "integer_columns": ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19"],
+        "problem_type": {"Classification": "y"}
+    },
+    "buddy": {
+        "categorical_columns": ["4", "5", "6", "7", "8", "y"],
+        "mixed_columns": {},
+        "integer_columns": ["0", "1"],
+        "general_columns": ["1", "3", "5"],
+        "problem_type": {"Classification": "y"}
+    },
+    "gesture": {
+        "categorical_columns": ["y"],
+        "mixed_columns": {},
+        "integer_columns": [],
+        "general_columns": ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "20", "21", "22", "23"],
+        "problem_type": {"Classification": "y"}
+    },
+    "wilt": {
+        "categorical_columns": ["y"],
+        "mixed_columns": {},
+        "integer_columns": [],
+        "general_columns": ["0", "3"],
+        "problem_type": {"Classification": "y"}
+    },
+    "satellite": {
+        "categorical_columns": ["y"],
+        "mixed_columns": {},
+        "integer_columns": [],
+        "problem_type": {"Classification": "y"}
+    },
+    "higgs-small": {
+        "categorical_columns": ["y"],
+        "mixed_columns": {},
+        "integer_columns": [],
+        "general_columns": ["1", "2", "4", "6", "10", "11", "14", "15", "18","19"],
+        "problem_type": {"Classification": "y"}
+    },
+    "diabetes": {
+        "categorical_columns": ["y"],
+        "mixed_columns": {"3": [0.0], "4": [0.0]},
+        "general_columns": [],
+        "integer_columns": ["0", "1", "2", "5", "7"],
+        "problem_type": {"Classification": "y"}
+    },
+    "abalone": {
+        "categorical_columns": ["7"],
+        "mixed_columns": {},
+        "integer_columns": ["y"],
+        "general_columns": [],
+        "problem_type": {"Regression": "y"}
+    },
+    "insurance": {
+        "categorical_columns": ["3", "4", "5"],
+        "mixed_columns": {},
+        "general_columns": [],
+        "integer_columns": ["0", "2"],
+        "problem_type": {"Regression": "y"}
+    },
+    "king": {
+        "categorical_columns": ["17", "18", "19"],
+        "mixed_columns": {"9": [0.0], "11":[0.0]},
+        "general_columns": ["2", "6", "7"],
+        "integer_columns": ["0", "2", "5", "7", "8", "9", "12"],
+        "problem_type": {"Regression": "y"}
+    },
+    "cardio": {
+        "categorical_columns": ["5", "6", "7", "8", "9", "10", "y"],
+        "mixed_columns": {},
+        "integer_columns": ["0", "1", "3", "4"],
+        "problem_type": {"Classification": "y"}
+    },
+    "house": {
+        "categorical_columns": [],
+        "mixed_columns": {"2": [0.0], "6": [0.0], "8": [0.0], "11": [0.0], "12": [1.0], "14": [0.0]},
+        "general_columns": ["1", "7"],
+        "integer_columns": ["0"],
+        "problem_type": {"Regression": "y"}
+    },
+    "miniboone": {
+        "categorical_columns": ["y"],
+        "mixed_columns": {},
+        "integer_columns": [],
+        "general_columns": ["8", "9", "10", "19", "20", "21", "28", "29", "35", "39", "45", "49"],
+        "problem_type": {"Classification": "y"}
+    },
+    "fb-comments": {
+        "categorical_columns": ["36", "37", "38", "39", "40", "41", "42", "43", "44", "45", "46", "47", "48", "49", "50"],
+        "mixed_columns": {"1": [0.0], "8": [0.0], "10": [0.0]},
+        "general_columns": ["26", "36"],
+        "integer_columns": [],
+        "problem_type": {"Regression": "y"}
+    }
+}

syntheticFail/c16/tabddpm/tabddpm-c16-20260510_223930/_tabddpm_runtime/CTAB-GAN-Plus/model copy/ctabgan.py

@@ -0,0 +1,70 @@
+"""
+Generative model training algorithm based on the CTABGANSynthesiser
+
+"""
+import pandas as pd
+import time
+from model.pipeline.data_preparation import DataPrep
+from model.synthesizer.ctabgan_synthesizer import CTABGANSynthesizer
+
+import warnings
+
+warnings.filterwarnings("ignore")
+
+class CTABGAN():
+
+    def __init__(self,
+                 df,
+                 test_ratio = 0.20,
+                 categorical_columns = [ 'workclass', 'education', 'marital-status', 'occupation', 'relationship', 'race', 'gender', 'native-country', 'income'], 
+                 log_columns = [],
+                 mixed_columns= {'capital-loss':[0.0],'capital-gain':[0.0]},
+                 general_columns = ["age"],
+                 non_categorical_columns = [],
+                 integer_columns = ['age', 'fnlwgt','capital-gain', 'capital-loss','hours-per-week'],
+                 problem_type= {"Classification": "income"},
+                 class_dim=(256, 256, 256, 256),
+                 random_dim=100,
+                 num_channels=64,
+                 l2scale=1e-5,
+                 batch_size=500,
+                 epochs=150,
+                 device="cpu"):
+
+        self.__name__ = 'CTABGAN'
+              
+        self.synthesizer = CTABGANSynthesizer(
+                class_dim=class_dim,
+                random_dim=random_dim,
+                num_channels=num_channels,
+                l2scale=l2scale,
+                batch_size=batch_size,
+                epochs=epochs,
+                device=device
+        )
+        self.raw_df = df
+        self.test_ratio = test_ratio
+        self.categorical_columns = categorical_columns
+        self.log_columns = log_columns
+        self.mixed_columns = mixed_columns
+        self.general_columns = general_columns
+        self.non_categorical_columns = non_categorical_columns
+        self.integer_columns = integer_columns
+        self.problem_type = problem_type
+                
+    def fit(self):
+        
+        start_time = time.time()
+        self.data_prep = DataPrep(self.raw_df,self.categorical_columns,self.log_columns,self.mixed_columns,self.general_columns,self.non_categorical_columns,self.integer_columns,self.problem_type,self.test_ratio)
+        self.synthesizer.fit(train_data=self.data_prep.df, categorical = self.data_prep.column_types["categorical"], mixed = self.data_prep.column_types["mixed"],
+        general = self.data_prep.column_types["general"], non_categorical = self.data_prep.column_types["non_categorical"], type=self.problem_type)
+        end_time = time.time()
+        print('Finished training in',end_time-start_time," seconds.")
+
+
+    def generate_samples(self, seed=0):
+        
+        sample = self.synthesizer.sample(len(self.raw_df), seed) 
+        sample_df = self.data_prep.inverse_prep(sample)
+        
+        return sample_df

syntheticFail/c16/tabddpm/tabddpm-c16-20260510_223930/_tabddpm_runtime/CTAB-GAN-Plus/model copy/eval/evaluation.py

@@ -0,0 +1,193 @@
+import numpy as np
+import pandas as pd 
+from sklearn import metrics
+from sklearn import model_selection
+from sklearn.preprocessing import MinMaxScaler,StandardScaler
+from sklearn.neural_network import MLPClassifier
+from sklearn.linear_model import LogisticRegression
+from sklearn import svm,tree
+from sklearn.ensemble import RandomForestClassifier
+from dython.nominal import compute_associations
+from scipy.stats import wasserstein_distance
+from scipy.spatial import distance
+import warnings
+
+warnings.filterwarnings("ignore")
+
+def supervised_model_training(x_train, y_train, x_test, 
+                              y_test, model_name):
+  
+     
+  if model_name == 'lr':
+    model  = LogisticRegression(random_state=42,max_iter=500) 
+  elif model_name == 'svm':
+    model  = svm.SVC(random_state=42,probability=True)
+  elif model_name == 'dt':
+    model  = tree.DecisionTreeClassifier(random_state=42)
+  elif model_name == 'rf':      
+    model = RandomForestClassifier(random_state=42)
+  elif model_name == "mlp":
+    model = MLPClassifier(random_state=42,max_iter=100)
+  
+  model.fit(x_train, y_train)
+  pred = model.predict(x_test)
+
+  if len(np.unique(y_train))>2:
+    predict = model.predict_proba(x_test)        
+    acc = metrics.accuracy_score(y_test,pred)*100
+    auc = metrics.roc_auc_score(y_test, predict,average="weighted",multi_class="ovr")
+    f1_score = metrics.precision_recall_fscore_support(y_test, pred,average="weighted")[2]
+    return [acc, auc,f1_score] 
+
+  else:
+    predict = model.predict_proba(x_test)[:,1]    
+    acc = metrics.accuracy_score(y_test,pred)*100
+    auc = metrics.roc_auc_score(y_test, predict)
+    f1_score = metrics.precision_recall_fscore_support(y_test,pred)[2].mean()
+    return [acc, auc,f1_score] 
+
+
+def get_utility_metrics(real_path,fake_paths,scaler="MinMax",classifiers=["lr","dt","rf","mlp"],test_ratio=.20):
+
+    data_real = pd.read_csv(real_path).to_numpy()
+    data_dim = data_real.shape[1]
+
+    data_real_y = data_real[:,-1]
+    data_real_X = data_real[:,:data_dim-1]
+    X_train_real, X_test_real, y_train_real, y_test_real = model_selection.train_test_split(data_real_X ,data_real_y, test_size=test_ratio, stratify=data_real_y,random_state=42) 
+
+    if scaler=="MinMax":
+        scaler_real = MinMaxScaler()
+    else:
+        scaler_real = StandardScaler()
+        
+    scaler_real.fit(data_real_X)
+    X_train_real_scaled = scaler_real.transform(X_train_real)
+    X_test_real_scaled = scaler_real.transform(X_test_real)
+
+    all_real_results = []
+    for classifier in classifiers:
+      real_results = supervised_model_training(X_train_real_scaled,y_train_real,X_test_real_scaled,y_test_real,classifier)
+      all_real_results.append(real_results)
+      
+    all_fake_results_avg = []
+    
+    for fake_path in fake_paths:
+      data_fake  = pd.read_csv(fake_path).to_numpy()
+      data_fake_y = data_fake[:,-1]
+      data_fake_X = data_fake[:,:data_dim-1]
+      X_train_fake, _ , y_train_fake, _ = model_selection.train_test_split(data_fake_X ,data_fake_y, test_size=test_ratio, stratify=data_fake_y,random_state=42) 
+
+      if scaler=="MinMax":
+        scaler_fake = MinMaxScaler()
+      else:
+        scaler_fake = StandardScaler()
+      
+      scaler_fake.fit(data_fake_X)
+      
+      X_train_fake_scaled = scaler_fake.transform(X_train_fake)
+      
+      all_fake_results = []
+      for classifier in classifiers:
+        fake_results = supervised_model_training(X_train_fake_scaled,y_train_fake,X_test_real_scaled,y_test_real,classifier)
+        all_fake_results.append(fake_results)
+
+      all_fake_results_avg.append(all_fake_results)
+    
+    diff_results = np.array(all_real_results)- np.array(all_fake_results_avg).mean(axis=0)
+
+    return diff_results
+
+def stat_sim(real_path,fake_path,cat_cols=None):
+    
+    Stat_dict={}
+    
+    real = pd.read_csv(real_path)
+    fake = pd.read_csv(fake_path)
+
+    really = real.copy()
+    fakey = fake.copy()
+
+    real_corr = compute_associations(real, nominal_columns=cat_cols)
+
+    fake_corr = compute_associations(fake, nominal_columns=cat_cols)
+
+    corr_dist = np.linalg.norm(real_corr - fake_corr)
+    
+    cat_stat = []
+    num_stat = []
+    
+    for column in real.columns:
+        
+        if column in cat_cols:
+
+            real_pdf=(really[column].value_counts()/really[column].value_counts().sum())
+            fake_pdf=(fakey[column].value_counts()/fakey[column].value_counts().sum())
+            categories = (fakey[column].value_counts()/fakey[column].value_counts().sum()).keys().tolist()
+            sorted_categories = sorted(categories)
+            
+            real_pdf_values = [] 
+            fake_pdf_values = []
+
+            for i in sorted_categories:
+                real_pdf_values.append(real_pdf[i])
+                fake_pdf_values.append(fake_pdf[i])
+            
+            if len(real_pdf)!=len(fake_pdf):
+                zero_cats = set(really[column].value_counts().keys())-set(fakey[column].value_counts().keys())
+                for z in zero_cats:
+                    real_pdf_values.append(real_pdf[z])
+                    fake_pdf_values.append(0)
+            Stat_dict[column]=(distance.jensenshannon(real_pdf_values,fake_pdf_values, 2.0))
+            cat_stat.append(Stat_dict[column])        
+        else:
+            scaler = MinMaxScaler()
+            scaler.fit(real[column].values.reshape(-1,1))
+            l1 = scaler.transform(real[column].values.reshape(-1,1)).flatten()
+            l2 = scaler.transform(fake[column].values.reshape(-1,1)).flatten()
+            Stat_dict[column]= (wasserstein_distance(l1,l2))
+            num_stat.append(Stat_dict[column])
+
+    return [np.mean(num_stat),np.mean(cat_stat),corr_dist]
+
+def privacy_metrics(real_path,fake_path,data_percent=15):
+    
+    real = pd.read_csv(real_path).drop_duplicates(keep=False)
+    fake = pd.read_csv(fake_path).drop_duplicates(keep=False)
+
+    real_refined = real.sample(n=int(len(real)*(.01*data_percent)), random_state=42).to_numpy()
+    fake_refined = fake.sample(n=int(len(fake)*(.01*data_percent)), random_state=42).to_numpy()
+
+    scalerR = StandardScaler()
+    scalerR.fit(real_refined)
+    scalerF = StandardScaler()
+    scalerF.fit(fake_refined)
+    df_real_scaled = scalerR.transform(real_refined)
+    df_fake_scaled = scalerF.transform(fake_refined)
+    
+    dist_rf = metrics.pairwise_distances(df_real_scaled, Y=df_fake_scaled, metric='minkowski', n_jobs=-1)
+    dist_rr = metrics.pairwise_distances(df_real_scaled, Y=None, metric='minkowski', n_jobs=-1)
+    rd_dist_rr = dist_rr[~np.eye(dist_rr.shape[0],dtype=bool)].reshape(dist_rr.shape[0],-1)
+    dist_ff = metrics.pairwise_distances(df_fake_scaled, Y=None, metric='minkowski', n_jobs=-1)
+    rd_dist_ff = dist_ff[~np.eye(dist_ff.shape[0],dtype=bool)].reshape(dist_ff.shape[0],-1) 
+    smallest_two_indexes_rf = [dist_rf[i].argsort()[:2] for i in range(len(dist_rf))]
+    smallest_two_rf = [dist_rf[i][smallest_two_indexes_rf[i]] for i in range(len(dist_rf))]       
+    smallest_two_indexes_rr = [rd_dist_rr[i].argsort()[:2] for i in range(len(rd_dist_rr))]
+    smallest_two_rr = [rd_dist_rr[i][smallest_two_indexes_rr[i]] for i in range(len(rd_dist_rr))]
+    smallest_two_indexes_ff = [rd_dist_ff[i].argsort()[:2] for i in range(len(rd_dist_ff))]
+    smallest_two_ff = [rd_dist_ff[i][smallest_two_indexes_ff[i]] for i in range(len(rd_dist_ff))]
+    nn_ratio_rr = np.array([i[0]/i[1] for i in smallest_two_rr])
+    nn_ratio_ff = np.array([i[0]/i[1] for i in smallest_two_ff])
+    nn_ratio_rf = np.array([i[0]/i[1] for i in smallest_two_rf])
+    nn_fifth_perc_rr = np.percentile(nn_ratio_rr,5)
+    nn_fifth_perc_ff = np.percentile(nn_ratio_ff,5)
+    nn_fifth_perc_rf = np.percentile(nn_ratio_rf,5)
+
+    min_dist_rf = np.array([i[0] for i in smallest_two_rf])
+    fifth_perc_rf = np.percentile(min_dist_rf,5)
+    min_dist_rr = np.array([i[0] for i in smallest_two_rr])
+    fifth_perc_rr = np.percentile(min_dist_rr,5)
+    min_dist_ff = np.array([i[0] for i in smallest_two_ff])
+    fifth_perc_ff = np.percentile(min_dist_ff,5)
+    
+    return np.array([fifth_perc_rf,fifth_perc_rr,fifth_perc_ff,nn_fifth_perc_rf,nn_fifth_perc_rr,nn_fifth_perc_ff]).reshape(1,6)    

syntheticFail/c16/tabddpm/tabddpm-c16-20260510_223930/_tabddpm_runtime/CTAB-GAN-Plus/model copy/pipeline/data_preparation.py

@@ -0,0 +1,130 @@
+import numpy as np
+import pandas as pd
+from sklearn import preprocessing
+from sklearn import model_selection
+
+class DataPrep(object):
+  
+    def __init__(self, raw_df: pd.DataFrame, categorical: list, log:list, mixed:dict, general:list, non_categorical:list, integer:list, type:dict, test_ratio:float):
+        
+        
+        self.categorical_columns = categorical
+        self.log_columns = log
+        self.mixed_columns = mixed
+        self.general_columns = general
+        self.non_categorical_columns = non_categorical
+        self.integer_columns = integer
+        self.column_types = dict()
+        self.column_types["categorical"] = []
+        self.column_types["mixed"] = {}
+        self.column_types["general"] = []
+        self.column_types["non_categorical"] = []
+        self.lower_bounds = {}
+        self.label_encoder_list = []
+        
+        target_col = list(type.values())[0]
+        if target_col is not None:
+            y_real = raw_df[target_col]
+            X_real = raw_df.drop(columns=[target_col])
+            X_train_real, _, y_train_real, _ = model_selection.train_test_split(X_real ,y_real, test_size=test_ratio, stratify=y_real,random_state=42)
+        
+            X_train_real[target_col]= y_train_real
+
+            self.df = X_train_real
+        else:
+            self.df = raw_df
+
+        self.df = self.df.replace(r' ', np.nan)
+        self.df = self.df.fillna('empty')
+       
+        all_columns= set(self.df.columns)
+        irrelevant_missing_columns = set(self.categorical_columns)
+        relevant_missing_columns = list(all_columns - irrelevant_missing_columns)
+        
+        for i in relevant_missing_columns:
+            if i in self.log_columns:
+                if "empty" in list(self.df[i].values):
+                    self.df[i] = self.df[i].apply(lambda x: -9999999 if x=="empty" else x)
+                    self.mixed_columns[i] = [-9999999]
+            elif i in list(self.mixed_columns.keys()):
+                if "empty" in list(self.df[i].values):
+                    self.df[i] = self.df[i].apply(lambda x: -9999999 if x=="empty" else x )
+                    self.mixed_columns[i].append(-9999999)
+            else:
+                if "empty" in list(self.df[i].values):   
+                    self.df[i] = self.df[i].apply(lambda x: -9999999 if x=="empty" else x)
+                    self.mixed_columns[i] = [-9999999]
+        
+        if self.log_columns:
+            for log_column in self.log_columns:
+                valid_indices = []
+                for idx,val in enumerate(self.df[log_column].values):
+                    if val!=-9999999:
+                        valid_indices.append(idx)
+                eps = 1
+                lower = np.min(self.df[log_column].iloc[valid_indices].values)
+                self.lower_bounds[log_column] = lower
+                if lower>0: 
+                    self.df[log_column] = self.df[log_column].apply(lambda x: np.log(x) if x!=-9999999 else -9999999)
+                elif lower == 0:
+                    self.df[log_column] = self.df[log_column].apply(lambda x: np.log(x+eps) if x!=-9999999 else -9999999) 
+                else:
+                    self.df[log_column] = self.df[log_column].apply(lambda x: np.log(x-lower+eps) if x!=-9999999 else -9999999)
+
+        for column_index, column in enumerate(self.df.columns):            
+            if column in self.categorical_columns:        
+                label_encoder = preprocessing.LabelEncoder()
+                self.df[column] = self.df[column].astype(str)
+                label_encoder.fit(self.df[column])
+                current_label_encoder = dict()
+                current_label_encoder['column'] = column
+                current_label_encoder['label_encoder'] = label_encoder
+                transformed_column = label_encoder.transform(self.df[column])
+                self.df[column] = transformed_column
+                self.label_encoder_list.append(current_label_encoder)
+                self.column_types["categorical"].append(column_index)
+
+                if column in self.general_columns:
+                    self.column_types["general"].append(column_index)
+            
+                if column in self.non_categorical_columns:
+                    self.column_types["non_categorical"].append(column_index)
+            
+            elif column in self.mixed_columns:
+                self.column_types["mixed"][column_index] = self.mixed_columns[column]
+            
+            elif column in self.general_columns:
+                self.column_types["general"].append(column_index)
+            
+
+        super().__init__()
+        
+    def inverse_prep(self, data, eps=1):
+        
+        df_sample = pd.DataFrame(data,columns=self.df.columns)
+     
+        for i in range(len(self.label_encoder_list)):
+            le = self.label_encoder_list[i]["label_encoder"]
+            df_sample[self.label_encoder_list[i]["column"]] = df_sample[self.label_encoder_list[i]["column"]].astype(int)
+            df_sample[self.label_encoder_list[i]["column"]] = le.inverse_transform(df_sample[self.label_encoder_list[i]["column"]])
+
+        if self.log_columns:
+            for i in df_sample:
+                if i in self.log_columns:
+                    lower_bound = self.lower_bounds[i]
+                    if lower_bound>0:
+                        df_sample[i].apply(lambda x: np.exp(x)) 
+                    elif lower_bound==0:
+                        df_sample[i] = df_sample[i].apply(lambda x: np.ceil(np.exp(x)-eps) if (np.exp(x)-eps) < 0 else (np.exp(x)-eps))
+                    else: 
+                        df_sample[i] = df_sample[i].apply(lambda x: np.exp(x)-eps+lower_bound)
+
+        if self.integer_columns:
+            for column in self.integer_columns:
+                df_sample[column]= (np.round(df_sample[column].values))
+                df_sample[column] = df_sample[column].astype(int)
+
+        df_sample.replace(-9999999, np.nan,inplace=True)
+        df_sample.replace('empty', np.nan,inplace=True)
+
+        return df_sample

syntheticFail/c16/tabddpm/tabddpm-c16-20260510_223930/_tabddpm_runtime/CTAB-GAN-Plus/model copy/privacy_utils/rdp_accountant.py

@@ -0,0 +1,280 @@
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import math
+import sys
+
+import numpy as np
+from scipy import special
+import six
+
+########################
+# LOG-SPACE ARITHMETIC #
+########################
+
+
+def _log_add(logx, logy):
+  """Add two numbers in the log space."""
+  a, b = min(logx, logy), max(logx, logy)
+  if a == -np.inf:  # adding 0
+    return b
+  # Use exp(a) + exp(b) = (exp(a - b) + 1) * exp(b)
+  return math.log1p(math.exp(a - b)) + b  # log1p(x) = log(x + 1)
+
+
+def _log_sub(logx, logy):
+  """Subtract two numbers in the log space. Answer must be non-negative."""
+  if logx < logy:
+    raise ValueError("The result of subtraction must be non-negative.")
+  if logy == -np.inf:  # subtracting 0
+    return logx
+  if logx == logy:
+    return -np.inf  # 0 is represented as -np.inf in the log space.
+
+  try:
+    # Use exp(x) - exp(y) = (exp(x - y) - 1) * exp(y).
+    return math.log(math.expm1(logx - logy)) + logy  # expm1(x) = exp(x) - 1
+  except OverflowError:
+    return logx
+
+
+def _log_print(logx):
+  """Pretty print."""
+  if logx < math.log(sys.float_info.max):
+    return "{}".format(math.exp(logx))
+  else:
+    return "exp({})".format(logx)
+
+
+def _compute_log_a_int(q, sigma, alpha):
+  """Compute log(A_alpha) for integer alpha. 0 < q < 1."""
+  assert isinstance(alpha, six.integer_types)
+
+  # Initialize with 0 in the log space.
+  log_a = -np.inf
+
+  for i in range(alpha + 1):
+    log_coef_i = (
+        math.log(special.binom(alpha, i)) + i * math.log(q) +
+        (alpha - i) * math.log(1 - q))
+
+    s = log_coef_i + (i * i - i) / (2 * (sigma**2))
+    log_a = _log_add(log_a, s)
+
+  return float(log_a)
+
+
+def _compute_log_a_frac(q, sigma, alpha):
+  """Compute log(A_alpha) for fractional alpha. 0 < q < 1."""
+  # The two parts of A_alpha, integrals over (-inf,z0] and [z0, +inf), are
+  # initialized to 0 in the log space:
+  log_a0, log_a1 = -np.inf, -np.inf
+  i = 0
+
+  z0 = sigma**2 * math.log(1 / q - 1) + .5
+
+  while True:  # do ... until loop
+    coef = special.binom(alpha, i)
+    log_coef = math.log(abs(coef))
+    j = alpha - i
+
+    log_t0 = log_coef + i * math.log(q) + j * math.log(1 - q)
+    log_t1 = log_coef + j * math.log(q) + i * math.log(1 - q)
+
+    log_e0 = math.log(.5) + _log_erfc((i - z0) / (math.sqrt(2) * sigma))
+    log_e1 = math.log(.5) + _log_erfc((z0 - j) / (math.sqrt(2) * sigma))
+
+    log_s0 = log_t0 + (i * i - i) / (2 * (sigma**2)) + log_e0
+    log_s1 = log_t1 + (j * j - j) / (2 * (sigma**2)) + log_e1
+
+    if coef > 0:
+      log_a0 = _log_add(log_a0, log_s0)
+      log_a1 = _log_add(log_a1, log_s1)
+    else:
+      log_a0 = _log_sub(log_a0, log_s0)
+      log_a1 = _log_sub(log_a1, log_s1)
+
+    i += 1
+    if max(log_s0, log_s1) < -30:
+      break
+
+  return _log_add(log_a0, log_a1)
+
+
+def _compute_log_a(q, sigma, alpha):
+  """Compute log(A_alpha) for any positive finite alpha."""
+  if float(alpha).is_integer():
+    return _compute_log_a_int(q, sigma, int(alpha))
+  else:
+    return _compute_log_a_frac(q, sigma, alpha)
+
+
+def _log_erfc(x):
+  """Compute log(erfc(x)) with high accuracy for large x."""
+  try:
+    return math.log(2) + special.log_ndtr(-x * 2**.5)
+  except NameError:
+    # If log_ndtr is not available, approximate as follows:
+    r = special.erfc(x)
+    if r == 0.0:
+      # Using the Laurent series at infinity for the tail of the erfc function:
+      #     erfc(x) ~ exp(-x^2-.5/x^2+.625/x^4)/(x*pi^.5)
+      # To verify in Mathematica:
+      #     Series[Log[Erfc[x]] + Log[x] + Log[Pi]/2 + x^2, {x, Infinity, 6}]
+      return (-math.log(math.pi) / 2 - math.log(x) - x**2 - .5 * x**-2 +
+              .625 * x**-4 - 37. / 24. * x**-6 + 353. / 64. * x**-8)
+    else:
+      return math.log(r)
+
+
+def _compute_delta(orders, rdp, eps):
+  """Compute delta given a list of RDP values and target epsilon.
+
+  Args:
+    orders: An array (or a scalar) of orders.
+    rdp: A list (or a scalar) of RDP guarantees.
+    eps: The target epsilon.
+
+  Returns:
+    Pair of (delta, optimal_order).
+
+  Raises:
+    ValueError: If input is malformed.
+
+  """
+  orders_vec = np.atleast_1d(orders)
+  rdp_vec = np.atleast_1d(rdp)
+
+  if len(orders_vec) != len(rdp_vec):
+    raise ValueError("Input lists must have the same length.")
+
+  deltas = np.exp((rdp_vec - eps) * (orders_vec - 1))
+  idx_opt = np.argmin(deltas)
+  return min(deltas[idx_opt], 1.), orders_vec[idx_opt]
+
+
+def _compute_eps(orders, rdp, delta):
+  """Compute epsilon given a list of RDP values and target delta.
+
+  Args:
+    orders: An array (or a scalar) of orders.
+    rdp: A list (or a scalar) of RDP guarantees.
+    delta: The target delta.
+
+  Returns:
+    Pair of (eps, optimal_order).
+
+  Raises:
+    ValueError: If input is malformed.
+
+  """
+  orders_vec = np.atleast_1d(orders)
+  rdp_vec = np.atleast_1d(rdp)
+
+  if len(orders_vec) != len(rdp_vec):
+    raise ValueError("Input lists must have the same length.")
+
+  eps = rdp_vec - math.log(delta) / (orders_vec - 1)
+
+  idx_opt = np.nanargmin(eps)  # Ignore NaNs
+  return eps[idx_opt], orders_vec[idx_opt]
+
+
+def _compute_rdp(q, sigma, alpha):
+  """Compute RDP of the Sampled Gaussian mechanism at order alpha.
+
+  Args:
+    q: The sampling rate.
+    sigma: The std of the additive Gaussian noise.
+    alpha: The order at which RDP is computed.
+
+  Returns:
+    RDP at alpha, can be np.inf.
+  """
+  if q == 0:
+    return 0
+
+  if q == 1.:
+    return alpha / (2 * sigma**2)
+
+  if np.isinf(alpha):
+    return np.inf
+
+  return _compute_log_a(q, sigma, alpha) / (alpha - 1)
+
+
+def compute_rdp(q, noise_multiplier, steps, orders):
+  """Compute RDP of the Sampled Gaussian Mechanism.
+
+  Args:
+    q: The sampling rate.
+    noise_multiplier: The ratio of the standard deviation of the Gaussian noise
+        to the l2-sensitivity of the function to which it is added.
+    steps: The number of steps.
+    orders: An array (or a scalar) of RDP orders.
+
+  Returns:
+    The RDPs at all orders, can be np.inf.
+  """
+  if np.isscalar(orders):
+    rdp = _compute_rdp(q, noise_multiplier, orders)
+  else:
+    rdp = np.array([_compute_rdp(q, noise_multiplier, order)
+                    for order in orders])
+
+  return rdp * steps
+
+
+def get_privacy_spent(orders, rdp, target_eps=None, target_delta=None):
+  """Compute delta (or eps) for given eps (or delta) from RDP values.
+
+  Args:
+    orders: An array (or a scalar) of RDP orders.
+    rdp: An array of RDP values. Must be of the same length as the orders list.
+    target_eps: If not None, the epsilon for which we compute the corresponding
+              delta.
+    target_delta: If not None, the delta for which we compute the corresponding
+              epsilon. Exactly one of target_eps and target_delta must be None.
+
+  Returns:
+    eps, delta, opt_order.
+
+  Raises:
+    ValueError: If target_eps and target_delta are messed up.
+  """
+  if target_eps is None and target_delta is None:
+    raise ValueError(
+        "Exactly one out of eps and delta must be None. (Both are).")
+
+  if target_eps is not None and target_delta is not None:
+    raise ValueError(
+        "Exactly one out of eps and delta must be None. (None is).")
+
+  if target_eps is not None:
+    delta, opt_order = _compute_delta(orders, rdp, target_eps)
+    return target_eps, delta, opt_order
+  else:
+    eps, opt_order = _compute_eps(orders, rdp, target_delta)
+    return eps, target_delta, opt_order
+
+
+def compute_rdp_from_ledger(ledger, orders):
+  """Compute RDP of Sampled Gaussian Mechanism from ledger.
+
+  Args:
+    ledger: A formatted privacy ledger.
+    orders: An array (or a scalar) of RDP orders.
+
+  Returns:
+    RDP at all orders, can be np.inf.
+  """
+  total_rdp = np.zeros_like(orders, dtype=float)
+  for sample in ledger:
+    # Compute equivalent z from l2_clip_bounds and noise stddevs in sample.
+    # See https://arxiv.org/pdf/1812.06210.pdf for derivation of this formula.
+    effective_z = sum([
+        (q.noise_stddev / q.l2_norm_bound)**-2 for q in sample.queries])**-0.5
+    total_rdp += compute_rdp(
+        sample.selection_probability, effective_z, 1, orders)
+  return total_rdp

syntheticFail/c16/tabddpm/tabddpm-c16-20260510_223930/_tabddpm_runtime/CTAB-GAN-Plus/model copy/synthesizer/ctabgan_synthesizer.py

@@ -0,0 +1,601 @@
+import numpy as np
+import pandas as pd
+import torch
+import torch.utils.data
+import torch.optim as optim
+from torch.optim import Adam
+from torch.nn import functional as F
+from torch.nn import (Dropout, LeakyReLU, Linear, Module, ReLU, Sequential,
+Conv2d, ConvTranspose2d, Sigmoid, init, BCELoss, CrossEntropyLoss,SmoothL1Loss,LayerNorm)
+from model.synthesizer.transformer import ImageTransformer,DataTransformer
+from model.privacy_utils.rdp_accountant import compute_rdp, get_privacy_spent
+from tqdm import tqdm
+
+
+class Classifier(Module):
+    def __init__(self,input_dim, dis_dims,st_ed):
+        super(Classifier,self).__init__()
+        dim = input_dim-(st_ed[1]-st_ed[0])
+        seq = []
+        self.str_end = st_ed
+        for item in list(dis_dims):
+            seq += [
+                Linear(dim, item),
+                LeakyReLU(0.2),
+                Dropout(0.5)
+            ]
+            dim = item
+        
+        if (st_ed[1]-st_ed[0])==1:
+            seq += [Linear(dim, 1)]
+        
+        elif (st_ed[1]-st_ed[0])==2:
+            seq += [Linear(dim, 1),Sigmoid()]
+        else:
+            seq += [Linear(dim,(st_ed[1]-st_ed[0]))] 
+        
+        self.seq = Sequential(*seq)
+
+    def forward(self, input):
+        
+        label=None
+        
+        if (self.str_end[1]-self.str_end[0])==1:
+            label = input[:, self.str_end[0]:self.str_end[1]]
+        else:
+            label = torch.argmax(input[:, self.str_end[0]:self.str_end[1]], axis=-1)
+        
+        new_imp = torch.cat((input[:,:self.str_end[0]],input[:,self.str_end[1]:]),1)
+        
+        if ((self.str_end[1]-self.str_end[0])==2) | ((self.str_end[1]-self.str_end[0])==1):
+            return self.seq(new_imp).view(-1), label
+        else:
+            return self.seq(new_imp), label
+
+def apply_activate(data, output_info):
+    data_t = []
+    st = 0
+    for item in output_info:
+        if item[1] == 'tanh':
+            ed = st + item[0]
+            data_t.append(torch.tanh(data[:, st:ed]))
+            st = ed
+        elif item[1] == 'softmax':
+            ed = st + item[0]
+            data_t.append(F.gumbel_softmax(data[:, st:ed], tau=0.2))
+            st = ed
+    return torch.cat(data_t, dim=1)
+
+def get_st_ed(target_col_index,output_info):
+    st = 0
+    c= 0
+    tc= 0
+
+    for item in output_info:
+        if c==target_col_index:
+            break
+        if item[1]=='tanh':
+            st += item[0]
+            if item[2] == 'yes_g':
+                c+=1
+        elif item[1] == 'softmax':
+            st += item[0]
+            c+=1
+        tc+=1    
+    
+    ed= st+output_info[tc][0] 
+
+    return (st,ed)
+
+def random_choice_prob_index_sampling(probs,col_idx):
+    option_list = []
+    for i in col_idx:
+        pp = probs[i]
+        option_list.append(np.random.choice(np.arange(len(probs[i])), p=pp))
+    
+    return np.array(option_list).reshape(col_idx.shape)
+
+def random_choice_prob_index(a, axis=1):
+    r = np.expand_dims(np.random.rand(a.shape[1 - axis]), axis=axis)
+    return (a.cumsum(axis=axis) > r).argmax(axis=axis)
+
+def maximum_interval(output_info):
+    max_interval = 0
+    for item in output_info:
+        max_interval = max(max_interval, item[0])
+    return max_interval
+
+class Cond(object):
+    def __init__(self, data, output_info):
+       
+        self.model = []
+        st = 0
+        counter = 0
+        for item in output_info:
+           
+            if item[1] == 'tanh':
+                st += item[0]
+                continue
+            elif item[1] == 'softmax':
+                ed = st + item[0]
+                counter += 1
+                self.model.append(np.argmax(data[:, st:ed], axis=-1))
+                st = ed
+            
+        self.interval = []
+        self.n_col = 0  
+        self.n_opt = 0  
+        st = 0
+        self.p = np.zeros((counter, maximum_interval(output_info)))  
+        self.p_sampling = []
+        for item in output_info:
+            if item[1] == 'tanh':
+                st += item[0]
+                continue
+            elif item[1] == 'softmax': 
+                ed = st + item[0]
+                tmp = np.sum(data[:, st:ed], axis=0)  
+                tmp_sampling = np.sum(data[:, st:ed], axis=0)     
+                tmp = np.log(tmp + 1)  
+                tmp = tmp / np.sum(tmp) 
+                tmp_sampling = tmp_sampling / np.sum(tmp_sampling)
+                self.p_sampling.append(tmp_sampling)
+                self.p[self.n_col, :item[0]] = tmp 
+                self.interval.append((self.n_opt, item[0]))
+                self.n_opt += item[0]
+                self.n_col += 1
+                st = ed
+                
+        self.interval = np.asarray(self.interval)
+        
+    def sample_train(self, batch):
+        if self.n_col == 0:
+            return None
+        batch = batch
+
+        idx = np.random.choice(np.arange(self.n_col), batch)
+
+        vec = np.zeros((batch, self.n_opt), dtype='float32')
+        mask = np.zeros((batch, self.n_col), dtype='float32')
+        mask[np.arange(batch), idx] = 1  
+        opt1prime = random_choice_prob_index(self.p[idx]) 
+        for i in np.arange(batch):
+            vec[i, self.interval[idx[i], 0] + opt1prime[i]] = 1
+            
+        return vec, mask, idx, opt1prime
+
+    def sample(self, batch):
+        if self.n_col == 0:
+            return None
+        batch = batch
+      
+        idx = np.random.choice(np.arange(self.n_col), batch)
+
+        vec = np.zeros((batch, self.n_opt), dtype='float32')
+        opt1prime = random_choice_prob_index_sampling(self.p_sampling,idx)
+        
+        for i in np.arange(batch):
+            vec[i, self.interval[idx[i], 0] + opt1prime[i]] = 1
+            
+        return vec
+
+def cond_loss(data, output_info, c, m):
+    loss = []
+    st = 0
+    st_c = 0
+    for item in output_info:
+        if item[1] == 'tanh':
+            st += item[0]
+            continue
+
+        elif item[1] == 'softmax':
+            ed = st + item[0]
+            ed_c = st_c + item[0]
+            tmp = F.cross_entropy(
+            data[:, st:ed],
+            torch.argmax(c[:, st_c:ed_c], dim=1),
+            reduction='none')
+            loss.append(tmp)
+            st = ed
+            st_c = ed_c
+
+    loss = torch.stack(loss, dim=1)
+    return (loss * m).sum() / data.size()[0]
+
+class Sampler(object):
+    def __init__(self, data, output_info):
+        super(Sampler, self).__init__()
+        self.data = data
+        self.model = []
+        self.n = len(data)
+        st = 0
+        for item in output_info:
+            if item[1] == 'tanh':
+                st += item[0]
+                continue
+            elif item[1] == 'softmax':
+                ed = st + item[0]
+                tmp = []
+                for j in range(item[0]):
+                    tmp.append(np.nonzero(data[:, st + j])[0])
+                self.model.append(tmp)
+                st = ed
+                
+    def sample(self, n, col, opt):
+        if col is None:
+            idx = np.random.choice(np.arange(self.n), n)
+            return self.data[idx]
+        idx = []
+        for c, o in zip(col, opt):
+            idx.append(np.random.choice(self.model[c][o]))
+        return self.data[idx]
+
+class Discriminator(Module):
+    def __init__(self, side, layers):
+        super(Discriminator, self).__init__()
+        self.side = side
+        info = len(layers)-2
+        self.seq = Sequential(*layers)
+        self.seq_info = Sequential(*layers[:info])
+
+    def forward(self, input):
+        return (self.seq(input)), self.seq_info(input)
+
+class Generator(Module):
+    def __init__(self, side, layers):
+        super(Generator, self).__init__()
+        self.side = side
+        self.seq = Sequential(*layers)
+
+    def forward(self, input_):
+        return self.seq(input_)
+
+def determine_layers_disc(side, num_channels):
+    assert side >= 4 and side <= 64
+
+    layer_dims = [(1, side), (num_channels, side // 2)]
+
+    while layer_dims[-1][1] > 3 and len(layer_dims) < 4:
+        layer_dims.append((layer_dims[-1][0] * 2, layer_dims[-1][1] // 2))
+
+    layerNorms = []
+    num_c = num_channels
+    num_s = side / 2
+    for l in range(len(layer_dims) - 1):
+        layerNorms.append([int(num_c), int(num_s), int(num_s)])
+        num_c = num_c * 2
+        num_s = num_s / 2
+
+    layers_D = []
+
+    for prev, curr, ln in zip(layer_dims, layer_dims[1:], layerNorms):
+        layers_D += [
+            Conv2d(prev[0], curr[0], 4, 2, 1, bias=False),
+            LayerNorm(ln),
+            LeakyReLU(0.2, inplace=True),
+        ]
+
+    layers_D += [Conv2d(layer_dims[-1][0], 1, layer_dims[-1][1], 1, 0), ReLU(True)] 
+
+    return layers_D
+
+def determine_layers_gen(side, random_dim, num_channels):
+    assert side >= 4 and side <= 64
+
+    layer_dims = [(1, side), (num_channels, side // 2)]
+
+    while layer_dims[-1][1] > 3 and len(layer_dims) < 4:
+        layer_dims.append((layer_dims[-1][0] * 2, layer_dims[-1][1] // 2))
+
+    layerNorms = []
+
+    num_c = num_channels * (2 ** (len(layer_dims) - 2))
+    num_s = int(side / (2 ** (len(layer_dims) - 1)))
+    for l in range(len(layer_dims) - 1):
+        layerNorms.append([int(num_c), int(num_s), int(num_s)])
+        num_c = num_c / 2
+        num_s = num_s * 2
+
+    layers_G = [ConvTranspose2d(random_dim, layer_dims[-1][0], layer_dims[-1][1], 1, 0, output_padding=0, bias=False)]
+
+    for prev, curr, ln in zip(reversed(layer_dims), reversed(layer_dims[:-1]), layerNorms):
+        layers_G += [LayerNorm(ln), ReLU(True), ConvTranspose2d(prev[0], curr[0], 4, 2, 1, output_padding=0, bias=True)]
+    return layers_G
+
+def slerp(val, low, high):
+    low_norm = low/torch.norm(low, dim=1, keepdim=True)
+    high_norm = high/torch.norm(high, dim=1, keepdim=True)
+    omega = torch.acos((low_norm*high_norm).sum(1)).view(val.size(0), 1)
+    so = torch.sin(omega)
+    res = (torch.sin((1.0-val)*omega)/so)*low + (torch.sin(val*omega)/so) * high
+    
+    return res
+
+def calc_gradient_penalty_slerp(netD, real_data, fake_data, transformer, device='cpu', lambda_=10):
+    batchsize = real_data.shape[0]
+    alpha = torch.rand(batchsize, 1,  device=device)
+    interpolates = slerp(alpha, real_data, fake_data)
+    interpolates = interpolates.to(device)
+    interpolates = transformer.transform(interpolates)
+    interpolates = torch.autograd.Variable(interpolates, requires_grad=True)
+    disc_interpolates,_ = netD(interpolates) 
+
+    gradients = torch.autograd.grad(outputs=disc_interpolates, inputs=interpolates,
+                                  grad_outputs=torch.ones(disc_interpolates.size()).to(device),
+                                  create_graph=True, retain_graph=True, only_inputs=True)[0] 
+    
+    gradients_norm = gradients.norm(2, dim=1)
+    gradient_penalty = ((gradients_norm - 1) ** 2).mean() * lambda_
+    
+    return gradient_penalty
+
+def weights_init(m):
+    classname = m.__class__.__name__
+    
+    if classname.find('Conv') != -1:
+        init.normal_(m.weight.data, 0.0, 0.02)
+
+    elif classname.find('BatchNorm') != -1:
+        init.normal_(m.weight.data, 1.0, 0.02)
+        init.constant_(m.bias.data, 0)
+
+class CTABGANSynthesizer:
+    def __init__(self,
+                 class_dim=(256, 256, 256, 256),
+                 random_dim=100,
+                 num_channels=64,
+                 l2scale=1e-5,
+                 batch_size=500,
+                 epochs=150,
+                 device="cpu"):
+                 
+
+        self.random_dim = random_dim
+        self.class_dim = class_dim
+        self.num_channels = num_channels
+        self.dside = None
+        self.gside = None
+        self.l2scale = l2scale
+        self.batch_size = batch_size
+        self.epochs = epochs
+        self.device = torch.device(device)
+
+    def fit(self, train_data=pd.DataFrame, categorical=[], mixed={}, general=[], non_categorical=[], type={}):
+
+        problem_type = None
+        target_index=None
+        if type:
+            problem_type = list(type.keys())[0]
+            if problem_type:
+                target_index = train_data.columns.get_loc(type[problem_type])
+
+        self.transformer = DataTransformer(train_data=train_data, categorical_list=categorical, mixed_dict=mixed, general_list=general, non_categorical_list=non_categorical)
+        self.transformer.fit() 
+        train_data = self.transformer.transform(train_data.values)
+        data_sampler = Sampler(train_data, self.transformer.output_info)
+        data_dim = self.transformer.output_dim
+        self.cond_generator = Cond(train_data, self.transformer.output_info)
+        		
+        sides = [4, 8, 16, 24, 64]
+        col_size_d = data_dim + self.cond_generator.n_opt
+        for i in sides:
+            if i * i >= col_size_d:
+                self.dside = i
+                break
+        
+        sides = [4, 8, 16, 24, 64]
+        col_size_g = data_dim
+        for i in sides:
+            if i * i >= col_size_g:
+                self.gside = i
+                break
+		
+
+        layers_G = determine_layers_gen(self.gside, self.random_dim+self.cond_generator.n_opt, self.num_channels)
+        layers_D = determine_layers_disc(self.dside, self.num_channels)
+        
+        self.generator = Generator(self.gside, layers_G).to(self.device)
+        discriminator = Discriminator(self.dside, layers_D).to(self.device)
+        optimizer_params = dict(lr=2e-4, betas=(0.5, 0.9), eps=1e-3, weight_decay=self.l2scale)
+        optimizerG = Adam(self.generator.parameters(), **optimizer_params)
+        optimizerD = Adam(discriminator.parameters(), **optimizer_params)
+
+        st_ed = None
+        classifier=None
+        optimizerC= None
+        if target_index != None:
+            st_ed= get_st_ed(target_index,self.transformer.output_info)
+            classifier = Classifier(data_dim,self.class_dim,st_ed).to(self.device)
+            optimizerC = optim.Adam(classifier.parameters(),**optimizer_params)
+        
+        
+        self.generator.apply(weights_init)
+        discriminator.apply(weights_init)
+
+        self.Gtransformer = ImageTransformer(self.gside)       
+        self.Dtransformer = ImageTransformer(self.dside)
+        
+        epsilon = 0
+        epoch = 0
+        steps = 0
+        ci = 1
+        
+        for i in tqdm(range(self.epochs)):
+				
+            
+            for _ in range(ci):
+                noisez = torch.randn(self.batch_size, self.random_dim, device=self.device)
+                condvec = self.cond_generator.sample_train(self.batch_size)
+
+                c, m, col, opt = condvec
+                c = torch.from_numpy(c).to(self.device)
+                m = torch.from_numpy(m).to(self.device)
+                noisez = torch.cat([noisez, c], dim=1)
+                noisez =  noisez.view(self.batch_size,self.random_dim+self.cond_generator.n_opt,1,1)
+                
+                perm = np.arange(self.batch_size)
+                np.random.shuffle(perm)
+                real = data_sampler.sample(self.batch_size, col[perm], opt[perm])
+                c_perm = c[perm]
+                
+                real = torch.from_numpy(real.astype('float32')).to(self.device)
+                
+                fake = self.generator(noisez)
+                faket = self.Gtransformer.inverse_transform(fake)
+                fakeact = apply_activate(faket, self.transformer.output_info)
+                
+                fake_cat = torch.cat([fakeact, c], dim=1)
+                real_cat = torch.cat([real, c_perm], dim=1)
+                
+                real_cat_d = self.Dtransformer.transform(real_cat)
+                fake_cat_d = self.Dtransformer.transform(fake_cat)
+                
+                optimizerD.zero_grad()
+                
+                d_real,_ = discriminator(real_cat_d)
+                
+
+                d_real = -torch.mean(d_real)
+                d_real.backward() 
+                
+
+                d_fake,_ = discriminator(fake_cat_d)
+                
+                d_fake = torch.mean(d_fake)
+
+                d_fake.backward() 
+                
+                pen = calc_gradient_penalty_slerp(discriminator, real_cat, fake_cat,  self.Dtransformer , self.device)
+
+                pen.backward()
+            
+                optimizerD.step()
+                
+            noisez = torch.randn(self.batch_size, self.random_dim, device=self.device)
+            
+            condvec = self.cond_generator.sample_train(self.batch_size)
+
+            c, m, col, opt = condvec
+            c = torch.from_numpy(c).to(self.device)
+            m = torch.from_numpy(m).to(self.device)
+            noisez = torch.cat([noisez, c], dim=1)
+            noisez =  noisez.view(self.batch_size,self.random_dim+self.cond_generator.n_opt,1,1)
+
+            optimizerG.zero_grad()
+
+            fake = self.generator(noisez)
+            faket = self.Gtransformer.inverse_transform(fake)
+            fakeact = apply_activate(faket, self.transformer.output_info)
+
+            fake_cat = torch.cat([fakeact, c], dim=1) 
+            fake_cat = self.Dtransformer.transform(fake_cat)
+                
+            y_fake,info_fake = discriminator(fake_cat)
+            
+            cross_entropy = cond_loss(faket, self.transformer.output_info, c, m)
+
+            _,info_real = discriminator(real_cat_d)
+            
+
+            g = -torch.mean(y_fake) + cross_entropy
+            g.backward(retain_graph=True)
+            loss_mean = torch.norm(torch.mean(info_fake.view(self.batch_size,-1), dim=0) - torch.mean(info_real.view(self.batch_size,-1), dim=0), 1)
+            loss_std = torch.norm(torch.std(info_fake.view(self.batch_size,-1), dim=0) - torch.std(info_real.view(self.batch_size,-1), dim=0), 1)
+            loss_info = loss_mean + loss_std 
+            loss_info.backward()
+            optimizerG.step()
+
+
+            if problem_type:
+                        
+                fake = self.generator(noisez)
+                
+                faket = self.Gtransformer.inverse_transform(fake)
+                
+                fakeact = apply_activate(faket, self.transformer.output_info)
+                
+                real_pre, real_label = classifier(real)
+                fake_pre, fake_label = classifier(fakeact)
+                    
+                c_loss = CrossEntropyLoss() 
+                
+                if (st_ed[1] - st_ed[0])==1:
+                    c_loss= SmoothL1Loss()
+                    real_label = real_label.type_as(real_pre)
+                    fake_label = fake_label.type_as(fake_pre)
+                    real_label = torch.reshape(real_label,real_pre.size())
+                    fake_label = torch.reshape(fake_label,fake_pre.size())
+                    
+                
+                elif (st_ed[1] - st_ed[0])==2:
+                    c_loss = BCELoss()
+                    real_label = real_label.type_as(real_pre)
+                    fake_label = fake_label.type_as(fake_pre)
+
+                loss_cc = c_loss(real_pre, real_label)
+                loss_cg = c_loss(fake_pre, fake_label)
+
+                optimizerG.zero_grad()
+                loss_cg.backward()
+                optimizerG.step()
+
+                optimizerC.zero_grad()
+                loss_cc.backward()
+                optimizerC.step()
+                            
+
+            
+   
+    @torch.no_grad()
+    def sample(self, n, seed=0):
+
+        torch.manual_seed(seed)
+        torch.cuda.manual_seed(seed)
+        sample_batch_size = 8092
+        self.generator.eval()
+
+        output_info = self.transformer.output_info
+        steps = n // sample_batch_size + 1
+
+        data = []
+        
+        for i in range(steps):
+            noisez = torch.randn(self.batch_size, self.random_dim, device=self.device)
+            condvec = self.cond_generator.sample(self.batch_size)
+            c = condvec
+            c = torch.from_numpy(c).to(self.device)
+            noisez = torch.cat([noisez, c], dim=1)
+            noisez =  noisez.view(self.batch_size,self.random_dim+self.cond_generator.n_opt,1,1)
+                
+            fake = self.generator(noisez)
+            faket = self.Gtransformer.inverse_transform(fake)
+            fakeact = apply_activate(faket,output_info)
+            data.append(fakeact.detach().cpu().numpy())
+
+        data = np.concatenate(data, axis=0)
+        result,resample = self.transformer.inverse_transform(data)
+        
+        while len(result) < n:
+            data_resample = []    
+            steps_left = resample// self.batch_size + 1
+            
+            for i in range(steps_left):
+                noisez = torch.randn(self.batch_size, self.random_dim, device=self.device)
+                condvec = self.cond_generator.sample(self.batch_size)
+                c = condvec
+                c = torch.from_numpy(c).to(self.device)
+                noisez = torch.cat([noisez, c], dim=1)
+                noisez =  noisez.view(self.batch_size,self.random_dim+self.cond_generator.n_opt,1,1)
+                    
+                fake = self.generator(noisez)
+                faket = self.Gtransformer.inverse_transform(fake)
+                fakeact = apply_activate(faket, output_info)
+                data_resample.append(fakeact.detach().cpu().numpy())
+
+            data_resample = np.concatenate(data_resample, axis=0)
+
+            res,resample = self.transformer.inverse_transform(data_resample)
+            result  = np.concatenate([result,res],axis=0)
+        
+        return result[0:n]
+

syntheticFail/c16/tabddpm/tabddpm-c16-20260510_223930/_tabddpm_runtime/CTAB-GAN-Plus/model copy/synthesizer/transformer.py

@@ -0,0 +1,429 @@
+import numpy as np
+import pandas as pd
+import torch
+from sklearn.mixture import BayesianGaussianMixture
+
+class DataTransformer():
+    
+    def __init__(self, train_data=pd.DataFrame, categorical_list=[], mixed_dict={}, general_list=[], non_categorical_list=[], n_clusters=10, eps=0.005):
+        self.meta = None
+        self.n_clusters = n_clusters
+        self.eps = eps
+        self.train_data = train_data
+        self.categorical_columns= categorical_list
+        self.mixed_columns= mixed_dict
+        self.general_columns = general_list
+        self.non_categorical_columns= non_categorical_list
+        
+    def get_metadata(self):
+        
+        meta = []
+    
+        for index in range(self.train_data.shape[1]):
+            column = self.train_data.iloc[:,index]
+            if index in self.categorical_columns:
+                if index in self.non_categorical_columns:
+                    meta.append({
+                      "name": index,
+                      "type": "continuous",
+                      "min": column.min(),
+                      "max": column.max(),
+                    })
+                else:
+                    mapper = column.value_counts().index.tolist()
+                    meta.append({
+                        "name": index,
+                        "type": "categorical",
+                        "size": len(mapper),
+                        "i2s": mapper
+                    })
+
+            elif index in self.mixed_columns.keys():
+                meta.append({
+                    "name": index,
+                    "type": "mixed",
+                    "min": column.min(),
+                    "max": column.max(),
+                    "modal": self.mixed_columns[index]
+                })
+            else:
+                meta.append({
+                    "name": index,
+                    "type": "continuous",
+                    "min": column.min(),
+                    "max": column.max(),
+                })            
+
+        return meta
+
+    def fit(self):
+        data = self.train_data.values
+        self.meta = self.get_metadata()
+        model = []
+        self.ordering = []
+        self.output_info = []
+        self.output_dim = 0
+        self.components = []
+        self.filter_arr = []
+        for id_, info in enumerate(self.meta):
+            if info['type'] == "continuous":
+                if id_ not in self.general_columns:
+                  gm = BayesianGaussianMixture(
+                      n_components = self.n_clusters, 
+                      weight_concentration_prior_type='dirichlet_process',
+                      weight_concentration_prior=0.001, 
+                      max_iter=100,n_init=1, random_state=42)
+                  gm.fit(data[:, id_].reshape([-1, 1]))
+                  mode_freq = (pd.Series(gm.predict(data[:, id_].reshape([-1, 1]))).value_counts().keys())
+                  model.append(gm)
+                  old_comp = gm.weights_ > self.eps
+                  comp = []
+                  for i in range(self.n_clusters):
+                      if (i in (mode_freq)) & old_comp[i]:
+                          comp.append(True)
+                      else:
+                          comp.append(False)
+                  self.components.append(comp) 
+                  self.output_info += [(1, 'tanh','no_g'), (np.sum(comp), 'softmax')]
+                  self.output_dim += 1 + np.sum(comp)
+                else:
+                  model.append(None)
+                  self.components.append(None)
+                  self.output_info += [(1, 'tanh','yes_g')]
+                  self.output_dim += 1
+            
+            elif info['type'] == "mixed":
+                
+                gm1 = BayesianGaussianMixture(
+                    n_components = self.n_clusters, 
+                    weight_concentration_prior_type='dirichlet_process',
+                    weight_concentration_prior=0.001, max_iter=100,
+                    n_init=1,random_state=42)
+                gm2 = BayesianGaussianMixture(
+                    n_components = self.n_clusters,
+                    weight_concentration_prior_type='dirichlet_process',
+                    weight_concentration_prior=0.001, max_iter=100,
+                    n_init=1,random_state=42)
+                
+                gm1.fit(data[:, id_].reshape([-1, 1]))
+                
+                filter_arr = []
+                for element in data[:, id_]:
+                    if element not in info['modal']:
+                        filter_arr.append(True)
+                    else:
+                        filter_arr.append(False)
+               
+                gm2.fit(data[:, id_][filter_arr].reshape([-1, 1]))
+                mode_freq = (pd.Series(gm2.predict(data[:, id_][filter_arr].reshape([-1, 1]))).value_counts().keys())
+                self.filter_arr.append(filter_arr)
+                model.append((gm1,gm2))
+               
+                old_comp = gm2.weights_ > self.eps
+                  
+                comp = []
+                  
+                for i in range(self.n_clusters):
+                    if (i in (mode_freq)) & old_comp[i]:
+                        comp.append(True)
+                    else:
+                        comp.append(False)
+
+                self.components.append(comp)
+
+                self.output_info += [(1, 'tanh',"no_g"), (np.sum(comp) + len(info['modal']), 'softmax')]
+                self.output_dim += 1 + np.sum(comp) + len(info['modal'])
+            else:
+                model.append(None)
+                self.components.append(None)
+                self.output_info += [(info['size'], 'softmax')]
+                self.output_dim += info['size']
+        self.model = model
+
+    def transform(self, data, ispositive = False, positive_list = None):
+        values = []
+        mixed_counter = 0
+        for id_, info in enumerate(self.meta):
+            current = data[:, id_]
+            if info['type'] == "continuous":
+                if id_ not in self.general_columns: 
+                  current = current.reshape([-1, 1])
+                  means = self.model[id_].means_.reshape((1, self.n_clusters))
+                  stds = np.sqrt(self.model[id_].covariances_).reshape((1, self.n_clusters))
+                  features = np.empty(shape=(len(current),self.n_clusters))
+                  if ispositive == True:
+                      if id_ in positive_list:
+                          features = np.abs(current - means) / (4 * stds)
+                  else:
+                      features = (current - means) / (4 * stds)
+
+                  probs = self.model[id_].predict_proba(current.reshape([-1, 1]))
+                  n_opts = sum(self.components[id_])
+                  features = features[:, self.components[id_]]
+                  probs = probs[:, self.components[id_]]
+
+                  opt_sel = np.zeros(len(data), dtype='int')
+                  for i in range(len(data)):
+                      pp = probs[i] + 1e-6
+                      pp = pp / sum(pp)
+                      opt_sel[i] = np.random.choice(np.arange(n_opts), p=pp)
+
+                  idx = np.arange((len(features)))
+                  features = features[idx, opt_sel].reshape([-1, 1])
+                  features = np.clip(features, -.99, .99) 
+                  probs_onehot = np.zeros_like(probs)
+                  probs_onehot[np.arange(len(probs)), opt_sel] = 1
+
+                  re_ordered_phot = np.zeros_like(probs_onehot)
+                  
+                  col_sums = probs_onehot.sum(axis=0)
+                  
+
+                  n = probs_onehot.shape[1]
+                  largest_indices = np.argsort(-1*col_sums)[:n]
+                  self.ordering.append(largest_indices)
+                  for id,val in enumerate(largest_indices):
+                      re_ordered_phot[:,id] = probs_onehot[:,val]
+                
+                  
+                  values += [features, re_ordered_phot]
+                  
+                else:
+                  
+                  self.ordering.append(None)
+                  
+                  if id_ in self.non_categorical_columns:
+                    info['min'] = -1e-3
+                    info['max'] = info['max'] + 1e-3
+                    
+                  current = (current - (info['min'])) / (info['max'] - info['min'])
+                  current = current * 2 - 1 
+                  current = current.reshape([-1, 1])
+                  values.append(current)
+
+            elif info['type'] == "mixed":
+                    
+                means_0 = self.model[id_][0].means_.reshape([-1])
+                stds_0 = np.sqrt(self.model[id_][0].covariances_).reshape([-1])
+
+                zero_std_list = []
+                means_needed = []
+                stds_needed = []
+
+                for mode in info['modal']:
+                    if mode!=-9999999:
+                        dist = []
+                        for idx,val in enumerate(list(means_0.flatten())):
+                            dist.append(abs(mode-val))
+                        index_min = np.argmin(np.array(dist))
+                        zero_std_list.append(index_min)
+                    else: continue
+
+                for idx in zero_std_list:
+                    means_needed.append(means_0[idx])
+                    stds_needed.append(stds_0[idx])
+                
+                
+                mode_vals = []
+
+                for i,j,k in zip(info['modal'],means_needed,stds_needed):
+                    this_val  = np.abs(i - j) / (4*k)
+                    mode_vals.append(this_val)
+                
+                if -9999999 in info["modal"]:
+                    mode_vals.append(0)
+                
+                current = current.reshape([-1, 1])
+                filter_arr = self.filter_arr[mixed_counter]
+                current = current[filter_arr]
+                
+                means = self.model[id_][1].means_.reshape((1, self.n_clusters))
+                stds = np.sqrt(self.model[id_][1].covariances_).reshape((1, self.n_clusters))
+                features = np.empty(shape=(len(current),self.n_clusters))
+                if ispositive == True:
+                    if id_ in positive_list:
+                        features = np.abs(current - means) / (4 * stds)
+                else:
+                    features = (current - means) / (4 * stds)
+
+                probs = self.model[id_][1].predict_proba(current.reshape([-1, 1]))
+
+                n_opts = sum(self.components[id_]) # 8
+                features = features[:, self.components[id_]]
+                probs = probs[:, self.components[id_]]
+                
+                opt_sel = np.zeros(len(current), dtype='int')
+                for i in range(len(current)):
+                    pp = probs[i] + 1e-6
+                    pp = pp / sum(pp)
+                    opt_sel[i] = np.random.choice(np.arange(n_opts), p=pp)
+                idx = np.arange((len(features)))
+                features = features[idx, opt_sel].reshape([-1, 1])
+                features = np.clip(features, -.99, .99)
+                probs_onehot = np.zeros_like(probs)
+                probs_onehot[np.arange(len(probs)), opt_sel] = 1
+                extra_bits = np.zeros([len(current), len(info['modal'])])
+                temp_probs_onehot = np.concatenate([extra_bits,probs_onehot], axis = 1)
+                final = np.zeros([len(data), 1 + probs_onehot.shape[1] + len(info['modal'])])
+                features_curser = 0
+                for idx, val in enumerate(data[:, id_]):
+                    if val in info['modal']:
+                        category_ = list(map(info['modal'].index, [val]))[0]
+                        final[idx, 0] = mode_vals[category_]
+                        final[idx, (category_+1)] = 1
+                    
+                    else:
+                        final[idx, 0] = features[features_curser]
+                        final[idx, (1+len(info['modal'])):] = temp_probs_onehot[features_curser][len(info['modal']):]
+                        features_curser = features_curser + 1
+               
+                just_onehot = final[:,1:]
+                re_ordered_jhot= np.zeros_like(just_onehot)
+                n = just_onehot.shape[1]
+                col_sums = just_onehot.sum(axis=0)
+                largest_indices = np.argsort(-1*col_sums)[:n]
+                self.ordering.append(largest_indices)
+                for id,val in enumerate(largest_indices):
+                      re_ordered_jhot[:,id] = just_onehot[:,val]
+                final_features = final[:,0].reshape([-1, 1])
+                values += [final_features, re_ordered_jhot]
+                mixed_counter = mixed_counter + 1
+    
+            else:
+                self.ordering.append(None)
+                col_t = np.zeros([len(data), info['size']])
+                idx = list(map(info['i2s'].index, current))
+                col_t[np.arange(len(data)), idx] = 1
+                values.append(col_t)
+                
+        return np.concatenate(values, axis=1)
+
+    def inverse_transform(self, data):
+        data_t = np.zeros([len(data), len(self.meta)])
+        invalid_ids = []
+        st = 0
+        for id_, info in enumerate(self.meta):
+            if info['type'] == "continuous":
+                if id_ not in self.general_columns:
+                  u = data[:, st]
+                  v = data[:, st + 1:st + 1 + np.sum(self.components[id_])]
+                  order = self.ordering[id_] 
+                  v_re_ordered = np.zeros_like(v)
+
+                  for id,val in enumerate(order):
+                      v_re_ordered[:,val] = v[:,id]
+                  
+                  v = v_re_ordered
+
+                  u = np.clip(u, -1, 1)
+                  v_t = np.ones((data.shape[0], self.n_clusters)) * -100
+                  v_t[:, self.components[id_]] = v
+                  v = v_t
+                  st += 1 + np.sum(self.components[id_])
+                  means = self.model[id_].means_.reshape([-1])
+                  stds = np.sqrt(self.model[id_].covariances_).reshape([-1])
+                  p_argmax = np.argmax(v, axis=1)
+                  std_t = stds[p_argmax]
+                  mean_t = means[p_argmax]
+                  tmp = u * 4 * std_t + mean_t
+                                    
+                  for idx,val in enumerate(tmp):
+                     if (val < info["min"]) | (val > info['max']):
+                         invalid_ids.append(idx)
+                  
+                  if id_ in self.non_categorical_columns:
+                    
+                    tmp = np.round(tmp)
+                  
+                  data_t[:, id_] = tmp
+
+                else:
+                  u = data[:, st]
+                  u = (u + 1) / 2
+                  u = np.clip(u, 0, 1)
+                  u = u * (info['max'] - info['min']) + info['min']
+                  if id_ in self.non_categorical_columns:
+                    data_t[:, id_] = np.round(u)
+                  else: data_t[:, id_] = u
+
+                  st += 1
+
+            elif info['type'] == "mixed":
+
+                u = data[:, st]
+                full_v = data[:,(st+1):(st+1)+len(info['modal'])+np.sum(self.components[id_])]
+                order = self.ordering[id_]
+                full_v_re_ordered = np.zeros_like(full_v)
+
+                for id,val in enumerate(order):
+                    full_v_re_ordered[:,val] = full_v[:,id]
+                  
+                full_v = full_v_re_ordered
+
+                
+                mixed_v = full_v[:,:len(info['modal'])]
+                v = full_v[:,-np.sum(self.components[id_]):]
+
+                u = np.clip(u, -1, 1)
+                v_t = np.ones((data.shape[0], self.n_clusters)) * -100
+                v_t[:, self.components[id_]] = v
+                v = np.concatenate([mixed_v,v_t], axis=1)
+
+                st += 1 + np.sum(self.components[id_]) + len(info['modal'])
+                means = self.model[id_][1].means_.reshape([-1]) 
+                stds = np.sqrt(self.model[id_][1].covariances_).reshape([-1]) 
+                p_argmax = np.argmax(v, axis=1)
+
+                result = np.zeros_like(u)
+
+                for idx in range(len(data)):
+                    if p_argmax[idx] < len(info['modal']):
+                        argmax_value = p_argmax[idx]
+                        result[idx] = float(list(map(info['modal'].__getitem__, [argmax_value]))[0])
+                    else:
+                        std_t = stds[(p_argmax[idx]-len(info['modal']))]
+                        mean_t = means[(p_argmax[idx]-len(info['modal']))]
+                        result[idx] = u[idx] * 4 * std_t + mean_t
+                        
+                for idx,val in enumerate(result):
+                     if (val < info["min"]) | (val > info['max']):
+                         invalid_ids.append(idx)
+
+                data_t[:, id_] = result
+
+            else:
+                current = data[:, st:st + info['size']]
+                st += info['size']
+                idx = np.argmax(current, axis=1)
+                data_t[:, id_] = list(map(info['i2s'].__getitem__, idx))
+            
+            
+        invalid_ids = np.unique(np.array(invalid_ids)) 
+        all_ids = np.arange(0,len(data))
+        valid_ids = list(set(all_ids) - set(invalid_ids))
+            
+        return data_t[valid_ids],len(invalid_ids)
+
+
+class ImageTransformer():
+
+    def __init__(self, side):
+    
+        self.height = side
+            
+    def transform(self, data):
+
+        if self.height * self.height > len(data[0]):
+            
+            padding = torch.zeros((len(data), self.height * self.height - len(data[0]))).to(data.device)
+            data = torch.cat([data, padding], axis=1)
+
+        return data.view(-1, 1, self.height, self.height)
+
+    def inverse_transform(self, data):
+        
+        data = data.view(-1, self.height * self.height)
+
+        return data
+
+

syntheticFail/c16/tabddpm/tabddpm-c16-20260510_223930/_tabddpm_runtime/CTAB-GAN-Plus/model/ctabgan.py

@@ -0,0 +1,72 @@
+"""
+Generative model training algorithm based on the CTABGANSynthesiser
+
+"""
+import pandas as pd
+import time
+from model.pipeline.data_preparation import DataPrep
+from model.synthesizer.ctabgan_synthesizer import CTABGANSynthesizer
+
+import warnings
+
+warnings.filterwarnings("ignore")
+
+class CTABGAN():
+
+    def __init__(self,
+                 df,
+                 test_ratio = 0.20,
+                 categorical_columns = [],
+                 log_columns = [],
+                 mixed_columns= {},
+                 general_columns = [],
+                 non_categorical_columns = [],
+                 integer_columns = [],
+                 problem_type= {},
+                 class_dim=(256, 256, 256, 256),
+                 random_dim=100,
+                 num_channels=64,
+                 l2scale=1e-5,
+                 batch_size=500,
+                 epochs=150,
+                 lr=2e-4,
+                 device="cpu"):
+
+        self.__name__ = 'CTABGAN'
+              
+        self.synthesizer = CTABGANSynthesizer(
+                class_dim=class_dim,
+                random_dim=random_dim,
+                num_channels=num_channels,
+                l2scale=l2scale,
+                lr=lr,
+                batch_size=batch_size,
+                epochs=epochs,
+                device=device
+        )
+        self.raw_df = df
+        self.test_ratio = test_ratio
+        self.categorical_columns = categorical_columns
+        self.log_columns = log_columns
+        self.mixed_columns = mixed_columns
+        self.general_columns = general_columns
+        self.non_categorical_columns = non_categorical_columns
+        self.integer_columns = integer_columns
+        self.problem_type = problem_type
+                
+    def fit(self):
+        
+        start_time = time.time()
+        self.data_prep = DataPrep(self.raw_df,self.categorical_columns,self.log_columns,self.mixed_columns,self.general_columns,self.non_categorical_columns,self.integer_columns,self.problem_type,self.test_ratio)
+        self.synthesizer.fit(train_data=self.data_prep.df, categorical = self.data_prep.column_types["categorical"], mixed = self.data_prep.column_types["mixed"],
+        general = self.data_prep.column_types["general"], non_categorical = self.data_prep.column_types["non_categorical"], type=self.problem_type)
+        end_time = time.time()
+        print('Finished training in',end_time-start_time," seconds.")
+
+
+    def generate_samples(self, num_samples, seed=0):
+        
+        sample = self.synthesizer.sample(num_samples, seed) 
+        sample_df = self.data_prep.inverse_prep(sample)
+        
+        return sample_df

syntheticFail/c16/tabddpm/tabddpm-c16-20260510_223930/_tabddpm_runtime/CTAB-GAN-Plus/model/eval/evaluation.py

@@ -0,0 +1,193 @@
+import numpy as np
+import pandas as pd 
+from sklearn import metrics
+from sklearn import model_selection
+from sklearn.preprocessing import MinMaxScaler,StandardScaler
+from sklearn.neural_network import MLPClassifier
+from sklearn.linear_model import LogisticRegression
+from sklearn import svm,tree
+from sklearn.ensemble import RandomForestClassifier
+from dython.nominal import compute_associations
+from scipy.stats import wasserstein_distance
+from scipy.spatial import distance
+import warnings
+
+warnings.filterwarnings("ignore")
+
+def supervised_model_training(x_train, y_train, x_test, 
+                              y_test, model_name):
+  
+     
+  if model_name == 'lr':
+    model  = LogisticRegression(random_state=42,max_iter=500) 
+  elif model_name == 'svm':
+    model  = svm.SVC(random_state=42,probability=True)
+  elif model_name == 'dt':
+    model  = tree.DecisionTreeClassifier(random_state=42)
+  elif model_name == 'rf':      
+    model = RandomForestClassifier(random_state=42)
+  elif model_name == "mlp":
+    model = MLPClassifier(random_state=42,max_iter=100)
+  
+  model.fit(x_train, y_train)
+  pred = model.predict(x_test)
+
+  if len(np.unique(y_train))>2:
+    predict = model.predict_proba(x_test)        
+    acc = metrics.accuracy_score(y_test,pred)*100
+    auc = metrics.roc_auc_score(y_test, predict,average="weighted",multi_class="ovr")
+    f1_score = metrics.precision_recall_fscore_support(y_test, pred,average="weighted")[2]
+    return [acc, auc,f1_score] 
+
+  else:
+    predict = model.predict_proba(x_test)[:,1]    
+    acc = metrics.accuracy_score(y_test,pred)*100
+    auc = metrics.roc_auc_score(y_test, predict)
+    f1_score = metrics.precision_recall_fscore_support(y_test,pred)[2].mean()
+    return [acc, auc,f1_score] 
+
+
+def get_utility_metrics(real_path,fake_paths,scaler="MinMax",classifiers=["lr","dt","rf","mlp"],test_ratio=.20):
+
+    data_real = pd.read_csv(real_path).to_numpy()
+    data_dim = data_real.shape[1]
+
+    data_real_y = data_real[:,-1]
+    data_real_X = data_real[:,:data_dim-1]
+    X_train_real, X_test_real, y_train_real, y_test_real = model_selection.train_test_split(data_real_X ,data_real_y, test_size=test_ratio, stratify=data_real_y,random_state=42) 
+
+    if scaler=="MinMax":
+        scaler_real = MinMaxScaler()
+    else:
+        scaler_real = StandardScaler()
+        
+    scaler_real.fit(data_real_X)
+    X_train_real_scaled = scaler_real.transform(X_train_real)
+    X_test_real_scaled = scaler_real.transform(X_test_real)
+
+    all_real_results = []
+    for classifier in classifiers:
+      real_results = supervised_model_training(X_train_real_scaled,y_train_real,X_test_real_scaled,y_test_real,classifier)
+      all_real_results.append(real_results)
+      
+    all_fake_results_avg = []
+    
+    for fake_path in fake_paths:
+      data_fake  = pd.read_csv(fake_path).to_numpy()
+      data_fake_y = data_fake[:,-1]
+      data_fake_X = data_fake[:,:data_dim-1]
+      X_train_fake, _ , y_train_fake, _ = model_selection.train_test_split(data_fake_X ,data_fake_y, test_size=test_ratio, stratify=data_fake_y,random_state=42) 
+
+      if scaler=="MinMax":
+        scaler_fake = MinMaxScaler()
+      else:
+        scaler_fake = StandardScaler()
+      
+      scaler_fake.fit(data_fake_X)
+      
+      X_train_fake_scaled = scaler_fake.transform(X_train_fake)
+      
+      all_fake_results = []
+      for classifier in classifiers:
+        fake_results = supervised_model_training(X_train_fake_scaled,y_train_fake,X_test_real_scaled,y_test_real,classifier)
+        all_fake_results.append(fake_results)
+
+      all_fake_results_avg.append(all_fake_results)
+    
+    diff_results = np.array(all_real_results)- np.array(all_fake_results_avg).mean(axis=0)
+
+    return diff_results
+
+def stat_sim(real_path,fake_path,cat_cols=None):
+    
+    Stat_dict={}
+    
+    real = pd.read_csv(real_path)
+    fake = pd.read_csv(fake_path)
+
+    really = real.copy()
+    fakey = fake.copy()
+
+    real_corr = compute_associations(real, nominal_columns=cat_cols)
+
+    fake_corr = compute_associations(fake, nominal_columns=cat_cols)
+
+    corr_dist = np.linalg.norm(real_corr - fake_corr)
+    
+    cat_stat = []
+    num_stat = []
+    
+    for column in real.columns:
+        
+        if column in cat_cols:
+
+            real_pdf=(really[column].value_counts()/really[column].value_counts().sum())
+            fake_pdf=(fakey[column].value_counts()/fakey[column].value_counts().sum())
+            categories = (fakey[column].value_counts()/fakey[column].value_counts().sum()).keys().tolist()
+            sorted_categories = sorted(categories)
+            
+            real_pdf_values = [] 
+            fake_pdf_values = []
+
+            for i in sorted_categories:
+                real_pdf_values.append(real_pdf[i])
+                fake_pdf_values.append(fake_pdf[i])
+            
+            if len(real_pdf)!=len(fake_pdf):
+                zero_cats = set(really[column].value_counts().keys())-set(fakey[column].value_counts().keys())
+                for z in zero_cats:
+                    real_pdf_values.append(real_pdf[z])
+                    fake_pdf_values.append(0)
+            Stat_dict[column]=(distance.jensenshannon(real_pdf_values,fake_pdf_values, 2.0))
+            cat_stat.append(Stat_dict[column])        
+        else:
+            scaler = MinMaxScaler()
+            scaler.fit(real[column].values.reshape(-1,1))
+            l1 = scaler.transform(real[column].values.reshape(-1,1)).flatten()
+            l2 = scaler.transform(fake[column].values.reshape(-1,1)).flatten()
+            Stat_dict[column]= (wasserstein_distance(l1,l2))
+            num_stat.append(Stat_dict[column])
+
+    return [np.mean(num_stat),np.mean(cat_stat),corr_dist]
+
+def privacy_metrics(real_path,fake_path,data_percent=15):
+    
+    real = pd.read_csv(real_path).drop_duplicates(keep=False)
+    fake = pd.read_csv(fake_path).drop_duplicates(keep=False)
+
+    real_refined = real.sample(n=int(len(real)*(.01*data_percent)), random_state=42).to_numpy()
+    fake_refined = fake.sample(n=int(len(fake)*(.01*data_percent)), random_state=42).to_numpy()
+
+    scalerR = StandardScaler()
+    scalerR.fit(real_refined)
+    scalerF = StandardScaler()
+    scalerF.fit(fake_refined)
+    df_real_scaled = scalerR.transform(real_refined)
+    df_fake_scaled = scalerF.transform(fake_refined)
+    
+    dist_rf = metrics.pairwise_distances(df_real_scaled, Y=df_fake_scaled, metric='minkowski', n_jobs=-1)
+    dist_rr = metrics.pairwise_distances(df_real_scaled, Y=None, metric='minkowski', n_jobs=-1)
+    rd_dist_rr = dist_rr[~np.eye(dist_rr.shape[0],dtype=bool)].reshape(dist_rr.shape[0],-1)
+    dist_ff = metrics.pairwise_distances(df_fake_scaled, Y=None, metric='minkowski', n_jobs=-1)
+    rd_dist_ff = dist_ff[~np.eye(dist_ff.shape[0],dtype=bool)].reshape(dist_ff.shape[0],-1) 
+    smallest_two_indexes_rf = [dist_rf[i].argsort()[:2] for i in range(len(dist_rf))]
+    smallest_two_rf = [dist_rf[i][smallest_two_indexes_rf[i]] for i in range(len(dist_rf))]       
+    smallest_two_indexes_rr = [rd_dist_rr[i].argsort()[:2] for i in range(len(rd_dist_rr))]
+    smallest_two_rr = [rd_dist_rr[i][smallest_two_indexes_rr[i]] for i in range(len(rd_dist_rr))]
+    smallest_two_indexes_ff = [rd_dist_ff[i].argsort()[:2] for i in range(len(rd_dist_ff))]
+    smallest_two_ff = [rd_dist_ff[i][smallest_two_indexes_ff[i]] for i in range(len(rd_dist_ff))]
+    nn_ratio_rr = np.array([i[0]/i[1] for i in smallest_two_rr])
+    nn_ratio_ff = np.array([i[0]/i[1] for i in smallest_two_ff])
+    nn_ratio_rf = np.array([i[0]/i[1] for i in smallest_two_rf])
+    nn_fifth_perc_rr = np.percentile(nn_ratio_rr,5)
+    nn_fifth_perc_ff = np.percentile(nn_ratio_ff,5)
+    nn_fifth_perc_rf = np.percentile(nn_ratio_rf,5)
+
+    min_dist_rf = np.array([i[0] for i in smallest_two_rf])
+    fifth_perc_rf = np.percentile(min_dist_rf,5)
+    min_dist_rr = np.array([i[0] for i in smallest_two_rr])
+    fifth_perc_rr = np.percentile(min_dist_rr,5)
+    min_dist_ff = np.array([i[0] for i in smallest_two_ff])
+    fifth_perc_ff = np.percentile(min_dist_ff,5)
+    
+    return np.array([fifth_perc_rf,fifth_perc_rr,fifth_perc_ff,nn_fifth_perc_rf,nn_fifth_perc_rr,nn_fifth_perc_ff]).reshape(1,6)    

syntheticFail/c16/tabddpm/tabddpm-c16-20260510_223930/_tabddpm_runtime/CTAB-GAN-Plus/model/pipeline/data_preparation.py

@@ -0,0 +1,131 @@
+import numpy as np
+import pandas as pd
+from sklearn import preprocessing
+from sklearn import model_selection
+
+class DataPrep(object):
+  
+    def __init__(self, raw_df: pd.DataFrame, categorical: list, log:list, mixed:dict, general:list, non_categorical:list, integer:list, type:dict, test_ratio:float):
+        
+        
+        self.categorical_columns = categorical
+        self.log_columns = log
+        self.mixed_columns = mixed
+        self.general_columns = general
+        self.non_categorical_columns = non_categorical
+        self.integer_columns = integer
+        self.column_types = dict()
+        self.column_types["categorical"] = []
+        self.column_types["mixed"] = {}
+        self.column_types["general"] = []
+        self.column_types["non_categorical"] = []
+        self.lower_bounds = {}
+        self.label_encoder_list = []
+        
+        target_col = list(type.values())[0]
+        if target_col is not None:
+            y_real = raw_df[target_col]
+            X_real = raw_df.drop(columns=[target_col])
+            # X_train_real, _, y_train_real, _ = model_selection.train_test_split(X_real ,y_real, test_size=test_ratio, stratify=y_real,random_state=42)
+            X_train_real, y_train_real = X_real, y_real
+        
+            X_train_real[target_col]= y_train_real
+
+            self.df = X_train_real
+        else:
+            self.df = raw_df
+
+        self.df = self.df.replace(r' ', np.nan)
+        self.df = self.df.fillna('empty')
+       
+        all_columns= set(self.df.columns)
+        irrelevant_missing_columns = set(self.categorical_columns)
+        relevant_missing_columns = list(all_columns - irrelevant_missing_columns)
+        
+        for i in relevant_missing_columns:
+            if i in self.log_columns:
+                if "empty" in list(self.df[i].values):
+                    self.df[i] = self.df[i].apply(lambda x: -9999999 if x=="empty" else x)
+                    self.mixed_columns[i] = [-9999999]
+            elif i in list(self.mixed_columns.keys()):
+                if "empty" in list(self.df[i].values):
+                    self.df[i] = self.df[i].apply(lambda x: -9999999 if x=="empty" else x )
+                    self.mixed_columns[i].append(-9999999)
+            else:
+                if "empty" in list(self.df[i].values):   
+                    self.df[i] = self.df[i].apply(lambda x: -9999999 if x=="empty" else x)
+                    self.mixed_columns[i] = [-9999999]
+        
+        if self.log_columns:
+            for log_column in self.log_columns:
+                valid_indices = []
+                for idx,val in enumerate(self.df[log_column].values):
+                    if val!=-9999999:
+                        valid_indices.append(idx)
+                eps = 1
+                lower = np.min(self.df[log_column].iloc[valid_indices].values)
+                self.lower_bounds[log_column] = lower
+                if lower>0: 
+                    self.df[log_column] = self.df[log_column].apply(lambda x: np.log(x) if x!=-9999999 else -9999999)
+                elif lower == 0:
+                    self.df[log_column] = self.df[log_column].apply(lambda x: np.log(x+eps) if x!=-9999999 else -9999999) 
+                else:
+                    self.df[log_column] = self.df[log_column].apply(lambda x: np.log(x-lower+eps) if x!=-9999999 else -9999999)
+
+        for column_index, column in enumerate(self.df.columns):            
+            if column in self.categorical_columns:        
+                label_encoder = preprocessing.LabelEncoder()
+                self.df[column] = self.df[column].astype(str)
+                label_encoder.fit(self.df[column])
+                current_label_encoder = dict()
+                current_label_encoder['column'] = column
+                current_label_encoder['label_encoder'] = label_encoder
+                transformed_column = label_encoder.transform(self.df[column])
+                self.df[column] = transformed_column
+                self.label_encoder_list.append(current_label_encoder)
+                self.column_types["categorical"].append(column_index)
+
+                if column in self.general_columns:
+                    self.column_types["general"].append(column_index)
+            
+                if column in self.non_categorical_columns:
+                    self.column_types["non_categorical"].append(column_index)
+            
+            elif column in self.mixed_columns:
+                self.column_types["mixed"][column_index] = self.mixed_columns[column]
+            
+            elif column in self.general_columns:
+                self.column_types["general"].append(column_index)
+            
+
+        super().__init__()
+        
+    def inverse_prep(self, data, eps=1):
+        
+        df_sample = pd.DataFrame(data,columns=self.df.columns)
+     
+        for i in range(len(self.label_encoder_list)):
+            le = self.label_encoder_list[i]["label_encoder"]
+            df_sample[self.label_encoder_list[i]["column"]] = df_sample[self.label_encoder_list[i]["column"]].astype(int)
+            df_sample[self.label_encoder_list[i]["column"]] = le.inverse_transform(df_sample[self.label_encoder_list[i]["column"]])
+
+        if self.log_columns:
+            for i in df_sample:
+                if i in self.log_columns:
+                    lower_bound = self.lower_bounds[i]
+                    if lower_bound>0:
+                        df_sample[i].apply(lambda x: np.exp(x)) 
+                    elif lower_bound==0:
+                        df_sample[i] = df_sample[i].apply(lambda x: np.ceil(np.exp(x)-eps) if (np.exp(x)-eps) < 0 else (np.exp(x)-eps))
+                    else: 
+                        df_sample[i] = df_sample[i].apply(lambda x: np.exp(x)-eps+lower_bound)
+
+        if self.integer_columns:
+            for column in self.integer_columns:
+                df_sample[column]= (np.round(df_sample[column].values))
+                df_sample[column] = df_sample[column].astype(int)
+
+        df_sample.replace(-9999999, np.nan,inplace=True)
+        df_sample.replace('empty', np.nan,inplace=True)
+
+        return df_sample

syntheticFail/c16/tabddpm/tabddpm-c16-20260510_223930/_tabddpm_runtime/CTAB-GAN-Plus/model/privacy_utils/rdp_accountant.py

@@ -0,0 +1,280 @@
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import math
+import sys
+
+import numpy as np
+from scipy import special
+import six
+
+########################
+# LOG-SPACE ARITHMETIC #
+########################
+
+
+def _log_add(logx, logy):
+  """Add two numbers in the log space."""
+  a, b = min(logx, logy), max(logx, logy)
+  if a == -np.inf:  # adding 0
+    return b
+  # Use exp(a) + exp(b) = (exp(a - b) + 1) * exp(b)
+  return math.log1p(math.exp(a - b)) + b  # log1p(x) = log(x + 1)
+
+
+def _log_sub(logx, logy):
+  """Subtract two numbers in the log space. Answer must be non-negative."""
+  if logx < logy:
+    raise ValueError("The result of subtraction must be non-negative.")
+  if logy == -np.inf:  # subtracting 0
+    return logx
+  if logx == logy:
+    return -np.inf  # 0 is represented as -np.inf in the log space.
+
+  try:
+    # Use exp(x) - exp(y) = (exp(x - y) - 1) * exp(y).
+    return math.log(math.expm1(logx - logy)) + logy  # expm1(x) = exp(x) - 1
+  except OverflowError:
+    return logx
+
+
+def _log_print(logx):
+  """Pretty print."""
+  if logx < math.log(sys.float_info.max):
+    return "{}".format(math.exp(logx))
+  else:
+    return "exp({})".format(logx)
+
+
+def _compute_log_a_int(q, sigma, alpha):
+  """Compute log(A_alpha) for integer alpha. 0 < q < 1."""
+  assert isinstance(alpha, six.integer_types)
+
+  # Initialize with 0 in the log space.
+  log_a = -np.inf
+
+  for i in range(alpha + 1):
+    log_coef_i = (
+        math.log(special.binom(alpha, i)) + i * math.log(q) +
+        (alpha - i) * math.log(1 - q))
+
+    s = log_coef_i + (i * i - i) / (2 * (sigma**2))
+    log_a = _log_add(log_a, s)
+
+  return float(log_a)
+
+
+def _compute_log_a_frac(q, sigma, alpha):
+  """Compute log(A_alpha) for fractional alpha. 0 < q < 1."""
+  # The two parts of A_alpha, integrals over (-inf,z0] and [z0, +inf), are
+  # initialized to 0 in the log space:
+  log_a0, log_a1 = -np.inf, -np.inf
+  i = 0
+
+  z0 = sigma**2 * math.log(1 / q - 1) + .5
+
+  while True:  # do ... until loop
+    coef = special.binom(alpha, i)
+    log_coef = math.log(abs(coef))
+    j = alpha - i
+
+    log_t0 = log_coef + i * math.log(q) + j * math.log(1 - q)
+    log_t1 = log_coef + j * math.log(q) + i * math.log(1 - q)
+
+    log_e0 = math.log(.5) + _log_erfc((i - z0) / (math.sqrt(2) * sigma))
+    log_e1 = math.log(.5) + _log_erfc((z0 - j) / (math.sqrt(2) * sigma))
+
+    log_s0 = log_t0 + (i * i - i) / (2 * (sigma**2)) + log_e0
+    log_s1 = log_t1 + (j * j - j) / (2 * (sigma**2)) + log_e1
+
+    if coef > 0:
+      log_a0 = _log_add(log_a0, log_s0)
+      log_a1 = _log_add(log_a1, log_s1)
+    else:
+      log_a0 = _log_sub(log_a0, log_s0)
+      log_a1 = _log_sub(log_a1, log_s1)
+
+    i += 1
+    if max(log_s0, log_s1) < -30:
+      break
+
+  return _log_add(log_a0, log_a1)
+
+
+def _compute_log_a(q, sigma, alpha):
+  """Compute log(A_alpha) for any positive finite alpha."""
+  if float(alpha).is_integer():
+    return _compute_log_a_int(q, sigma, int(alpha))
+  else:
+    return _compute_log_a_frac(q, sigma, alpha)
+
+
+def _log_erfc(x):
+  """Compute log(erfc(x)) with high accuracy for large x."""
+  try:
+    return math.log(2) + special.log_ndtr(-x * 2**.5)
+  except NameError:
+    # If log_ndtr is not available, approximate as follows:
+    r = special.erfc(x)
+    if r == 0.0:
+      # Using the Laurent series at infinity for the tail of the erfc function:
+      #     erfc(x) ~ exp(-x^2-.5/x^2+.625/x^4)/(x*pi^.5)
+      # To verify in Mathematica:
+      #     Series[Log[Erfc[x]] + Log[x] + Log[Pi]/2 + x^2, {x, Infinity, 6}]
+      return (-math.log(math.pi) / 2 - math.log(x) - x**2 - .5 * x**-2 +
+              .625 * x**-4 - 37. / 24. * x**-6 + 353. / 64. * x**-8)
+    else:
+      return math.log(r)
+
+
+def _compute_delta(orders, rdp, eps):
+  """Compute delta given a list of RDP values and target epsilon.
+
+  Args:
+    orders: An array (or a scalar) of orders.
+    rdp: A list (or a scalar) of RDP guarantees.
+    eps: The target epsilon.
+
+  Returns:
+    Pair of (delta, optimal_order).
+
+  Raises:
+    ValueError: If input is malformed.
+
+  """
+  orders_vec = np.atleast_1d(orders)
+  rdp_vec = np.atleast_1d(rdp)
+
+  if len(orders_vec) != len(rdp_vec):
+    raise ValueError("Input lists must have the same length.")
+
+  deltas = np.exp((rdp_vec - eps) * (orders_vec - 1))
+  idx_opt = np.argmin(deltas)
+  return min(deltas[idx_opt], 1.), orders_vec[idx_opt]
+
+
+def _compute_eps(orders, rdp, delta):
+  """Compute epsilon given a list of RDP values and target delta.
+
+  Args:
+    orders: An array (or a scalar) of orders.
+    rdp: A list (or a scalar) of RDP guarantees.
+    delta: The target delta.
+
+  Returns:
+    Pair of (eps, optimal_order).
+
+  Raises:
+    ValueError: If input is malformed.
+
+  """
+  orders_vec = np.atleast_1d(orders)
+  rdp_vec = np.atleast_1d(rdp)
+
+  if len(orders_vec) != len(rdp_vec):
+    raise ValueError("Input lists must have the same length.")
+
+  eps = rdp_vec - math.log(delta) / (orders_vec - 1)
+
+  idx_opt = np.nanargmin(eps)  # Ignore NaNs
+  return eps[idx_opt], orders_vec[idx_opt]
+
+
+def _compute_rdp(q, sigma, alpha):
+  """Compute RDP of the Sampled Gaussian mechanism at order alpha.
+
+  Args:
+    q: The sampling rate.
+    sigma: The std of the additive Gaussian noise.
+    alpha: The order at which RDP is computed.
+
+  Returns:
+    RDP at alpha, can be np.inf.
+  """
+  if q == 0:
+    return 0
+
+  if q == 1.:
+    return alpha / (2 * sigma**2)
+
+  if np.isinf(alpha):
+    return np.inf
+
+  return _compute_log_a(q, sigma, alpha) / (alpha - 1)
+
+
+def compute_rdp(q, noise_multiplier, steps, orders):
+  """Compute RDP of the Sampled Gaussian Mechanism.
+
+  Args:
+    q: The sampling rate.
+    noise_multiplier: The ratio of the standard deviation of the Gaussian noise
+        to the l2-sensitivity of the function to which it is added.
+    steps: The number of steps.
+    orders: An array (or a scalar) of RDP orders.
+
+  Returns:
+    The RDPs at all orders, can be np.inf.
+  """
+  if np.isscalar(orders):
+    rdp = _compute_rdp(q, noise_multiplier, orders)
+  else:
+    rdp = np.array([_compute_rdp(q, noise_multiplier, order)
+                    for order in orders])
+
+  return rdp * steps
+
+
+def get_privacy_spent(orders, rdp, target_eps=None, target_delta=None):
+  """Compute delta (or eps) for given eps (or delta) from RDP values.
+
+  Args:
+    orders: An array (or a scalar) of RDP orders.
+    rdp: An array of RDP values. Must be of the same length as the orders list.
+    target_eps: If not None, the epsilon for which we compute the corresponding
+              delta.
+    target_delta: If not None, the delta for which we compute the corresponding
+              epsilon. Exactly one of target_eps and target_delta must be None.
+
+  Returns:
+    eps, delta, opt_order.
+
+  Raises:
+    ValueError: If target_eps and target_delta are messed up.
+  """
+  if target_eps is None and target_delta is None:
+    raise ValueError(
+        "Exactly one out of eps and delta must be None. (Both are).")
+
+  if target_eps is not None and target_delta is not None:
+    raise ValueError(
+        "Exactly one out of eps and delta must be None. (None is).")
+
+  if target_eps is not None:
+    delta, opt_order = _compute_delta(orders, rdp, target_eps)
+    return target_eps, delta, opt_order
+  else:
+    eps, opt_order = _compute_eps(orders, rdp, target_delta)
+    return eps, target_delta, opt_order
+
+
+def compute_rdp_from_ledger(ledger, orders):
+  """Compute RDP of Sampled Gaussian Mechanism from ledger.
+
+  Args:
+    ledger: A formatted privacy ledger.
+    orders: An array (or a scalar) of RDP orders.
+
+  Returns:
+    RDP at all orders, can be np.inf.
+  """
+  total_rdp = np.zeros_like(orders, dtype=float)
+  for sample in ledger:
+    # Compute equivalent z from l2_clip_bounds and noise stddevs in sample.
+    # See https://arxiv.org/pdf/1812.06210.pdf for derivation of this formula.
+    effective_z = sum([
+        (q.noise_stddev / q.l2_norm_bound)**-2 for q in sample.queries])**-0.5
+    total_rdp += compute_rdp(
+        sample.selection_probability, effective_z, 1, orders)
+  return total_rdp

syntheticFail/c16/tabddpm/tabddpm-c16-20260510_223930/_tabddpm_runtime/CTAB-GAN-Plus/model/synthesizer/ctabgan_synthesizer.py

@@ -0,0 +1,605 @@
+import numpy as np
+import pandas as pd
+import torch
+import torch.utils.data
+import torch.optim as optim
+from torch.optim import Adam
+from torch.nn import functional as F
+from torch.nn import (Dropout, LeakyReLU, Linear, Module, ReLU, Sequential,
+Conv2d, ConvTranspose2d, Sigmoid, init, BCELoss, CrossEntropyLoss,SmoothL1Loss,LayerNorm)
+from model.synthesizer.transformer import ImageTransformer,DataTransformer
+from model.privacy_utils.rdp_accountant import compute_rdp, get_privacy_spent
+from tqdm import tqdm, trange
+import time
+
+
+class Classifier(Module):
+    def __init__(self,input_dim, dis_dims,st_ed):
+        super(Classifier,self).__init__()
+        dim = input_dim-(st_ed[1]-st_ed[0])
+        seq = []
+        self.str_end = st_ed
+        for item in list(dis_dims):
+            seq += [
+                Linear(dim, item),
+                LeakyReLU(0.2),
+                Dropout(0.5)
+            ]
+            dim = item
+        
+        if (st_ed[1]-st_ed[0])==1:
+            seq += [Linear(dim, 1)]
+        
+        elif (st_ed[1]-st_ed[0])==2:
+            seq += [Linear(dim, 1),Sigmoid()]
+        else:
+            seq += [Linear(dim,(st_ed[1]-st_ed[0]))] 
+        
+        self.seq = Sequential(*seq)
+
+    def forward(self, input):
+        
+        label=None
+        
+        if (self.str_end[1]-self.str_end[0])==1:
+            label = input[:, self.str_end[0]:self.str_end[1]]
+        else:
+            label = torch.argmax(input[:, self.str_end[0]:self.str_end[1]], axis=-1)
+        
+        new_imp = torch.cat((input[:,:self.str_end[0]],input[:,self.str_end[1]:]),1)
+        
+        if ((self.str_end[1]-self.str_end[0])==2) | ((self.str_end[1]-self.str_end[0])==1):
+            return self.seq(new_imp).view(-1), label
+        else:
+            return self.seq(new_imp), label
+
+def apply_activate(data, output_info):
+    data_t = []
+    st = 0
+    for item in output_info:
+        if item[1] == 'tanh':
+            ed = st + item[0]
+            data_t.append(torch.tanh(data[:, st:ed]))
+            st = ed
+        elif item[1] == 'softmax':
+            ed = st + item[0]
+            data_t.append(F.gumbel_softmax(data[:, st:ed], tau=0.2))
+            st = ed
+    return torch.cat(data_t, dim=1)
+
+def get_st_ed(target_col_index,output_info):
+    st = 0
+    c= 0
+    tc= 0
+
+    for item in output_info:
+        if c==target_col_index:
+            break
+        if item[1]=='tanh':
+            st += item[0]
+            if item[2] == 'yes_g':
+                c+=1
+        elif item[1] == 'softmax':
+            st += item[0]
+            c+=1
+        tc+=1    
+    
+    ed= st+output_info[tc][0] 
+
+    return (st,ed)
+
+def random_choice_prob_index_sampling(probs,col_idx):
+    option_list = []
+    for i in col_idx:
+        pp = probs[i]
+        option_list.append(np.random.choice(np.arange(len(probs[i])), p=pp))
+    
+    return np.array(option_list).reshape(col_idx.shape)
+
+def random_choice_prob_index(a, axis=1):
+    r = np.expand_dims(np.random.rand(a.shape[1 - axis]), axis=axis)
+    return (a.cumsum(axis=axis) > r).argmax(axis=axis)
+
+def maximum_interval(output_info):
+    max_interval = 0
+    for item in output_info:
+        max_interval = max(max_interval, item[0])
+    return max_interval
+
+class Cond(object):
+    def __init__(self, data, output_info):
+       
+        self.model = []
+        st = 0
+        counter = 0
+        for item in output_info:
+           
+            if item[1] == 'tanh':
+                st += item[0]
+                continue
+            elif item[1] == 'softmax':
+                ed = st + item[0]
+                counter += 1
+                self.model.append(np.argmax(data[:, st:ed], axis=-1))
+                st = ed
+            
+        self.interval = []
+        self.n_col = 0  
+        self.n_opt = 0  
+        st = 0
+        self.p = np.zeros((counter, maximum_interval(output_info)))  
+        self.p_sampling = []
+        for item in output_info:
+            if item[1] == 'tanh':
+                st += item[0]
+                continue
+            elif item[1] == 'softmax': 
+                ed = st + item[0]
+                tmp = np.sum(data[:, st:ed], axis=0)  
+                tmp_sampling = np.sum(data[:, st:ed], axis=0)     
+                tmp = np.log(tmp + 1)  
+                tmp = tmp / np.sum(tmp) 
+                tmp_sampling = tmp_sampling / np.sum(tmp_sampling)
+                self.p_sampling.append(tmp_sampling)
+                self.p[self.n_col, :item[0]] = tmp 
+                self.interval.append((self.n_opt, item[0]))
+                self.n_opt += item[0]
+                self.n_col += 1
+                st = ed
+                
+        self.interval = np.asarray(self.interval)
+        
+    def sample_train(self, batch):
+        if self.n_col == 0:
+            return None
+        batch = batch
+
+        idx = np.random.choice(np.arange(self.n_col), batch)
+
+        vec = np.zeros((batch, self.n_opt), dtype='float32')
+        mask = np.zeros((batch, self.n_col), dtype='float32')
+        mask[np.arange(batch), idx] = 1  
+        opt1prime = random_choice_prob_index(self.p[idx]) 
+        for i in np.arange(batch):
+            vec[i, self.interval[idx[i], 0] + opt1prime[i]] = 1
+            
+        return vec, mask, idx, opt1prime
+
+    def sample(self, batch):
+        if self.n_col == 0:
+            return None
+        batch = batch
+      
+        idx = np.random.choice(np.arange(self.n_col), batch)
+
+        vec = np.zeros((batch, self.n_opt), dtype='float32')
+        opt1prime = random_choice_prob_index_sampling(self.p_sampling,idx)
+        
+        for i in np.arange(batch):
+            vec[i, self.interval[idx[i], 0] + opt1prime[i]] = 1
+            
+        return vec
+
+def cond_loss(data, output_info, c, m):
+    loss = []
+    st = 0
+    st_c = 0
+    for item in output_info:
+        if item[1] == 'tanh':
+            st += item[0]
+            continue
+
+        elif item[1] == 'softmax':
+            ed = st + item[0]
+            ed_c = st_c + item[0]
+            tmp = F.cross_entropy(
+            data[:, st:ed],
+            torch.argmax(c[:, st_c:ed_c], dim=1),
+            reduction='none')
+            loss.append(tmp)
+            st = ed
+            st_c = ed_c
+
+    loss = torch.stack(loss, dim=1)
+    return (loss * m).sum() / data.size()[0]
+
+class Sampler(object):
+    def __init__(self, data, output_info):
+        super(Sampler, self).__init__()
+        self.data = data
+        self.model = []
+        self.n = len(data)
+        st = 0
+        for item in output_info:
+            if item[1] == 'tanh':
+                st += item[0]
+                continue
+            elif item[1] == 'softmax':
+                ed = st + item[0]
+                tmp = []
+                for j in range(item[0]):
+                    tmp.append(np.nonzero(data[:, st + j])[0])
+                self.model.append(tmp)
+                st = ed
+                
+    def sample(self, n, col, opt):
+        if col is None:
+            idx = np.random.choice(np.arange(self.n), n)
+            return self.data[idx]
+        idx = []
+        for c, o in zip(col, opt):
+            idx.append(np.random.choice(self.model[c][o]))
+        return self.data[idx]
+
+class Discriminator(Module):
+    def __init__(self, side, layers):
+        super(Discriminator, self).__init__()
+        self.side = side
+        info = len(layers)-2
+        self.seq = Sequential(*layers)
+        self.seq_info = Sequential(*layers[:info])
+
+    def forward(self, input):
+        return (self.seq(input)), self.seq_info(input)
+
+class Generator(Module):
+    def __init__(self, side, layers):
+        super(Generator, self).__init__()
+        self.side = side
+        self.seq = Sequential(*layers)
+
+    def forward(self, input_):
+        return self.seq(input_)
+
+def determine_layers_disc(side, num_channels):
+    assert side >= 4 and side <= 64
+
+    layer_dims = [(1, side), (num_channels, side // 2)]
+
+    while layer_dims[-1][1] > 3 and len(layer_dims) < 4:
+        layer_dims.append((layer_dims[-1][0] * 2, layer_dims[-1][1] // 2))
+
+    layerNorms = []
+    num_c = num_channels
+    num_s = side / 2
+    for l in range(len(layer_dims) - 1):
+        layerNorms.append([int(num_c), int(num_s), int(num_s)])
+        num_c = num_c * 2
+        num_s = num_s / 2
+
+    layers_D = []
+
+    for prev, curr, ln in zip(layer_dims, layer_dims[1:], layerNorms):
+        layers_D += [
+            Conv2d(prev[0], curr[0], 4, 2, 1, bias=False),
+            LayerNorm(ln),
+            LeakyReLU(0.2, inplace=True),
+        ]
+
+    layers_D += [Conv2d(layer_dims[-1][0], 1, layer_dims[-1][1], 1, 0), ReLU(True)] 
+
+    return layers_D
+
+def determine_layers_gen(side, random_dim, num_channels):
+    assert side >= 4 and side <= 64
+
+    layer_dims = [(1, side), (num_channels, side // 2)]
+
+    while layer_dims[-1][1] > 3 and len(layer_dims) < 4:
+        layer_dims.append((layer_dims[-1][0] * 2, layer_dims[-1][1] // 2))
+
+    layerNorms = []
+
+    num_c = num_channels * (2 ** (len(layer_dims) - 2))
+    num_s = int(side / (2 ** (len(layer_dims) - 1)))
+    for l in range(len(layer_dims) - 1):
+        layerNorms.append([int(num_c), int(num_s), int(num_s)])
+        num_c = num_c / 2
+        num_s = num_s * 2
+
+    layers_G = [ConvTranspose2d(random_dim, layer_dims[-1][0], layer_dims[-1][1], 1, 0, output_padding=0, bias=False)]
+
+    for prev, curr, ln in zip(reversed(layer_dims), reversed(layer_dims[:-1]), layerNorms):
+        layers_G += [LayerNorm(ln), ReLU(True), ConvTranspose2d(prev[0], curr[0], 4, 2, 1, output_padding=0, bias=True)]
+    return layers_G
+
+def slerp(val, low, high):
+    low_norm = low/torch.norm(low, dim=1, keepdim=True)
+    high_norm = high/torch.norm(high, dim=1, keepdim=True)
+    omega = torch.acos((low_norm*high_norm).sum(1)).view(val.size(0), 1)
+    so = torch.sin(omega)
+    res = (torch.sin((1.0-val)*omega)/so)*low + (torch.sin(val*omega)/so) * high
+    
+    return res
+
+def calc_gradient_penalty_slerp(netD, real_data, fake_data, transformer, device='cpu', lambda_=10):
+    batchsize = real_data.shape[0]
+    alpha = torch.rand(batchsize, 1,  device=device)
+    interpolates = slerp(alpha, real_data, fake_data)
+    interpolates = interpolates.to(device)
+    interpolates = transformer.transform(interpolates)
+    interpolates = torch.autograd.Variable(interpolates, requires_grad=True)
+    disc_interpolates,_ = netD(interpolates) 
+
+    gradients = torch.autograd.grad(outputs=disc_interpolates, inputs=interpolates,
+                                  grad_outputs=torch.ones(disc_interpolates.size()).to(device),
+                                  create_graph=True, retain_graph=True, only_inputs=True)[0] 
+    
+    gradients_norm = gradients.norm(2, dim=1)
+    gradient_penalty = ((gradients_norm - 1) ** 2).mean() * lambda_
+    
+    return gradient_penalty
+
+def weights_init(m):
+    classname = m.__class__.__name__
+    
+    if classname.find('Conv') != -1:
+        init.normal_(m.weight.data, 0.0, 0.02)
+
+    elif classname.find('BatchNorm') != -1:
+        init.normal_(m.weight.data, 1.0, 0.02)
+        init.constant_(m.bias.data, 0)
+
+class CTABGANSynthesizer:
+    def __init__(self,
+                 class_dim=(256, 256, 256, 256),
+                 random_dim=100,
+                 num_channels=64,
+                 l2scale=1e-5,
+                 batch_size=500,
+                 epochs=150,
+                 lr=2e-4,
+                 device="cpu"):
+                 
+
+        self.random_dim = random_dim
+        self.class_dim = class_dim
+        self.num_channels = num_channels
+        self.dside = None
+        self.gside = None
+        self.l2scale = l2scale
+        self.lr = lr
+        self.batch_size = batch_size
+        self.epochs = epochs
+        self.device = torch.device(device)
+
+    def fit(self, train_data=pd.DataFrame, categorical=[], mixed={}, general=[], non_categorical=[], type={}):
+
+        problem_type = None
+        target_index=None
+        if type:
+            problem_type = list(type.keys())[0]
+            if problem_type:
+                target_index = train_data.columns.get_loc(type[problem_type])
+
+        self.transformer = DataTransformer(train_data=train_data, categorical_list=categorical, mixed_dict=mixed, general_list=general, non_categorical_list=non_categorical)
+        self.transformer.fit() 
+        train_data = self.transformer.transform(train_data.values)
+        data_sampler = Sampler(train_data, self.transformer.output_info)
+        data_dim = self.transformer.output_dim
+        self.cond_generator = Cond(train_data, self.transformer.output_info)
+        		
+        sides = [4, 8, 16, 24, 32]
+        col_size_d = data_dim + self.cond_generator.n_opt
+        for i in sides:
+            if i * i >= col_size_d:
+                self.dside = i
+                break
+        
+        sides = [4, 8, 16, 24, 32]
+        col_size_g = data_dim
+        for i in sides:
+            if i * i >= col_size_g:
+                self.gside = i
+                break
+		
+
+        layers_G = determine_layers_gen(self.gside, self.random_dim+self.cond_generator.n_opt, self.num_channels)
+        layers_D = determine_layers_disc(self.dside, self.num_channels)
+        
+        self.generator = Generator(self.gside, layers_G).to(self.device)
+        discriminator = Discriminator(self.dside, layers_D).to(self.device)
+        optimizer_params = dict(lr=self.lr, betas=(0.5, 0.9), eps=1e-3, weight_decay=self.l2scale)
+        optimizerG = Adam(self.generator.parameters(), **optimizer_params)
+        optimizerD = Adam(discriminator.parameters(), **optimizer_params)
+
+        st_ed = None
+        classifier=None
+        optimizerC= None
+        if target_index != None:
+            st_ed= get_st_ed(target_index,self.transformer.output_info)
+            classifier = Classifier(data_dim,self.class_dim,st_ed).to(self.device)
+            optimizerC = optim.Adam(classifier.parameters(),**optimizer_params)
+        
+        
+        self.generator.apply(weights_init)
+        discriminator.apply(weights_init)
+
+        self.Gtransformer = ImageTransformer(self.gside)       
+        self.Dtransformer = ImageTransformer(self.dside)
+        
+        epsilon = 0
+        epoch = 0
+        steps = 0
+        ci = 1
+        
+        for i in tqdm(range(self.epochs)):
+				
+            
+            for _ in range(ci):
+                noisez = torch.randn(self.batch_size, self.random_dim, device=self.device)
+                condvec = self.cond_generator.sample_train(self.batch_size)
+
+                c, m, col, opt = condvec
+                c = torch.from_numpy(c).to(self.device)
+                m = torch.from_numpy(m).to(self.device)
+                noisez = torch.cat([noisez, c], dim=1)
+                noisez =  noisez.view(self.batch_size,self.random_dim+self.cond_generator.n_opt,1,1)
+                
+                perm = np.arange(self.batch_size)
+                np.random.shuffle(perm)
+                real = data_sampler.sample(self.batch_size, col[perm], opt[perm])
+                c_perm = c[perm]
+                
+                real = torch.from_numpy(real.astype('float32')).to(self.device)
+                
+                fake = self.generator(noisez)
+                faket = self.Gtransformer.inverse_transform(fake)
+                fakeact = apply_activate(faket, self.transformer.output_info)
+                
+                fake_cat = torch.cat([fakeact, c], dim=1)
+                real_cat = torch.cat([real, c_perm], dim=1)
+                
+                real_cat_d = self.Dtransformer.transform(real_cat)
+                fake_cat_d = self.Dtransformer.transform(fake_cat)
+                
+                optimizerD.zero_grad()
+                
+                d_real,_ = discriminator(real_cat_d)
+                
+
+                d_real = -torch.mean(d_real)
+                d_real.backward() 
+                
+
+                d_fake,_ = discriminator(fake_cat_d)
+                
+                d_fake = torch.mean(d_fake)
+
+                d_fake.backward() 
+                
+                pen = calc_gradient_penalty_slerp(discriminator, real_cat, fake_cat,  self.Dtransformer , self.device)
+
+                pen.backward()
+            
+                optimizerD.step()
+                
+            noisez = torch.randn(self.batch_size, self.random_dim, device=self.device)
+            
+            condvec = self.cond_generator.sample_train(self.batch_size)
+
+            c, m, col, opt = condvec
+            c = torch.from_numpy(c).to(self.device)
+            m = torch.from_numpy(m).to(self.device)
+            noisez = torch.cat([noisez, c], dim=1)
+            noisez =  noisez.view(self.batch_size,self.random_dim+self.cond_generator.n_opt,1,1)
+
+            optimizerG.zero_grad()
+
+            fake = self.generator(noisez)
+            faket = self.Gtransformer.inverse_transform(fake)
+            fakeact = apply_activate(faket, self.transformer.output_info)
+
+            fake_cat = torch.cat([fakeact, c], dim=1) 
+            fake_cat = self.Dtransformer.transform(fake_cat)
+                
+            y_fake,info_fake = discriminator(fake_cat)
+            
+            cross_entropy = cond_loss(faket, self.transformer.output_info, c, m)
+
+            _,info_real = discriminator(real_cat_d)
+            
+
+            g = -torch.mean(y_fake) + cross_entropy
+            g.backward(retain_graph=True)
+            loss_mean = torch.norm(torch.mean(info_fake.view(self.batch_size,-1), dim=0) - torch.mean(info_real.view(self.batch_size,-1), dim=0), 1)
+            loss_std = torch.norm(torch.std(info_fake.view(self.batch_size,-1), dim=0) - torch.std(info_real.view(self.batch_size,-1), dim=0), 1)
+            loss_info = loss_mean + loss_std 
+            loss_info.backward()
+            optimizerG.step()
+
+
+            if problem_type:
+                        
+                fake = self.generator(noisez)
+                
+                faket = self.Gtransformer.inverse_transform(fake)
+                
+                fakeact = apply_activate(faket, self.transformer.output_info)
+                
+                real_pre, real_label = classifier(real)
+                fake_pre, fake_label = classifier(fakeact)
+                    
+                c_loss = CrossEntropyLoss() 
+                
+                if (st_ed[1] - st_ed[0])==1:
+                    c_loss= SmoothL1Loss()
+                    real_label = real_label.type_as(real_pre)
+                    fake_label = fake_label.type_as(fake_pre)
+                    real_label = torch.reshape(real_label,real_pre.size())
+                    fake_label = torch.reshape(fake_label,fake_pre.size())
+                    
+                
+                elif (st_ed[1] - st_ed[0])==2:
+                    c_loss = BCELoss()
+                    real_label = real_label.type_as(real_pre)
+                    fake_label = fake_label.type_as(fake_pre)
+
+                loss_cc = c_loss(real_pre, real_label)
+                loss_cg = c_loss(fake_pre, fake_label)
+
+                optimizerG.zero_grad()
+                loss_cg.backward()
+                optimizerG.step()
+
+                optimizerC.zero_grad()
+                loss_cc.backward()
+                optimizerC.step()
+                            
+
+            
+   
+    @torch.no_grad()
+    def sample(self, n, seed=0):
+        print(n)
+        torch.manual_seed(seed)
+        torch.cuda.manual_seed(seed)
+        sample_batch_size = 8092
+        self.generator.eval()
+
+        output_info = self.transformer.output_info
+        steps = n // sample_batch_size + 1
+
+        data = []
+        
+        for i in range(steps):
+            noisez = torch.randn(sample_batch_size, self.random_dim, device=self.device)
+            condvec = self.cond_generator.sample(sample_batch_size)
+            c = condvec
+            c = torch.from_numpy(c).to(self.device)
+            noisez = torch.cat([noisez, c], dim=1)
+            noisez =  noisez.view(sample_batch_size,self.random_dim+self.cond_generator.n_opt,1,1)
+                
+            fake = self.generator(noisez)
+            faket = self.Gtransformer.inverse_transform(fake)
+            fakeact = apply_activate(faket,output_info)
+            data.append(fakeact.detach().cpu().numpy())
+
+        data = np.concatenate(data, axis=0)
+        result,resample = self.transformer.inverse_transform(data)
+
+        t0 = time.time()
+        while len(result) < n and (time.time() - t0) <= 600:
+            data_resample = []    
+            steps_left = resample// sample_batch_size + 1
+            # print(f"Sampling: {len(result)}/{n}")
+            for i in range(steps_left):
+                noisez = torch.randn(sample_batch_size, self.random_dim, device=self.device)
+                condvec = self.cond_generator.sample(sample_batch_size)
+                c = condvec
+                c = torch.from_numpy(c).to(self.device)
+                noisez = torch.cat([noisez, c], dim=1)
+                noisez =  noisez.view(sample_batch_size,self.random_dim+self.cond_generator.n_opt,1,1)
+                    
+                fake = self.generator(noisez)
+                faket = self.Gtransformer.inverse_transform(fake)
+                fakeact = apply_activate(faket, output_info)
+                data_resample.append(fakeact.detach().cpu().numpy())
+
+            data_resample = np.concatenate(data_resample, axis=0)
+
+            res,resample = self.transformer.inverse_transform(data_resample)
+            result  = np.concatenate([result,res],axis=0)
+        
+        return result[0:n]
+

syntheticFail/c16/tabddpm/tabddpm-c16-20260510_223930/_tabddpm_runtime/CTAB-GAN-Plus/model/synthesizer/transformer.py

@@ -0,0 +1,429 @@
+import numpy as np
+import pandas as pd
+import torch
+from sklearn.mixture import BayesianGaussianMixture
+
+class DataTransformer():
+    
+    def __init__(self, train_data=pd.DataFrame, categorical_list=[], mixed_dict={}, general_list=[], non_categorical_list=[], n_clusters=10, eps=0.005):
+        self.meta = None
+        self.n_clusters = n_clusters
+        self.eps = eps
+        self.train_data = train_data
+        self.categorical_columns= categorical_list
+        self.mixed_columns= mixed_dict
+        self.general_columns = general_list
+        self.non_categorical_columns= non_categorical_list
+        
+    def get_metadata(self):
+        
+        meta = []
+    
+        for index in range(self.train_data.shape[1]):
+            column = self.train_data.iloc[:,index]
+            if index in self.categorical_columns:
+                if index in self.non_categorical_columns:
+                    meta.append({
+                      "name": index,
+                      "type": "continuous",
+                      "min": column.min(),
+                      "max": column.max(),
+                    })
+                else:
+                    mapper = column.value_counts().index.tolist()
+                    meta.append({
+                        "name": index,
+                        "type": "categorical",
+                        "size": len(mapper),
+                        "i2s": mapper
+                    })
+
+            elif index in self.mixed_columns.keys():
+                meta.append({
+                    "name": index,
+                    "type": "mixed",
+                    "min": column.min(),
+                    "max": column.max(),
+                    "modal": self.mixed_columns[index]
+                })
+            else:
+                meta.append({
+                    "name": index,
+                    "type": "continuous",
+                    "min": column.min(),
+                    "max": column.max(),
+                })            
+
+        return meta
+
+    def fit(self):
+        data = self.train_data.values
+        self.meta = self.get_metadata()
+        model = []
+        self.ordering = []
+        self.output_info = []
+        self.output_dim = 0
+        self.components = []
+        self.filter_arr = []
+        for id_, info in enumerate(self.meta):
+            if info['type'] == "continuous":
+                if id_ not in self.general_columns:
+                  gm = BayesianGaussianMixture(
+                      n_components = self.n_clusters, 
+                      weight_concentration_prior_type='dirichlet_process',
+                      weight_concentration_prior=0.001, 
+                      max_iter=100,n_init=1, random_state=42)
+                  gm.fit(data[:, id_].reshape([-1, 1]))
+                  mode_freq = (pd.Series(gm.predict(data[:, id_].reshape([-1, 1]))).value_counts().keys())
+                  model.append(gm)
+                  old_comp = gm.weights_ > self.eps
+                  comp = []
+                  for i in range(self.n_clusters):
+                      if (i in (mode_freq)) & old_comp[i]:
+                          comp.append(True)
+                      else:
+                          comp.append(False)
+                  self.components.append(comp) 
+                  self.output_info += [(1, 'tanh','no_g'), (np.sum(comp), 'softmax')]
+                  self.output_dim += 1 + np.sum(comp)
+                else:
+                  model.append(None)
+                  self.components.append(None)
+                  self.output_info += [(1, 'tanh','yes_g')]
+                  self.output_dim += 1
+            
+            elif info['type'] == "mixed":
+                
+                gm1 = BayesianGaussianMixture(
+                    n_components = self.n_clusters, 
+                    weight_concentration_prior_type='dirichlet_process',
+                    weight_concentration_prior=0.001, max_iter=100,
+                    n_init=1,random_state=42)
+                gm2 = BayesianGaussianMixture(
+                    n_components = self.n_clusters,
+                    weight_concentration_prior_type='dirichlet_process',
+                    weight_concentration_prior=0.001, max_iter=100,
+                    n_init=1,random_state=42)
+                
+                gm1.fit(data[:, id_].reshape([-1, 1]))
+                
+                filter_arr = []
+                for element in data[:, id_]:
+                    if element not in info['modal']:
+                        filter_arr.append(True)
+                    else:
+                        filter_arr.append(False)
+               
+                gm2.fit(data[:, id_][filter_arr].reshape([-1, 1]))
+                mode_freq = (pd.Series(gm2.predict(data[:, id_][filter_arr].reshape([-1, 1]))).value_counts().keys())
+                self.filter_arr.append(filter_arr)
+                model.append((gm1,gm2))
+               
+                old_comp = gm2.weights_ > self.eps
+                  
+                comp = []
+                  
+                for i in range(self.n_clusters):
+                    if (i in (mode_freq)) & old_comp[i]:
+                        comp.append(True)
+                    else:
+                        comp.append(False)
+
+                self.components.append(comp)
+
+                self.output_info += [(1, 'tanh',"no_g"), (np.sum(comp) + len(info['modal']), 'softmax')]
+                self.output_dim += 1 + np.sum(comp) + len(info['modal'])
+            else:
+                model.append(None)
+                self.components.append(None)
+                self.output_info += [(info['size'], 'softmax')]
+                self.output_dim += info['size']
+        self.model = model
+
+    def transform(self, data, ispositive = False, positive_list = None):
+        values = []
+        mixed_counter = 0
+        for id_, info in enumerate(self.meta):
+            current = data[:, id_]
+            if info['type'] == "continuous":
+                if id_ not in self.general_columns: 
+                  current = current.reshape([-1, 1])
+                  means = self.model[id_].means_.reshape((1, self.n_clusters))
+                  stds = np.sqrt(self.model[id_].covariances_).reshape((1, self.n_clusters))
+                  features = np.empty(shape=(len(current),self.n_clusters))
+                  if ispositive == True:
+                      if id_ in positive_list:
+                          features = np.abs(current - means) / (4 * stds)
+                  else:
+                      features = (current - means) / (4 * stds)
+
+                  probs = self.model[id_].predict_proba(current.reshape([-1, 1]))
+                  n_opts = sum(self.components[id_])
+                  features = features[:, self.components[id_]]
+                  probs = probs[:, self.components[id_]]
+
+                  opt_sel = np.zeros(len(data), dtype='int')
+                  for i in range(len(data)):
+                      pp = probs[i] + 1e-6
+                      pp = pp / sum(pp)
+                      opt_sel[i] = np.random.choice(np.arange(n_opts), p=pp)
+
+                  idx = np.arange((len(features)))
+                  features = features[idx, opt_sel].reshape([-1, 1])
+                  features = np.clip(features, -.99, .99) 
+                  probs_onehot = np.zeros_like(probs)
+                  probs_onehot[np.arange(len(probs)), opt_sel] = 1
+
+                  re_ordered_phot = np.zeros_like(probs_onehot)
+                  
+                  col_sums = probs_onehot.sum(axis=0)
+                  
+
+                  n = probs_onehot.shape[1]
+                  largest_indices = np.argsort(-1*col_sums)[:n]
+                  self.ordering.append(largest_indices)
+                  for id,val in enumerate(largest_indices):
+                      re_ordered_phot[:,id] = probs_onehot[:,val]
+                
+                  
+                  values += [features, re_ordered_phot]
+                  
+                else:
+                  
+                  self.ordering.append(None)
+                  
+                  if id_ in self.non_categorical_columns:
+                    info['min'] = -1e-3
+                    info['max'] = info['max'] + 1e-3
+                    
+                  current = (current - (info['min'])) / (info['max'] - info['min'])
+                  current = current * 2 - 1 
+                  current = current.reshape([-1, 1])
+                  values.append(current)
+
+            elif info['type'] == "mixed":
+                    
+                means_0 = self.model[id_][0].means_.reshape([-1])
+                stds_0 = np.sqrt(self.model[id_][0].covariances_).reshape([-1])
+
+                zero_std_list = []
+                means_needed = []
+                stds_needed = []
+
+                for mode in info['modal']:
+                    if mode!=-9999999:
+                        dist = []
+                        for idx,val in enumerate(list(means_0.flatten())):
+                            dist.append(abs(mode-val))
+                        index_min = np.argmin(np.array(dist))
+                        zero_std_list.append(index_min)
+                    else: continue
+
+                for idx in zero_std_list:
+                    means_needed.append(means_0[idx])
+                    stds_needed.append(stds_0[idx])
+                
+                
+                mode_vals = []
+
+                for i,j,k in zip(info['modal'],means_needed,stds_needed):
+                    this_val  = np.abs(i - j) / (4*k)
+                    mode_vals.append(this_val)
+                
+                if -9999999 in info["modal"]:
+                    mode_vals.append(0)
+                
+                current = current.reshape([-1, 1])
+                filter_arr = self.filter_arr[mixed_counter]
+                current = current[filter_arr]
+                
+                means = self.model[id_][1].means_.reshape((1, self.n_clusters))
+                stds = np.sqrt(self.model[id_][1].covariances_).reshape((1, self.n_clusters))
+                features = np.empty(shape=(len(current),self.n_clusters))
+                if ispositive == True:
+                    if id_ in positive_list:
+                        features = np.abs(current - means) / (4 * stds)
+                else:
+                    features = (current - means) / (4 * stds)
+
+                probs = self.model[id_][1].predict_proba(current.reshape([-1, 1]))
+
+                n_opts = sum(self.components[id_]) # 8
+                features = features[:, self.components[id_]]
+                probs = probs[:, self.components[id_]]
+                
+                opt_sel = np.zeros(len(current), dtype='int')
+                for i in range(len(current)):
+                    pp = probs[i] + 1e-6
+                    pp = pp / sum(pp)
+                    opt_sel[i] = np.random.choice(np.arange(n_opts), p=pp)
+                idx = np.arange((len(features)))
+                features = features[idx, opt_sel].reshape([-1, 1])
+                features = np.clip(features, -.99, .99)
+                probs_onehot = np.zeros_like(probs)
+                probs_onehot[np.arange(len(probs)), opt_sel] = 1
+                extra_bits = np.zeros([len(current), len(info['modal'])])
+                temp_probs_onehot = np.concatenate([extra_bits,probs_onehot], axis = 1)
+                final = np.zeros([len(data), 1 + probs_onehot.shape[1] + len(info['modal'])])
+                features_curser = 0
+                for idx, val in enumerate(data[:, id_]):
+                    if val in info['modal']:
+                        category_ = list(map(info['modal'].index, [val]))[0]
+                        final[idx, 0] = mode_vals[category_]
+                        final[idx, (category_+1)] = 1
+                    
+                    else:
+                        final[idx, 0] = features[features_curser]
+                        final[idx, (1+len(info['modal'])):] = temp_probs_onehot[features_curser][len(info['modal']):]
+                        features_curser = features_curser + 1
+               
+                just_onehot = final[:,1:]
+                re_ordered_jhot= np.zeros_like(just_onehot)
+                n = just_onehot.shape[1]
+                col_sums = just_onehot.sum(axis=0)
+                largest_indices = np.argsort(-1*col_sums)[:n]
+                self.ordering.append(largest_indices)
+                for id,val in enumerate(largest_indices):
+                      re_ordered_jhot[:,id] = just_onehot[:,val]
+                final_features = final[:,0].reshape([-1, 1])
+                values += [final_features, re_ordered_jhot]
+                mixed_counter = mixed_counter + 1
+    
+            else:
+                self.ordering.append(None)
+                col_t = np.zeros([len(data), info['size']])
+                idx = list(map(info['i2s'].index, current))
+                col_t[np.arange(len(data)), idx] = 1
+                values.append(col_t)
+                
+        return np.concatenate(values, axis=1)
+
+    def inverse_transform(self, data):
+        data_t = np.zeros([len(data), len(self.meta)])
+        invalid_ids = []
+        st = 0
+        for id_, info in enumerate(self.meta):
+            if info['type'] == "continuous":
+                if id_ not in self.general_columns:
+                  u = data[:, st]
+                  v = data[:, st + 1:st + 1 + np.sum(self.components[id_])]
+                  order = self.ordering[id_] 
+                  v_re_ordered = np.zeros_like(v)
+
+                  for id,val in enumerate(order):
+                      v_re_ordered[:,val] = v[:,id]
+                  
+                  v = v_re_ordered
+
+                  u = np.clip(u, -1, 1)
+                  v_t = np.ones((data.shape[0], self.n_clusters)) * -100
+                  v_t[:, self.components[id_]] = v
+                  v = v_t
+                  st += 1 + np.sum(self.components[id_])
+                  means = self.model[id_].means_.reshape([-1])
+                  stds = np.sqrt(self.model[id_].covariances_).reshape([-1])
+                  p_argmax = np.argmax(v, axis=1)
+                  std_t = stds[p_argmax]
+                  mean_t = means[p_argmax]
+                  tmp = u * 4 * std_t + mean_t
+                                    
+                  for idx,val in enumerate(tmp):
+                     if (val < info["min"]) | (val > info['max']):
+                         invalid_ids.append(idx)
+                  
+                  if id_ in self.non_categorical_columns:
+                    
+                    tmp = np.round(tmp)
+                  
+                  data_t[:, id_] = tmp
+
+                else:
+                  u = data[:, st]
+                  u = (u + 1) / 2
+                  u = np.clip(u, 0, 1)
+                  u = u * (info['max'] - info['min']) + info['min']
+                  if id_ in self.non_categorical_columns:
+                    data_t[:, id_] = np.round(u)
+                  else: data_t[:, id_] = u
+
+                  st += 1
+
+            elif info['type'] == "mixed":
+
+                u = data[:, st]
+                full_v = data[:,(st+1):(st+1)+len(info['modal'])+np.sum(self.components[id_])]
+                order = self.ordering[id_]
+                full_v_re_ordered = np.zeros_like(full_v)
+
+                for id,val in enumerate(order):
+                    full_v_re_ordered[:,val] = full_v[:,id]
+                  
+                full_v = full_v_re_ordered
+
+                
+                mixed_v = full_v[:,:len(info['modal'])]
+                v = full_v[:,-np.sum(self.components[id_]):]
+
+                u = np.clip(u, -1, 1)
+                v_t = np.ones((data.shape[0], self.n_clusters)) * -100
+                v_t[:, self.components[id_]] = v
+                v = np.concatenate([mixed_v,v_t], axis=1)
+
+                st += 1 + np.sum(self.components[id_]) + len(info['modal'])
+                means = self.model[id_][1].means_.reshape([-1]) 
+                stds = np.sqrt(self.model[id_][1].covariances_).reshape([-1]) 
+                p_argmax = np.argmax(v, axis=1)
+
+                result = np.zeros_like(u)
+
+                for idx in range(len(data)):
+                    if p_argmax[idx] < len(info['modal']):
+                        argmax_value = p_argmax[idx]
+                        result[idx] = float(list(map(info['modal'].__getitem__, [argmax_value]))[0])
+                    else:
+                        std_t = stds[(p_argmax[idx]-len(info['modal']))]
+                        mean_t = means[(p_argmax[idx]-len(info['modal']))]
+                        result[idx] = u[idx] * 4 * std_t + mean_t
+                        
+                for idx,val in enumerate(result):
+                     if (val < info["min"]) | (val > info['max']):
+                         invalid_ids.append(idx)
+
+                data_t[:, id_] = result
+
+            else:
+                current = data[:, st:st + info['size']]
+                st += info['size']
+                idx = np.argmax(current, axis=1)
+                data_t[:, id_] = list(map(info['i2s'].__getitem__, idx))
+            
+            
+        invalid_ids = np.unique(np.array(invalid_ids)) 
+        all_ids = np.arange(0,len(data))
+        valid_ids = list(set(all_ids) - set(invalid_ids))
+            
+        return data_t[valid_ids],len(invalid_ids)
+
+
+class ImageTransformer():
+
+    def __init__(self, side):
+    
+        self.height = side
+            
+    def transform(self, data):
+
+        if self.height * self.height > len(data[0]):
+            
+            padding = torch.zeros((len(data), self.height * self.height - len(data[0]))).to(data.device)
+            data = torch.cat([data, padding], axis=1)
+
+        return data.view(-1, 1, self.height, self.height)
+
+    def inverse_transform(self, data):
+        
+        data = data.view(-1, self.height * self.height)
+
+        return data
+
+

syntheticFail/c16/tabddpm/tabddpm-c16-20260510_223930/_tabddpm_runtime/CTAB-GAN-Plus/pipeline_ctabganp.py

@@ -0,0 +1,81 @@
+import tomli
+import shutil
+import os
+import argparse
+from train_sample_ctabganp import train_ctabgan, sample_ctabgan
+from scripts.eval_catboost import train_catboost
+import zero
+import lib
+from model.ctabgan import CTABGAN
+
+def load_config(path) :
+    with open(path, 'rb') as f:
+        return tomli.load(f)
+    
+def save_file(parent_dir, config_path):
+    try:
+        dst = os.path.join(parent_dir)
+        os.makedirs(os.path.dirname(dst), exist_ok=True)
+        shutil.copyfile(os.path.abspath(config_path), dst)
+    except shutil.SameFileError:
+        pass
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--config', metavar='FILE')
+    parser.add_argument('--train', action='store_true',  default=False)
+    parser.add_argument('--sample', action='store_true',  default=False)
+    parser.add_argument('--eval', action='store_true',  default=False)
+    parser.add_argument('--change_val', action='store_true',  default=False)
+
+    args = parser.parse_args()
+    raw_config = lib.load_config(args.config)
+    timer = zero.Timer()
+    timer.run()
+    save_file(os.path.join(raw_config['parent_dir'], 'config.toml'), args.config)
+    ctabgan = None
+    if args.train:
+        ctabgan = train_ctabgan(
+            parent_dir=raw_config['parent_dir'],
+            real_data_path=raw_config['real_data_path'],
+            train_params=raw_config['train_params'],
+            change_val=args.change_val,
+            device=raw_config['device']
+        )
+    if args.sample:
+        sample_ctabgan(
+            synthesizer=ctabgan,
+            parent_dir=raw_config['parent_dir'],
+            real_data_path=raw_config['real_data_path'],
+            num_samples=raw_config['sample']['num_samples'],
+            train_params=raw_config['train_params'],
+            change_val=args.change_val,
+            seed=raw_config['sample']['seed'],
+            device=raw_config['device']
+        )
+
+    save_file(os.path.join(raw_config['parent_dir'], 'info.json'), os.path.join(raw_config['real_data_path'], 'info.json'))
+    if args.eval:
+        if raw_config['eval']['type']['eval_model'] == 'catboost':
+            train_catboost(
+                parent_dir=raw_config['parent_dir'],
+                real_data_path=raw_config['real_data_path'],
+                eval_type=raw_config['eval']['type']['eval_type'],
+                T_dict=raw_config['eval']['T'],
+                seed=raw_config['seed'],
+                change_val=args.change_val
+            )
+        # elif raw_config['eval']['type']['eval_model'] == 'mlp':
+        #     train_mlp(
+        #         parent_dir=raw_config['parent_dir'],
+        #         real_data_path=raw_config['real_data_path'],
+        #         eval_type=raw_config['eval']['type']['eval_type'],
+        #         T_dict=raw_config['eval']['T'],
+        #         seed=raw_config['seed'],
+        #         change_val=args.change_val
+        #     )
+
+    print(f'Elapsed time: {str(timer)}')
+
+if __name__ == '__main__':
+    main()

syntheticFail/c16/tabddpm/tabddpm-c16-20260510_223930/_tabddpm_runtime/CTAB-GAN-Plus/train_sample_ctabganp.py

@@ -0,0 +1,110 @@
+import lib
+import os
+import numpy as np
+import argparse
+from model.ctabgan import CTABGAN
+from pathlib import Path
+import torch
+import pickle
+
+
+def train_ctabgan(
+    parent_dir,
+    real_data_path,
+    train_params = {"batch_size": 512},
+    change_val=False,
+    device = "cpu"
+):
+    real_data_path = Path(real_data_path)
+    parent_dir = Path(parent_dir)
+    device = torch.device(device)
+
+    if change_val:
+        X_num_train, X_cat_train, y_train, _, _, _ = lib.read_changed_val(real_data_path)
+    else:
+        X_num_train, X_cat_train, y_train = lib.read_pure_data(real_data_path, 'train')
+    
+    X = lib.concat_to_pd(X_num_train, X_cat_train, y_train)
+
+    X.columns = [str(_) for _ in X.columns]
+
+    ctabgan_params = lib.load_json("CTAB-GAN-Plus/columns.json")[real_data_path.name]
+    train_params["batch_size"] = min(y_train.shape[0], train_params["batch_size"])
+
+    print(train_params)
+    synthesizer =  CTABGAN(
+                    df = X,
+                    test_ratio = 0.0,  
+                    **ctabgan_params,
+                    **train_params,
+                    device=device
+                ) 
+    
+    synthesizer.fit()
+
+    # save_ctabgan(synthesizer, parent_dir)
+    with open(parent_dir / "ctabgan.obj", "wb") as f:
+        pickle.dump(synthesizer, f)
+
+    return synthesizer
+
+def sample_ctabgan(
+    synthesizer,
+    parent_dir,
+    real_data_path,
+    num_samples,
+    train_params = {"batch_size": 512},
+    change_val=False,
+    device="cpu",
+    seed=0
+):
+    real_data_path = Path(real_data_path)
+    parent_dir = Path(parent_dir)
+    device = torch.device(device)
+
+    if change_val:
+        X_num_train, X_cat_train, y_train, _, _, _ = lib.read_changed_val(real_data_path)
+    else:
+        X_num_train, X_cat_train, y_train = lib.read_pure_data(real_data_path, 'train')
+    
+    X = lib.concat_to_pd(X_num_train, X_cat_train, y_train)
+
+    X.columns = [str(_) for _ in X.columns]
+
+    ctabgan_params = lib.load_json("CTAB-GAN-Plus/columns.json")[real_data_path.name]
+
+    cat_features = ctabgan_params["categorical_columns"]
+    # if synthesizer is None:
+        # synthesizer = load_ctabgan(X, ctabgan_params, train_params, parent_dir)
+    with open(parent_dir / "ctabgan.obj", 'rb')  as f:
+        synthesizer = pickle.load(f)
+        synthesizer.synthesizer.generator = synthesizer.synthesizer.generator.to(device)
+    gen_data = synthesizer.generate_samples(num_samples, seed)
+
+    y = gen_data['y'].values
+    if len(np.unique(y)) == 1:
+        y[0] = 0
+        y[1] = 1
+
+    X_cat = gen_data[cat_features].drop('y', axis=1, errors="ignore").values if len(cat_features) else None
+    X_num = gen_data.values[:, :X_num_train.shape[1]] if X_num_train is not None else None
+
+    if X_num_train is not None:
+        np.save(parent_dir / 'X_num_train', X_num.astype(float))
+    if X_cat_train is not None:
+        np.save(parent_dir / 'X_cat_train', X_cat.astype(str))
+    np.save(parent_dir / 'y_train', y.astype(float).astype(int)) # only clf !!!
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('real_data_path', type=str)
+    parser.add_argument('parent_dir', type=str)
+    parser.add_argument('train_size', type=int)
+    args = parser.parse_args()
+
+    ctabgan = train_ctabgan(args.parent_dir, args.real_data_path, change_val=True)
+    sample_ctabgan(ctabgan, args.parent_dir, args.real_data_path, args.train_size, change_val=True)
+
+
+if __name__ == '__main__':
+    main()

syntheticFail/c16/tabddpm/tabddpm-c16-20260510_223930/_tabddpm_runtime/CTAB-GAN-Plus/tune_ctabgan.py

@@ -0,0 +1,153 @@
+from multiprocessing.sharedctypes import RawValue
+from random import random
+import tempfile
+import subprocess
+import lib
+import os
+import optuna
+import argparse
+from pathlib import Path
+from train_sample_ctabganp import train_ctabgan, sample_ctabgan
+from scripts.eval_catboost import train_catboost
+
+parser = argparse.ArgumentParser()
+parser.add_argument('data_path', type=str)
+parser.add_argument('train_size', type=int)
+parser.add_argument('eval_type', type=str)
+parser.add_argument('device', type=str)
+
+args = parser.parse_args()
+real_data_path = args.data_path
+eval_type = args.eval_type
+train_size = args.train_size
+device = args.device
+assert eval_type in ('merged', 'synthetic')
+
+def objective(trial):
+    
+    lr = trial.suggest_loguniform('lr', 0.00001, 0.003)
+
+    def suggest_dim(name):
+        t = trial.suggest_int(name, d_min, d_max)
+        return 2 ** t
+    
+    # construct model
+    min_n_layers, max_n_layers, d_min, d_max = 1, 4, 6, 8
+    n_layers = trial.suggest_int('n_layers', min_n_layers, max_n_layers)
+    d_first = [suggest_dim('d_first')] if n_layers else []
+    d_middle = (
+        [suggest_dim('d_middle')] * (n_layers - 2)
+        if n_layers > 2
+        else []
+    )
+    d_last = [suggest_dim('d_last')] if n_layers > 1 else []
+    d_layers = d_first + d_middle + d_last
+    ####
+
+    steps = trial.suggest_categorical('steps', [1000, 5000, 10000])
+    # steps = trial.suggest_categorical('steps', [10])
+    batch_size = 2 ** trial.suggest_int('batch_size', 9, 11)
+    random_dim = 2 ** trial.suggest_int('random_dim', 4, 7)
+    num_channels = 2 ** trial.suggest_int('num_channels', 4, 6)
+
+    # steps = trial.suggest_categorical('steps', [1000])
+
+    num_samples = int(train_size * (2 ** trial.suggest_int('frac_samples', -2, 3)))
+
+    train_params = {
+        "lr": lr,
+        "epochs": steps,
+        "class_dim": d_layers,
+        "batch_size": batch_size,
+        "random_dim": random_dim,
+        "num_channels": num_channels
+    }
+    trial.set_user_attr("train_params", train_params)
+    trial.set_user_attr("num_samples", num_samples)
+
+    score = 0.0
+    with tempfile.TemporaryDirectory() as dir_:
+        dir_ = Path(dir_)
+        ctabgan = train_ctabgan(
+            parent_dir=dir_,
+            real_data_path=real_data_path,
+            train_params=train_params,
+            change_val=True,
+            device=device
+        )
+
+        for sample_seed in range(5):
+            sample_ctabgan(
+                ctabgan,
+                parent_dir=dir_,
+                real_data_path=real_data_path,
+                num_samples=num_samples,
+                train_params=train_params,
+                change_val=True,
+                seed=sample_seed,
+                device=device
+            )
+
+            T_dict = {
+                "seed": 0,
+                "normalization": None,
+                "num_nan_policy": None,
+                "cat_nan_policy": None,
+                "cat_min_frequency": None,
+                "cat_encoding": None,
+                "y_policy": "default"
+            }
+            metrics = train_catboost(
+                parent_dir=dir_,
+                real_data_path=real_data_path, 
+                eval_type=eval_type,
+                T_dict=T_dict,
+                change_val=True,
+                seed = 0
+            )
+
+            score += metrics.get_val_score()
+    return score / 5
+
+
+study = optuna.create_study(
+    direction='maximize',
+    sampler=optuna.samplers.TPESampler(seed=0),
+)
+
+study.optimize(objective, n_trials=35, show_progress_bar=True)
+
+os.makedirs(f"exp/{Path(real_data_path).name}/ctabgan-plus/", exist_ok=True)
+config = {
+    "parent_dir": f"exp/{Path(real_data_path).name}/ctabgan-plus/",
+    "real_data_path": real_data_path,
+    "seed": 0,
+    "device": args.device,
+    "train_params": study.best_trial.user_attrs["train_params"],
+    "sample": {"seed": 0, "num_samples": study.best_trial.user_attrs["num_samples"]},
+    "eval": {
+        "type": {"eval_model": "catboost", "eval_type": eval_type},
+        "T": {
+            "seed": 0,
+            "normalization": None,
+            "num_nan_policy": None,
+            "cat_nan_policy": None,
+            "cat_min_frequency": None,
+            "cat_encoding": None,
+            "y_policy": "default"
+        },
+    }
+}
+
+train_ctabgan(
+    parent_dir=f"exp/{Path(real_data_path).name}/ctabgan-plus/",
+    real_data_path=real_data_path,
+    train_params=study.best_trial.user_attrs["train_params"],
+    change_val=False,
+    device=device
+)
+
+lib.dump_config(config, config["parent_dir"]+"config.toml")
+
+subprocess.run(['python3.9', "scripts/eval_seeds.py", '--config', f'{config["parent_dir"]+"config.toml"}',
+                '10', "ctabgan-plus", eval_type, "catboost", "5"], check=True)

syntheticFail/c16/tabddpm/tabddpm-c16-20260510_223930/_tabddpm_runtime/CTAB-GAN/.gitignore

@@ -0,0 +1 @@
+**/**.csv

syntheticFail/c16/tabddpm/tabddpm-c16-20260510_223930/_tabddpm_runtime/CTAB-GAN/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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.

syntheticFail/c16/tabddpm/tabddpm-c16-20260510_223930/_tabddpm_runtime/CTAB-GAN/License.txt

@@ -0,0 +1,15 @@
+Distributed learning systems Lab at TU Delft & Generatrix, hereby disclaims all copyright interest in the program "CTAB-GAN" (which synthesizes tabular data) 
+
+Copyright 2020-2022 Distributed learning systems Lab at TU Delft & Generatrix.
+
+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
+
+      https://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.

syntheticFail/c16/tabddpm/tabddpm-c16-20260510_223930/_tabddpm_runtime/CTAB-GAN/README.md

@@ -0,0 +1,50 @@
+# CTAB-GAN
+This is the official git paper [CTAB-GAN: Effective Table Data Synthesizing](https://proceedings.mlr.press/v157/zhao21a.html). The paper is published on Asian Conference on Machine Learning (ACML 2021), please check our pdf on PMLR website for our newest version of [paper](https://proceedings.mlr.press/v157/zhao21a.html), it adds more content on time consumption analysis of training CTAB-GAN. If you have any question, please contact `z.zhao-8@tudelft.nl` for more information.
+
+
+## Prerequisite
+
+The required package version
+```
+numpy==1.21.0
+torch==1.9.1
+pandas==1.2.4
+sklearn==0.24.1
+dython==0.6.4.post1
+scipy==1.4.1
+```
+
+## Example
+`Experiment_Script_Adult.ipynb` is an example notebook for training CTAB-GAN with Adult dataset. The dataset is alread under `Real_Datasets` folder.
+The evaluation code is also provided.
+
+## For large dataset
+
+If your dataset has large number of column, you may encounter the problem that our currnet code cannot encode all of your data since CTAB-GAN will wrap the encoded data into an image-like format. What you can do is changing the line 341 and 348 in `model/synthesizer/ctabgan_synthesizer.py`. The number in the `slide` list
+```
+sides = [4, 8, 16, 24, 32]
+```
+is the side size of image. You can enlarge the list to [4, 8, 16, 24, 32, 64] or [4, 8, 16, 24, 32, 64, 128] for accepting larger dataset.
+
+## Bibtex
+
+To cite this paper, you could use this bibtex
+
+```
+@InProceedings{zhao21,
+  title = 	 {CTAB-GAN: Effective Table Data Synthesizing},
+  author =       {Zhao, Zilong and Kunar, Aditya and Birke, Robert and Chen, Lydia Y.},
+  booktitle = 	 {Proceedings of The 13th Asian Conference on Machine Learning},
+  pages = 	 {97--112},
+  year = 	 {2021},
+  editor = 	 {Balasubramanian, Vineeth N. and Tsang, Ivor},
+  volume = 	 {157},
+  series = 	 {Proceedings of Machine Learning Research},
+  month = 	 {17--19 Nov},
+  publisher =    {PMLR},
+  pdf = 	 {https://proceedings.mlr.press/v157/zhao21a/zhao21a.pdf},
+  url = 	 {https://proceedings.mlr.press/v157/zhao21a.html}
+}
+
+
+```

syntheticFail/c16/tabddpm/tabddpm-c16-20260510_223930/_tabddpm_runtime/CTAB-GAN/columns.json

@@ -0,0 +1,74 @@
+{
+    "churn2": {
+        "categorical_columns": ["7", "8", "9", "10", "y"],
+        "mixed_columns": {"0": [850.0], "3": [0.0]},
+        "integer_columns": ["1", "2", "4"],
+        "problem_type": {"Classification": "y"}
+    },
+    "adult": {
+        "categorical_columns": ["6", "7", "8", "9", "10", "11", "12", "13", "y"],
+        "mixed_columns": {"3": [0.0], "4": [0.0]},
+        "integer_columns": ["0", "2", "5"],
+        "problem_type": {"Classification": "y"}
+    },
+    "buddy": {
+        "categorical_columns": ["4", "5", "6", "7", "8", "y"],
+        "mixed_columns": {},
+        "integer_columns": ["0", "1"],
+        "problem_type": {"Classification": "y"}
+    },
+    "gesture": {
+        "categorical_columns": ["y"],
+        "mixed_columns": {},
+        "integer_columns": [],
+        "problem_type": {"Classification": "y"}
+    },
+    "wilt": {
+        "categorical_columns": ["y"],
+        "mixed_columns": {},
+        "integer_columns": [],
+        "problem_type": {"Classification": "y"}
+    },
+    "satellite": {
+        "categorical_columns": ["y"],
+        "mixed_columns": {},
+        "integer_columns": ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "20", "21", "22", "23", "24", "25", "26", "27", "28", "29", "30", "31", "32", "33", "34", "35"],
+        "problem_type": {"Classification": "y"}
+    },
+    "higgs-small": {
+        "categorical_columns": ["y"],
+        "mixed_columns": {},
+        "integer_columns": [],
+        "problem_type": {"Classification": "y"}
+    },
+    "diabetes": {
+        "categorical_columns": ["y"],
+        "mixed_columns": {"3": [0.0], "4": [0.0]},
+        "integer_columns": ["0", "1", "2", "5", "7"],
+        "problem_type": {"Classification": "y"}
+    },
+    "default": {
+        "categorical_columns": ["20", "21", "22", "y"],
+        "mixed_columns": {},
+        "integer_columns": ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19"],
+        "problem_type": {"Classification": "y"}
+    },
+    "otto": {
+        "categorical_columns": ["y"],
+        "mixed_columns": {},
+        "integer_columns": ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "20", "21", "22", "23", "24", "25", "26", "27", "28", "29", "30", "31", "32", "33", "34", "35", "36", "37", "38", "39", "40", "41", "42", "43", "44", "45", "46", "47", "48", "49", "50", "51", "52", "53", "54", "55", "56", "57", "58", "59", "60", "61", "62", "63", "64", "65", "66", "67", "68", "69", "70", "71", "72", "73", "74", "75", "76", "77", "78", "79", "80", "81", "82", "83", "84", "85", "86", "87", "88", "89", "90", "91", "92"],
+        "problem_type": {"Classification": "y"}
+    },
+    "cardio": {
+        "categorical_columns": ["5", "6", "7", "8", "9", "10", "y"],
+        "mixed_columns": {},
+        "integer_columns": ["0", "1", "3", "4"],
+        "problem_type": {"Classification": "y"}
+    },
+    "miniboone": {
+        "categorical_columns": ["y"],
+        "mixed_columns": {},
+        "integer_columns": [],
+        "problem_type": {"Classification": "y"}
+    }
+}

syntheticFail/c16/tabddpm/tabddpm-c16-20260510_223930/_tabddpm_runtime/CTAB-GAN/model/ctabgan.py

@@ -0,0 +1,58 @@
+"""
+Generative model training algorithm based on the CTABGANSynthesiser
+
+"""
+import pandas as pd
+import time
+from model.pipeline.data_preparation import DataPrep
+from model.synthesizer.ctabgan_synthesizer import CTABGANSynthesizer
+
+import warnings
+
+warnings.filterwarnings("ignore")
+
+class CTABGAN():
+
+    def __init__(self,
+                 df,
+                 test_ratio = 0.20,
+                 categorical_columns = [ 'workclass', 'education', 'marital-status', 'occupation', 'relationship', 'race', 'gender', 'native-country', 'income'], 
+                 log_columns = [],
+                 mixed_columns= {'capital-loss':[0.0],'capital-gain':[0.0]},
+                 integer_columns = ['age', 'fnlwgt','capital-gain', 'capital-loss','hours-per-week'],
+                 problem_type= {"Classification": 'income'},
+                 batch_size = 512,
+                 class_dim = (256, 256, 256, 256),
+                 lr = 2e-4,
+                 epochs = 10,
+                 device=None):
+
+        self.__name__ = 'CTABGAN'
+              
+        self.synthesizer = CTABGANSynthesizer(lr = lr, epochs = epochs, batch_size = batch_size, class_dim = class_dim, device = device)
+        self.raw_df = df
+        print(self.raw_df.shape)
+        self.test_ratio = test_ratio
+        self.categorical_columns = categorical_columns
+        self.log_columns = log_columns
+        self.mixed_columns = mixed_columns
+        self.integer_columns = integer_columns
+        self.problem_type = problem_type
+        
+    def fit(self, no_train=False):
+        print("-"*100)
+        start_time = time.time()
+        self.data_prep = DataPrep(self.raw_df,self.categorical_columns,self.log_columns,self.mixed_columns,self.integer_columns,self.problem_type,self.test_ratio)
+        self.synthesizer.fit(train_data=self.data_prep.df, categorical = self.data_prep.column_types["categorical"], 
+        mixed = self.data_prep.column_types["mixed"],type=self.problem_type, no_train=no_train)
+        end_time = time.time()
+        print('Finished training in',end_time-start_time," seconds.")
+        print("-"*100)
+
+
+    def generate_samples(self, num_samples, seed=0):
+        
+        sample = self.synthesizer.sample(num_samples, seed) 
+        sample_df = self.data_prep.inverse_prep(sample)
+        
+        return sample_df

syntheticFail/c16/tabddpm/tabddpm-c16-20260510_223930/_tabddpm_runtime/CTAB-GAN/model/eval/evaluation.py

@@ -0,0 +1,191 @@
+import numpy as np
+import pandas as pd 
+from sklearn import metrics
+from sklearn import model_selection
+from sklearn.preprocessing import MinMaxScaler,StandardScaler
+from sklearn.neural_network import MLPClassifier
+from sklearn.linear_model import LogisticRegression
+from sklearn import svm,tree
+from sklearn.ensemble import RandomForestClassifier
+from dython.nominal import compute_associations
+from scipy.stats import wasserstein_distance
+from scipy.spatial import distance
+import warnings
+
+warnings.filterwarnings("ignore")
+
+def supervised_model_training(x_train, y_train, x_test, 
+                              y_test, model_name):
+  
+  if model_name == 'lr':
+    model  = LogisticRegression(random_state=42,max_iter=500) 
+  elif model_name == 'svm':
+    model  = svm.SVC(random_state=42,probability=True)
+  elif model_name == 'dt':
+    model  = tree.DecisionTreeClassifier(random_state=42)
+  elif model_name == 'rf':      
+    model = RandomForestClassifier(random_state=42)
+  elif model_name == "mlp":
+    model = MLPClassifier(random_state=42,max_iter=100)
+  
+  model.fit(x_train, y_train)
+  pred = model.predict(x_test)
+
+  if len(np.unique(y_train))>2:
+    predict = model.predict_proba(x_test)        
+    acc = metrics.accuracy_score(y_test,pred)*100
+    auc = metrics.roc_auc_score(y_test, predict,average="weighted",multi_class="ovr")
+    f1_score = metrics.precision_recall_fscore_support(y_test, pred,average="weighted")[2]
+    return [acc, auc,f1_score] 
+
+  else:
+    predict = model.predict_proba(x_test)[:,1]    
+    acc = metrics.accuracy_score(y_test,pred)*100
+    auc = metrics.roc_auc_score(y_test, predict)
+    f1_score = metrics.precision_recall_fscore_support(y_test,pred)[2].mean()
+    return [acc, auc,f1_score] 
+
+
+def get_utility_metrics(real_path,fake_paths,scaler="MinMax",classifiers=["lr","dt","rf","mlp"],test_ratio=.20):
+
+    data_real = pd.read_csv(real_path).to_numpy()
+    data_dim = data_real.shape[1]
+
+    data_real_y = data_real[:,-1]
+    data_real_X = data_real[:,:data_dim-1]
+    X_train_real, X_test_real, y_train_real, y_test_real = model_selection.train_test_split(data_real_X ,data_real_y, test_size=test_ratio, stratify=data_real_y,random_state=42) 
+
+    if scaler=="MinMax":
+        scaler_real = MinMaxScaler()
+    else:
+        scaler_real = StandardScaler()
+        
+    scaler_real.fit(X_train_real)
+    X_train_real_scaled = scaler_real.transform(X_train_real)
+    X_test_real_scaled = scaler_real.transform(X_test_real)
+
+    all_real_results = []
+    for classifier in classifiers:
+      real_results = supervised_model_training(X_train_real_scaled,y_train_real,X_test_real_scaled,y_test_real,classifier)
+      all_real_results.append(real_results)
+      
+    all_fake_results_avg = []
+    
+    for fake_path in fake_paths:
+      data_fake  = pd.read_csv(fake_path).to_numpy()
+      data_fake_y = data_fake[:,-1]
+      data_fake_X = data_fake[:,:data_dim-1]
+      X_train_fake, _ , y_train_fake, _ = model_selection.train_test_split(data_fake_X ,data_fake_y, test_size=test_ratio, stratify=data_fake_y,random_state=42) 
+
+      if scaler=="MinMax":
+        scaler_fake = MinMaxScaler()
+      else:
+        scaler_fake = StandardScaler()
+      
+      scaler_fake.fit(data_fake_X)
+      
+      X_train_fake_scaled = scaler_fake.transform(X_train_fake)
+      
+      all_fake_results = []
+      for classifier in classifiers:
+        fake_results = supervised_model_training(X_train_fake_scaled,y_train_fake,X_test_real_scaled,y_test_real,classifier)
+        all_fake_results.append(fake_results)
+
+      all_fake_results_avg.append(all_fake_results)
+    
+    diff_results = np.array(all_real_results)- np.array(all_fake_results_avg).mean(axis=0)
+
+    return diff_results
+
+def stat_sim(real_path,fake_path,cat_cols=None):
+    
+    Stat_dict={}
+    
+    real = pd.read_csv(real_path)
+    fake = pd.read_csv(fake_path)
+
+    really = real.copy()
+    fakey = fake.copy()
+
+    real_corr = compute_associations(real, nominal_columns=cat_cols)
+
+    fake_corr = compute_associations(fake, nominal_columns=cat_cols)
+
+    corr_dist = np.linalg.norm(real_corr - fake_corr)
+    
+    cat_stat = []
+    num_stat = []
+    
+    for column in real.columns:
+        
+        if column in cat_cols:
+            real_pdf=(really[column].value_counts()/really[column].value_counts().sum())
+            fake_pdf=(fakey[column].value_counts()/fakey[column].value_counts().sum())
+            categories = (fakey[column].value_counts()/fakey[column].value_counts().sum()).keys().tolist()
+            sorted_categories = sorted(categories)
+            
+            real_pdf_values = [] 
+            fake_pdf_values = []
+
+            for i in sorted_categories:
+                real_pdf_values.append(real_pdf[i])
+                fake_pdf_values.append(fake_pdf[i])
+            
+            if len(real_pdf)!=len(fake_pdf):
+                zero_cats = set(really[column].value_counts().keys())-set(fakey[column].value_counts().keys())
+                for z in zero_cats:
+                    real_pdf_values.append(real_pdf[z])
+                    fake_pdf_values.append(0)
+            Stat_dict[column]=(distance.jensenshannon(real_pdf_values,fake_pdf_values, 2.0))
+            cat_stat.append(Stat_dict[column])        
+        else:
+            scaler = MinMaxScaler()
+            scaler.fit(real[column].values.reshape(-1,1))
+            l1 = scaler.transform(real[column].values.reshape(-1,1)).flatten()
+            l2 = scaler.transform(fake[column].values.reshape(-1,1)).flatten()
+            Stat_dict[column]= (wasserstein_distance(l1,l2))
+            num_stat.append(Stat_dict[column])
+
+    return [np.mean(num_stat),np.mean(cat_stat),corr_dist]
+
+def privacy_metrics(real_path,fake_path,data_percent=15):
+    
+    real = pd.read_csv(real_path).drop_duplicates(keep=False)
+    fake = pd.read_csv(fake_path).drop_duplicates(keep=False)
+
+    real_refined = real.sample(n=int(len(real)*(.01*data_percent)), random_state=42).to_numpy()
+    fake_refined = fake.sample(n=int(len(fake)*(.01*data_percent)), random_state=42).to_numpy()
+
+    scalerR = StandardScaler()
+    scalerR.fit(real_refined)
+    scalerF = StandardScaler()
+    scalerF.fit(fake_refined)
+    df_real_scaled = scalerR.transform(real_refined)
+    df_fake_scaled = scalerF.transform(fake_refined)
+    
+    dist_rf = metrics.pairwise_distances(df_real_scaled, Y=df_fake_scaled, metric='minkowski', n_jobs=-1)
+    dist_rr = metrics.pairwise_distances(df_real_scaled, Y=None, metric='minkowski', n_jobs=-1)
+    rd_dist_rr = dist_rr[~np.eye(dist_rr.shape[0],dtype=bool)].reshape(dist_rr.shape[0],-1)
+    dist_ff = metrics.pairwise_distances(df_fake_scaled, Y=None, metric='minkowski', n_jobs=-1)
+    rd_dist_ff = dist_ff[~np.eye(dist_ff.shape[0],dtype=bool)].reshape(dist_ff.shape[0],-1) 
+    smallest_two_indexes_rf = [dist_rf[i].argsort()[:2] for i in range(len(dist_rf))]
+    smallest_two_rf = [dist_rf[i][smallest_two_indexes_rf[i]] for i in range(len(dist_rf))]       
+    smallest_two_indexes_rr = [rd_dist_rr[i].argsort()[:2] for i in range(len(rd_dist_rr))]
+    smallest_two_rr = [rd_dist_rr[i][smallest_two_indexes_rr[i]] for i in range(len(rd_dist_rr))]
+    smallest_two_indexes_ff = [rd_dist_ff[i].argsort()[:2] for i in range(len(rd_dist_ff))]
+    smallest_two_ff = [rd_dist_ff[i][smallest_two_indexes_ff[i]] for i in range(len(rd_dist_ff))]
+    nn_ratio_rr = np.array([i[0]/i[1] for i in smallest_two_rr])
+    nn_ratio_ff = np.array([i[0]/i[1] for i in smallest_two_ff])
+    nn_ratio_rf = np.array([i[0]/i[1] for i in smallest_two_rf])
+    nn_fifth_perc_rr = np.percentile(nn_ratio_rr,5)
+    nn_fifth_perc_ff = np.percentile(nn_ratio_ff,5)
+    nn_fifth_perc_rf = np.percentile(nn_ratio_rf,5)
+
+    min_dist_rf = np.array([i[0] for i in smallest_two_rf])
+    fifth_perc_rf = np.percentile(min_dist_rf,5)
+    min_dist_rr = np.array([i[0] for i in smallest_two_rr])
+    fifth_perc_rr = np.percentile(min_dist_rr,5)
+    min_dist_ff = np.array([i[0] for i in smallest_two_ff])
+    fifth_perc_ff = np.percentile(min_dist_ff,5)
+    
+    return np.array([fifth_perc_rf,fifth_perc_rr,fifth_perc_ff,nn_fifth_perc_rf,nn_fifth_perc_rr,nn_fifth_perc_ff]).reshape(1,6)