Hugging Face's logo

Datasets:
TabQueryBench2026
/
server

Dataset card Files
xet
 Community
1
jialinzhang commited on
Commit
5215b17
·
1 Parent(s): 6c6b457

Add syntheticFail n18

Browse files
This view is limited to 50 files because it contains too many changes.   See raw diff
Files changed (50) hide show
  1. syntheticFail/n18/tabddpm/tabddpm-n18-20260510_215518/_tabddpm_train.py +32 -0
  2. syntheticFail/n18/tabddpm/tabddpm-n18-20260510_215518/config.toml +39 -0
  3. syntheticFail/n18/tabddpm/tabddpm-n18-20260510_215518/data/X_cat_train.npy +3 -0
  4. syntheticFail/n18/tabddpm/tabddpm-n18-20260510_215518/data/X_num_train.npy +3 -0
  5. syntheticFail/n18/tabddpm/tabddpm-n18-20260510_215518/data/info.json +358 -0
  6. syntheticFail/n18/tabddpm/tabddpm-n18-20260510_215518/data/y_train.npy +3 -0
  7. syntheticFail/n18/tabddpm/tabddpm-n18-20260510_215518/input_snapshot.json +36 -0
  8. syntheticFail/n18/tabddpm/tabddpm-n18-20260510_215518/public_gate/normalized_schema_snapshot.json +3926 -0
  9. syntheticFail/n18/tabddpm/tabddpm-n18-20260510_215518/public_gate/public_gate_report.json +37 -0
  10. syntheticFail/n18/tabddpm/tabddpm-n18-20260510_215518/public_gate/staged_input_manifest.json +3931 -0
  11. syntheticFail/n18/tabddpm/tabddpm-n18-20260510_215518/run_config.json +45 -0
  12. syntheticFail/n18/tabddpm/tabddpm-n18-20260510_215518/runtime_result.json +24 -0
  13. syntheticFail/n18/tabddpm/tabddpm-n18-20260510_215518/staged/public/staged_features.json +857 -0
  14. syntheticFail/n18/tabddpm/tabddpm-n18-20260510_215518/staged/public/test.csv +3 -0
  15. syntheticFail/n18/tabddpm/tabddpm-n18-20260510_215518/staged/public/train.csv +3 -0
  16. syntheticFail/n18/tabddpm/tabddpm-n18-20260510_215518/staged/public/val.csv +3 -0
  17. syntheticFail/n18/tabddpm/tabddpm-n18-20260510_215518/staged/tabddpm/adapter_report.json +7 -0
  18. syntheticFail/n18/tabddpm/tabddpm-n18-20260510_215518/staged/tabddpm/adapter_transforms_applied.json +1 -0
  19. syntheticFail/n18/tabddpm/tabddpm-n18-20260510_215518/staged/tabddpm/model_input_manifest.json +3933 -0
  20. syntheticFail/n18/tabddpm/tabddpm-n18-20260510_215518/train_20260510_215528.log +3 -0
  21. syntheticFail/n18/tabddpm/tabddpm-n18-20260511_002808/_tabddpm_runtime/._data +0 -0
  22. syntheticFail/n18/tabddpm/tabddpm-n18-20260511_002808/_tabddpm_runtime/.gitignore +22 -0
  23. syntheticFail/n18/tabddpm/tabddpm-n18-20260511_002808/_tabddpm_runtime/.gitmodules +9 -0
  24. syntheticFail/n18/tabddpm/tabddpm-n18-20260511_002808/_tabddpm_runtime/CONFIG_DESCRIPTION.md +78 -0
  25. syntheticFail/n18/tabddpm/tabddpm-n18-20260511_002808/_tabddpm_runtime/CTAB-GAN-Plus/.gitignore +1 -0
  26. syntheticFail/n18/tabddpm/tabddpm-n18-20260511_002808/_tabddpm_runtime/CTAB-GAN-Plus/README.md +49 -0
  27. syntheticFail/n18/tabddpm/tabddpm-n18-20260511_002808/_tabddpm_runtime/CTAB-GAN-Plus/columns.json +119 -0
  28. syntheticFail/n18/tabddpm/tabddpm-n18-20260511_002808/_tabddpm_runtime/CTAB-GAN-Plus/model copy/ctabgan.py +70 -0
  29. syntheticFail/n18/tabddpm/tabddpm-n18-20260511_002808/_tabddpm_runtime/CTAB-GAN-Plus/model copy/eval/evaluation.py +193 -0
  30. syntheticFail/n18/tabddpm/tabddpm-n18-20260511_002808/_tabddpm_runtime/CTAB-GAN-Plus/model copy/pipeline/data_preparation.py +130 -0
  31. syntheticFail/n18/tabddpm/tabddpm-n18-20260511_002808/_tabddpm_runtime/CTAB-GAN-Plus/model copy/privacy_utils/rdp_accountant.py +280 -0
  32. syntheticFail/n18/tabddpm/tabddpm-n18-20260511_002808/_tabddpm_runtime/CTAB-GAN-Plus/model copy/synthesizer/ctabgan_synthesizer.py +601 -0
  33. syntheticFail/n18/tabddpm/tabddpm-n18-20260511_002808/_tabddpm_runtime/CTAB-GAN-Plus/model copy/synthesizer/transformer.py +429 -0
  34. syntheticFail/n18/tabddpm/tabddpm-n18-20260511_002808/_tabddpm_runtime/CTAB-GAN-Plus/model/ctabgan.py +72 -0
  35. syntheticFail/n18/tabddpm/tabddpm-n18-20260511_002808/_tabddpm_runtime/CTAB-GAN-Plus/model/eval/evaluation.py +193 -0
  36. syntheticFail/n18/tabddpm/tabddpm-n18-20260511_002808/_tabddpm_runtime/CTAB-GAN-Plus/model/pipeline/data_preparation.py +131 -0
  37. syntheticFail/n18/tabddpm/tabddpm-n18-20260511_002808/_tabddpm_runtime/CTAB-GAN-Plus/model/privacy_utils/rdp_accountant.py +280 -0
  38. syntheticFail/n18/tabddpm/tabddpm-n18-20260511_002808/_tabddpm_runtime/CTAB-GAN-Plus/model/synthesizer/ctabgan_synthesizer.py +605 -0
  39. syntheticFail/n18/tabddpm/tabddpm-n18-20260511_002808/_tabddpm_runtime/CTAB-GAN-Plus/model/synthesizer/transformer.py +429 -0
  40. syntheticFail/n18/tabddpm/tabddpm-n18-20260511_002808/_tabddpm_runtime/CTAB-GAN-Plus/pipeline_ctabganp.py +81 -0
  41. syntheticFail/n18/tabddpm/tabddpm-n18-20260511_002808/_tabddpm_runtime/CTAB-GAN-Plus/train_sample_ctabganp.py +110 -0
  42. syntheticFail/n18/tabddpm/tabddpm-n18-20260511_002808/_tabddpm_runtime/CTAB-GAN-Plus/tune_ctabgan.py +153 -0
  43. syntheticFail/n18/tabddpm/tabddpm-n18-20260511_002808/_tabddpm_runtime/CTAB-GAN/.gitignore +1 -0
  44. syntheticFail/n18/tabddpm/tabddpm-n18-20260511_002808/_tabddpm_runtime/CTAB-GAN/LICENSE +201 -0
  45. syntheticFail/n18/tabddpm/tabddpm-n18-20260511_002808/_tabddpm_runtime/CTAB-GAN/License.txt +15 -0
  46. syntheticFail/n18/tabddpm/tabddpm-n18-20260511_002808/_tabddpm_runtime/CTAB-GAN/README.md +50 -0
  47. syntheticFail/n18/tabddpm/tabddpm-n18-20260511_002808/_tabddpm_runtime/CTAB-GAN/columns.json +74 -0
  48. syntheticFail/n18/tabddpm/tabddpm-n18-20260511_002808/_tabddpm_runtime/CTAB-GAN/model/__init__.py +0 -0
  49. syntheticFail/n18/tabddpm/tabddpm-n18-20260511_002808/_tabddpm_runtime/CTAB-GAN/model/ctabgan.py +58 -0
  50. syntheticFail/n18/tabddpm/tabddpm-n18-20260511_002808/_tabddpm_runtime/CTAB-GAN/model/eval/evaluation.py +191 -0
syntheticFail/n18/tabddpm/tabddpm-n18-20260510_215518/_tabddpm_train.py ADDED
@@ -0,0 +1,32 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ import os, sys, subprocess
2
+
3
+ tabddpm_root = "/workspace/tabddpm/code"
4
+ assert os.path.isdir(tabddpm_root), f"TabDDPM source not mounted: {tabddpm_root}"
5
+ env = os.environ.copy()
6
+ env["PYTHONPATH"] = tabddpm_root + (os.pathsep + env.get("PYTHONPATH", ""))
7
+
8
+ # Write a wrapper that patches collections.Sequence (removed in Python 3.10+)
9
+ # before running pipeline.py - needed because skorch uses old API
10
+ wrapper = os.path.join(tabddpm_root, "_compat_run.py")
11
+ with open(wrapper, "w") as f:
12
+ f.write(
13
+ "import collections, collections.abc\n"
14
+ "for _a in ('Sequence','MutableSequence','MutableMapping','Mapping',"
15
+ "'MutableSet','Set','Callable','Iterable','Iterator'):\n"
16
+ " if not hasattr(collections, _a): setattr(collections, _a, getattr(collections.abc, _a, None))\n"
17
+ "import sys, runpy\n"
18
+ "sys.argv = sys.argv[1:]\n"
19
+ "runpy.run_path(sys.argv[0], run_name='__main__')\n"
20
+ )
21
+
22
+ print(f"[TabDDPM] Training, config=/work/output-Benchmark-trainonly-v1/n18/tabddpm/tabddpm-n18-20260510_215518/config.toml")
23
+ ret = subprocess.run(
24
+ [sys.executable, wrapper, "scripts/pipeline.py",
25
+ "--config", "/work/output-Benchmark-trainonly-v1/n18/tabddpm/tabddpm-n18-20260510_215518/config.toml",
26
+ "--train"],
27
+ cwd=tabddpm_root,
28
+ env=env
29
+ )
30
+ if ret.returncode != 0:
31
+ sys.exit(ret.returncode)
32
+ print("[TabDDPM] Training complete")
syntheticFail/n18/tabddpm/tabddpm-n18-20260510_215518/config.toml ADDED
@@ -0,0 +1,39 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ seed = 0
2
+ parent_dir = "/work/output-Benchmark-trainonly-v1/n18/tabddpm/tabddpm-n18-20260510_215518/output"
3
+ real_data_path = "/work/output-Benchmark-trainonly-v1/n18/tabddpm/tabddpm-n18-20260510_215518/data"
4
+ model_type = "mlp"
5
+ num_numerical_features = 149
6
+ device = "cuda:0"
7
+
8
+ [model_params]
9
+ d_in = 170
10
+ num_classes = 2
11
+ is_y_cond = true
12
+
13
+ [model_params.rtdl_params]
14
+ d_layers = [256, 256]
15
+ dropout = 0.0
16
+
17
+ [diffusion_params]
18
+ num_timesteps = 200
19
+ gaussian_loss_type = "mse"
20
+
21
+ [train.main]
22
+ steps = 2000
23
+ lr = 0.001
24
+ weight_decay = 0.0
25
+ batch_size = 256
26
+
27
+ [train.T]
28
+ seed = 0
29
+ normalization = "quantile"
30
+ num_nan_policy = "__none__"
31
+ cat_nan_policy = "__none__"
32
+ cat_min_frequency = "__none__"
33
+ cat_encoding = "__none__"
34
+ y_policy = "default"
35
+
36
+ [sample]
37
+ num_samples = 1000
38
+ batch_size = 256
39
+ seed = 0
syntheticFail/n18/tabddpm/tabddpm-n18-20260510_215518/data/X_cat_train.npy ADDED
@@ -0,0 +1,3 @@
 
 
 
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:00ba868e1e41e794cc84714cdf3b5ee364761178ceedfcaaa541b829be733119
3
+ size 10214528
syntheticFail/n18/tabddpm/tabddpm-n18-20260510_215518/data/X_num_train.npy ADDED
@@ -0,0 +1,3 @@
 
 
 
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:7d32634747463d42035d32e25b4c3f15e826f06a24e5b325b1f7c25a73e0facc
3
+ size 36236928
syntheticFail/n18/tabddpm/tabddpm-n18-20260510_215518/data/info.json ADDED
@@ -0,0 +1,358 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "name": "benchmark_dataset",
3
+ "task_type": "multiclass",
4
+ "n_num_features": 149,
5
+ "n_cat_features": 21,
6
+ "train_size": 60800,
7
+ "num_col_idx": [
8
+ 0,
9
+ 1,
10
+ 2,
11
+ 3,
12
+ 4,
13
+ 5,
14
+ 6,
15
+ 7,
16
+ 8,
17
+ 9,
18
+ 10,
19
+ 11,
20
+ 12,
21
+ 13,
22
+ 14,
23
+ 15,
24
+ 16,
25
+ 17,
26
+ 18,
27
+ 19,
28
+ 20,
29
+ 21,
30
+ 22,
31
+ 23,
32
+ 24,
33
+ 25,
34
+ 26,
35
+ 27,
36
+ 28,
37
+ 29,
38
+ 30,
39
+ 31,
40
+ 32,
41
+ 33,
42
+ 34,
43
+ 35,
44
+ 36,
45
+ 37,
46
+ 38,
47
+ 39,
48
+ 40,
49
+ 41,
50
+ 42,
51
+ 43,
52
+ 44,
53
+ 45,
54
+ 46,
55
+ 47,
56
+ 48,
57
+ 49,
58
+ 50,
59
+ 51,
60
+ 52,
61
+ 53,
62
+ 54,
63
+ 55,
64
+ 56,
65
+ 57,
66
+ 58,
67
+ 59,
68
+ 60,
69
+ 61,
70
+ 62,
71
+ 63,
72
+ 64,
73
+ 65,
74
+ 66,
75
+ 67,
76
+ 68,
77
+ 69,
78
+ 70,
79
+ 71,
80
+ 72,
81
+ 73,
82
+ 74,
83
+ 75,
84
+ 76,
85
+ 77,
86
+ 78,
87
+ 79,
88
+ 80,
89
+ 81,
90
+ 82,
91
+ 83,
92
+ 84,
93
+ 85,
94
+ 86,
95
+ 87,
96
+ 88,
97
+ 89,
98
+ 90,
99
+ 91,
100
+ 92,
101
+ 93,
102
+ 94,
103
+ 95,
104
+ 96,
105
+ 97,
106
+ 98,
107
+ 99,
108
+ 100,
109
+ 101,
110
+ 102,
111
+ 103,
112
+ 104,
113
+ 105,
114
+ 106,
115
+ 107,
116
+ 108,
117
+ 109,
118
+ 110,
119
+ 111,
120
+ 112,
121
+ 113,
122
+ 114,
123
+ 115,
124
+ 116,
125
+ 117,
126
+ 118,
127
+ 119,
128
+ 120,
129
+ 121,
130
+ 122,
131
+ 123,
132
+ 124,
133
+ 125,
134
+ 126,
135
+ 127,
136
+ 128,
137
+ 129,
138
+ 130,
139
+ 131,
140
+ 132,
141
+ 133,
142
+ 134,
143
+ 135,
144
+ 136,
145
+ 137,
146
+ 138,
147
+ 139,
148
+ 140,
149
+ 141,
150
+ 142,
151
+ 143,
152
+ 144,
153
+ 145,
154
+ 146,
155
+ 147,
156
+ 148
157
+ ],
158
+ "cat_col_idx": [
159
+ 149,
160
+ 150,
161
+ 151,
162
+ 152,
163
+ 153,
164
+ 154,
165
+ 155,
166
+ 156,
167
+ 157,
168
+ 158,
169
+ 159,
170
+ 160,
171
+ 161,
172
+ 162,
173
+ 163,
174
+ 164,
175
+ 165,
176
+ 166,
177
+ 167,
178
+ 168,
179
+ 169
180
+ ],
181
+ "target_col_idx": [
182
+ 170
183
+ ],
184
+ "column_names": [
185
+ "aa_000",
186
+ "ab_000",
187
+ "ac_000",
188
+ "ad_000",
189
+ "ae_000",
190
+ "af_000",
191
+ "ag_002",
192
+ "ag_003",
193
+ "ag_004",
194
+ "ag_005",
195
+ "ag_006",
196
+ "ag_007",
197
+ "ag_008",
198
+ "ag_009",
199
+ "ah_000",
200
+ "ai_000",
201
+ "aj_000",
202
+ "al_000",
203
+ "am_0",
204
+ "an_000",
205
+ "ao_000",
206
+ "ap_000",
207
+ "aq_000",
208
+ "ar_000",
209
+ "at_000",
210
+ "av_000",
211
+ "ax_000",
212
+ "ay_003",
213
+ "ay_004",
214
+ "ay_005",
215
+ "ay_006",
216
+ "ay_007",
217
+ "ay_008",
218
+ "az_000",
219
+ "az_001",
220
+ "az_002",
221
+ "az_003",
222
+ "az_004",
223
+ "az_005",
224
+ "az_006",
225
+ "az_007",
226
+ "az_008",
227
+ "az_009",
228
+ "ba_000",
229
+ "ba_001",
230
+ "ba_002",
231
+ "ba_003",
232
+ "ba_004",
233
+ "ba_005",
234
+ "ba_006",
235
+ "ba_007",
236
+ "ba_008",
237
+ "ba_009",
238
+ "bb_000",
239
+ "bc_000",
240
+ "bd_000",
241
+ "be_000",
242
+ "bf_000",
243
+ "bg_000",
244
+ "bh_000",
245
+ "bi_000",
246
+ "bj_000",
247
+ "bk_000",
248
+ "bl_000",
249
+ "bm_000",
250
+ "bn_000",
251
+ "bo_000",
252
+ "bp_000",
253
+ "bq_000",
254
+ "br_000",
255
+ "bs_000",
256
+ "bt_000",
257
+ "bu_000",
258
+ "bv_000",
259
+ "bx_000",
260
+ "by_000",
261
+ "bz_000",
262
+ "ca_000",
263
+ "cb_000",
264
+ "cc_000",
265
+ "cd_000",
266
+ "ce_000",
267
+ "cf_000",
268
+ "cg_000",
269
+ "ci_000",
270
+ "cj_000",
271
+ "ck_000",
272
+ "cl_000",
273
+ "cm_000",
274
+ "cn_000",
275
+ "cn_001",
276
+ "cn_002",
277
+ "cn_003",
278
+ "cn_004",
279
+ "cn_005",
280
+ "cn_006",
281
+ "cn_007",
282
+ "cn_008",
283
+ "cn_009",
284
+ "co_000",
285
+ "cp_000",
286
+ "cq_000",
287
+ "cs_000",
288
+ "cs_001",
289
+ "cs_002",
290
+ "cs_003",
291
+ "cs_004",
292
+ "cs_005",
293
+ "cs_006",
294
+ "cs_007",
295
+ "cs_008",
296
+ "cs_009",
297
+ "ct_000",
298
+ "cu_000",
299
+ "cv_000",
300
+ "cx_000",
301
+ "cy_000",
302
+ "cz_000",
303
+ "db_000",
304
+ "dc_000",
305
+ "dd_000",
306
+ "de_000",
307
+ "dg_000",
308
+ "dh_000",
309
+ "di_000",
310
+ "dn_000",
311
+ "do_000",
312
+ "dp_000",
313
+ "dq_000",
314
+ "dr_000",
315
+ "ds_000",
316
+ "dt_000",
317
+ "du_000",
318
+ "dv_000",
319
+ "dx_000",
320
+ "dy_000",
321
+ "eb_000",
322
+ "ec_00",
323
+ "ed_000",
324
+ "ee_000",
325
+ "ee_001",
326
+ "ee_002",
327
+ "ee_003",
328
+ "ee_004",
329
+ "ee_005",
330
+ "ee_006",
331
+ "ee_007",
332
+ "ee_008",
333
+ "ee_009",
334
+ "ag_000",
335
+ "ag_001",
336
+ "ak_000",
337
+ "as_000",
338
+ "au_000",
339
+ "ay_000",
340
+ "ay_001",
341
+ "ay_002",
342
+ "ay_009",
343
+ "ch_000",
344
+ "cr_000",
345
+ "da_000",
346
+ "df_000",
347
+ "dj_000",
348
+ "dk_000",
349
+ "dl_000",
350
+ "dm_000",
351
+ "dz_000",
352
+ "ea_000",
353
+ "ef_000",
354
+ "eg_000",
355
+ "class"
356
+ ],
357
+ "num_classes": 2
358
+ }
syntheticFail/n18/tabddpm/tabddpm-n18-20260510_215518/data/y_train.npy ADDED
@@ -0,0 +1,3 @@
 
 
 
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:8b9c91d04d23109885310c16bb8d0319932adf22f5bf372f9a5c08448834d702
3
+ size 486528
syntheticFail/n18/tabddpm/tabddpm-n18-20260510_215518/input_snapshot.json ADDED
@@ -0,0 +1,36 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "dataset_id": "n18",
3
+ "model": "tabddpm",
4
+ "inputs": {
5
+ "train_csv": {
6
+ "path": "/data/jialinzhang/SynthesizePipeline-server/DatasetNew/n18/n18-train.csv",
7
+ "exists": true,
8
+ "size": 43546804,
9
+ "sha256": "9fe631ab9b0a3e358958940bc941091f78d50a4be42dbc27bada9ac381f79a22"
10
+ },
11
+ "val_csv": {
12
+ "path": "/data/jialinzhang/SynthesizePipeline-server/DatasetNew/n18/n18-val.csv",
13
+ "exists": true,
14
+ "size": 5451301,
15
+ "sha256": "bfa2c19dd55d129999f8bd416d752bd3f27534e96e64e3470db882c46e0bebb3"
16
+ },
17
+ "test_csv": {
18
+ "path": "/data/jialinzhang/SynthesizePipeline-server/DatasetNew/n18/n18-test.csv",
19
+ "exists": true,
20
+ "size": 5456707,
21
+ "sha256": "f55b07dcf84260883a57d80bad1f14f4ae16c9129048c13ed6816c5ffe7f4176"
22
+ },
23
+ "profile_json": {
24
+ "path": "/data/jialinzhang/SynthesizePipeline-server/DatasetNew/artifacts/data_core/tabular/n18/n18-dataset_profile.json",
25
+ "exists": true,
26
+ "size": 62077,
27
+ "sha256": "5dfda6a9673ce8e970b607e1c6eb8ba52f2cc61f2baeb4e915d6d3f58a1c3524"
28
+ },
29
+ "contract_json": {
30
+ "path": "/data/jialinzhang/SynthesizePipeline-server/DatasetNew/artifacts/data_core/tabular/n18/n18-dataset_contract_v1.json",
31
+ "exists": true,
32
+ "size": 84071,
33
+ "sha256": "450559cfe489a1776130310b2afe2fc8e69e57522c5f146a364cb706374bdf32"
34
+ }
35
+ }
36
+ }
syntheticFail/n18/tabddpm/tabddpm-n18-20260510_215518/public_gate/normalized_schema_snapshot.json ADDED
@@ -0,0 +1,3926 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "dataset_id": "n18",
3
+ "target_column": "class",
4
+ "task_type": "classification",
5
+ "columns": [
6
+ {
7
+ "name": "class",
8
+ "role": "target",
9
+ "semantic_type": "categorical",
10
+ "nullable": false,
11
+ "missing_tokens": [],
12
+ "parse_format": null,
13
+ "impute_strategy": "mode",
14
+ "profile_stats": {
15
+ "missing_rate": 0.0,
16
+ "unique_count": 2,
17
+ "unique_ratio": 3.3e-05,
18
+ "example_values": [
19
+ "neg",
20
+ "pos"
21
+ ]
22
+ }
23
+ },
24
+ {
25
+ "name": "aa_000",
26
+ "role": "feature",
27
+ "semantic_type": "numeric",
28
+ "nullable": false,
29
+ "missing_tokens": [],
30
+ "parse_format": null,
31
+ "impute_strategy": "median",
32
+ "profile_stats": {
33
+ "missing_rate": 0.0,
34
+ "unique_count": 20000,
35
+ "unique_ratio": 0.328947,
36
+ "example_values": [
37
+ "1656",
38
+ "118600",
39
+ "130",
40
+ "37016",
41
+ "32930"
42
+ ]
43
+ }
44
+ },
45
+ {
46
+ "name": "ab_000",
47
+ "role": "feature",
48
+ "semantic_type": "numeric",
49
+ "nullable": true,
50
+ "missing_tokens": [
51
+ "na"
52
+ ],
53
+ "parse_format": null,
54
+ "impute_strategy": "median",
55
+ "profile_stats": {
56
+ "missing_rate": 0.772253,
57
+ "unique_count": 30,
58
+ "unique_ratio": 0.002167,
59
+ "example_values": [
60
+ "0",
61
+ "2",
62
+ "4",
63
+ "58",
64
+ "18"
65
+ ]
66
+ }
67
+ },
68
+ {
69
+ "name": "ac_000",
70
+ "role": "feature",
71
+ "semantic_type": "numeric",
72
+ "nullable": true,
73
+ "missing_tokens": [
74
+ "na"
75
+ ],
76
+ "parse_format": null,
77
+ "impute_strategy": "median",
78
+ "profile_stats": {
79
+ "missing_rate": 0.055691,
80
+ "unique_count": 2095,
81
+ "unique_ratio": 0.036489,
82
+ "example_values": [
83
+ "126",
84
+ "0",
85
+ "76",
86
+ "1204",
87
+ "2130706432"
88
+ ]
89
+ }
90
+ },
91
+ {
92
+ "name": "ad_000",
93
+ "role": "feature",
94
+ "semantic_type": "numeric",
95
+ "nullable": true,
96
+ "missing_tokens": [
97
+ "na"
98
+ ],
99
+ "parse_format": null,
100
+ "impute_strategy": "median",
101
+ "profile_stats": {
102
+ "missing_rate": 0.246727,
103
+ "unique_count": 1897,
104
+ "unique_ratio": 0.04142,
105
+ "example_values": [
106
+ "118",
107
+ "68",
108
+ "952",
109
+ "1484",
110
+ "24"
111
+ ]
112
+ }
113
+ },
114
+ {
115
+ "name": "ae_000",
116
+ "role": "feature",
117
+ "semantic_type": "numeric",
118
+ "nullable": true,
119
+ "missing_tokens": [
120
+ "na"
121
+ ],
122
+ "parse_format": null,
123
+ "impute_strategy": "median",
124
+ "profile_stats": {
125
+ "missing_rate": 0.041727,
126
+ "unique_count": 324,
127
+ "unique_ratio": 0.005561,
128
+ "example_values": [
129
+ "0",
130
+ "120",
131
+ "2",
132
+ "58",
133
+ "74"
134
+ ]
135
+ }
136
+ },
137
+ {
138
+ "name": "af_000",
139
+ "role": "feature",
140
+ "semantic_type": "numeric",
141
+ "nullable": true,
142
+ "missing_tokens": [
143
+ "na"
144
+ ],
145
+ "parse_format": null,
146
+ "impute_strategy": "median",
147
+ "profile_stats": {
148
+ "missing_rate": 0.041727,
149
+ "unique_count": 418,
150
+ "unique_ratio": 0.007174,
151
+ "example_values": [
152
+ "0",
153
+ "214",
154
+ "2",
155
+ "98",
156
+ "608"
157
+ ]
158
+ }
159
+ },
160
+ {
161
+ "name": "ag_000",
162
+ "role": "feature",
163
+ "semantic_type": "boolean",
164
+ "nullable": true,
165
+ "missing_tokens": [
166
+ "na"
167
+ ],
168
+ "parse_format": null,
169
+ "impute_strategy": "mode",
170
+ "profile_stats": {
171
+ "missing_rate": 0.011382,
172
+ "unique_count": 166,
173
+ "unique_ratio": 0.002762,
174
+ "example_values": [
175
+ "0",
176
+ "228",
177
+ "318",
178
+ "6554",
179
+ "10"
180
+ ]
181
+ }
182
+ },
183
+ {
184
+ "name": "ag_001",
185
+ "role": "feature",
186
+ "semantic_type": "boolean",
187
+ "nullable": true,
188
+ "missing_tokens": [
189
+ "na"
190
+ ],
191
+ "parse_format": null,
192
+ "impute_strategy": "mode",
193
+ "profile_stats": {
194
+ "missing_rate": 0.011382,
195
+ "unique_count": 659,
196
+ "unique_ratio": 0.010964,
197
+ "example_values": [
198
+ "0",
199
+ "2276",
200
+ "102",
201
+ "32",
202
+ "5128"
203
+ ]
204
+ }
205
+ },
206
+ {
207
+ "name": "ag_002",
208
+ "role": "feature",
209
+ "semantic_type": "numeric",
210
+ "nullable": true,
211
+ "missing_tokens": [
212
+ "na"
213
+ ],
214
+ "parse_format": null,
215
+ "impute_strategy": "median",
216
+ "profile_stats": {
217
+ "missing_rate": 0.011382,
218
+ "unique_count": 2456,
219
+ "unique_ratio": 0.04086,
220
+ "example_values": [
221
+ "0",
222
+ "108",
223
+ "38",
224
+ "5274",
225
+ "292"
226
+ ]
227
+ }
228
+ },
229
+ {
230
+ "name": "ag_003",
231
+ "role": "feature",
232
+ "semantic_type": "numeric",
233
+ "nullable": true,
234
+ "missing_tokens": [
235
+ "na"
236
+ ],
237
+ "parse_format": null,
238
+ "impute_strategy": "median",
239
+ "profile_stats": {
240
+ "missing_rate": 0.011382,
241
+ "unique_count": 7967,
242
+ "unique_ratio": 0.132545,
243
+ "example_values": [
244
+ "0",
245
+ "8608",
246
+ "4038",
247
+ "2450",
248
+ "548"
249
+ ]
250
+ }
251
+ },
252
+ {
253
+ "name": "ag_004",
254
+ "role": "feature",
255
+ "semantic_type": "numeric",
256
+ "nullable": true,
257
+ "missing_tokens": [
258
+ "na"
259
+ ],
260
+ "parse_format": null,
261
+ "impute_strategy": "median",
262
+ "profile_stats": {
263
+ "missing_rate": 0.011382,
264
+ "unique_count": 20000,
265
+ "unique_ratio": 0.332734,
266
+ "example_values": [
267
+ "98",
268
+ "2346",
269
+ "16590",
270
+ "14782",
271
+ "204"
272
+ ]
273
+ }
274
+ },
275
+ {
276
+ "name": "ag_005",
277
+ "role": "feature",
278
+ "semantic_type": "numeric",
279
+ "nullable": true,
280
+ "missing_tokens": [
281
+ "na"
282
+ ],
283
+ "parse_format": null,
284
+ "impute_strategy": "median",
285
+ "profile_stats": {
286
+ "missing_rate": 0.011382,
287
+ "unique_count": 20000,
288
+ "unique_ratio": 0.332734,
289
+ "example_values": [
290
+ "54",
291
+ "853922",
292
+ "7546",
293
+ "701688",
294
+ "79236"
295
+ ]
296
+ }
297
+ },
298
+ {
299
+ "name": "ag_006",
300
+ "role": "feature",
301
+ "semantic_type": "numeric",
302
+ "nullable": true,
303
+ "missing_tokens": [
304
+ "na"
305
+ ],
306
+ "parse_format": null,
307
+ "impute_strategy": "median",
308
+ "profile_stats": {
309
+ "missing_rate": 0.011382,
310
+ "unique_count": 20000,
311
+ "unique_ratio": 0.332734,
312
+ "example_values": [
313
+ "90380",
314
+ "4077182",
315
+ "2252",
316
+ "1212560",
317
+ "1555662"
318
+ ]
319
+ }
320
+ },
321
+ {
322
+ "name": "ag_007",
323
+ "role": "feature",
324
+ "semantic_type": "numeric",
325
+ "nullable": true,
326
+ "missing_tokens": [
327
+ "na"
328
+ ],
329
+ "parse_format": null,
330
+ "impute_strategy": "median",
331
+ "profile_stats": {
332
+ "missing_rate": 0.011382,
333
+ "unique_count": 20000,
334
+ "unique_ratio": 0.332734,
335
+ "example_values": [
336
+ "7952",
337
+ "940762",
338
+ "0",
339
+ "330356",
340
+ "939740"
341
+ ]
342
+ }
343
+ },
344
+ {
345
+ "name": "ag_008",
346
+ "role": "feature",
347
+ "semantic_type": "numeric",
348
+ "nullable": true,
349
+ "missing_tokens": [
350
+ "na"
351
+ ],
352
+ "parse_format": null,
353
+ "impute_strategy": "median",
354
+ "profile_stats": {
355
+ "missing_rate": 0.011382,
356
+ "unique_count": 19086,
357
+ "unique_ratio": 0.317528,
358
+ "example_values": [
359
+ "0",
360
+ "19120",
361
+ "8670",
362
+ "44210",
363
+ "23162"
364
+ ]
365
+ }
366
+ },
367
+ {
368
+ "name": "ag_009",
369
+ "role": "feature",
370
+ "semantic_type": "numeric",
371
+ "nullable": true,
372
+ "missing_tokens": [
373
+ "na"
374
+ ],
375
+ "parse_format": null,
376
+ "impute_strategy": "median",
377
+ "profile_stats": {
378
+ "missing_rate": 0.011382,
379
+ "unique_count": 5398,
380
+ "unique_ratio": 0.089805,
381
+ "example_values": [
382
+ "0",
383
+ "316",
384
+ "1758",
385
+ "576",
386
+ "552"
387
+ ]
388
+ }
389
+ },
390
+ {
391
+ "name": "ah_000",
392
+ "role": "feature",
393
+ "semantic_type": "numeric",
394
+ "nullable": true,
395
+ "missing_tokens": [
396
+ "na"
397
+ ],
398
+ "parse_format": null,
399
+ "impute_strategy": "median",
400
+ "profile_stats": {
401
+ "missing_rate": 0.010559,
402
+ "unique_count": 20000,
403
+ "unique_ratio": 0.332458,
404
+ "example_values": [
405
+ "36080",
406
+ "3165022",
407
+ "10518",
408
+ "1060220",
409
+ "1167164"
410
+ ]
411
+ }
412
+ },
413
+ {
414
+ "name": "ai_000",
415
+ "role": "feature",
416
+ "semantic_type": "numeric",
417
+ "nullable": true,
418
+ "missing_tokens": [
419
+ "na"
420
+ ],
421
+ "parse_format": null,
422
+ "impute_strategy": "median",
423
+ "profile_stats": {
424
+ "missing_rate": 0.01023,
425
+ "unique_count": 4180,
426
+ "unique_ratio": 0.069461,
427
+ "example_values": [
428
+ "0",
429
+ "918",
430
+ "3658",
431
+ "10814",
432
+ "2628"
433
+ ]
434
+ }
435
+ },
436
+ {
437
+ "name": "aj_000",
438
+ "role": "feature",
439
+ "semantic_type": "numeric",
440
+ "nullable": true,
441
+ "missing_tokens": [
442
+ "na"
443
+ ],
444
+ "parse_format": null,
445
+ "impute_strategy": "median",
446
+ "profile_stats": {
447
+ "missing_rate": 0.01023,
448
+ "unique_count": 913,
449
+ "unique_ratio": 0.015172,
450
+ "example_values": [
451
+ "0",
452
+ "114",
453
+ "146",
454
+ "58",
455
+ "70"
456
+ ]
457
+ }
458
+ },
459
+ {
460
+ "name": "ak_000",
461
+ "role": "feature",
462
+ "semantic_type": "boolean",
463
+ "nullable": true,
464
+ "missing_tokens": [
465
+ "na"
466
+ ],
467
+ "parse_format": null,
468
+ "impute_strategy": "mode",
469
+ "profile_stats": {
470
+ "missing_rate": 0.072632,
471
+ "unique_count": 169,
472
+ "unique_ratio": 0.002997,
473
+ "example_values": [
474
+ "0",
475
+ "1840",
476
+ "142646",
477
+ "1124",
478
+ "2130"
479
+ ]
480
+ }
481
+ },
482
+ {
483
+ "name": "al_000",
484
+ "role": "feature",
485
+ "semantic_type": "numeric",
486
+ "nullable": true,
487
+ "missing_tokens": [
488
+ "na"
489
+ ],
490
+ "parse_format": null,
491
+ "impute_strategy": "median",
492
+ "profile_stats": {
493
+ "missing_rate": 0.010526,
494
+ "unique_count": 9127,
495
+ "unique_ratio": 0.151712,
496
+ "example_values": [
497
+ "0",
498
+ "5610",
499
+ "2",
500
+ "5636",
501
+ "2068"
502
+ ]
503
+ }
504
+ },
505
+ {
506
+ "name": "am_0",
507
+ "role": "feature",
508
+ "semantic_type": "numeric",
509
+ "nullable": true,
510
+ "missing_tokens": [
511
+ "na"
512
+ ],
513
+ "parse_format": null,
514
+ "impute_strategy": "median",
515
+ "profile_stats": {
516
+ "missing_rate": 0.01023,
517
+ "unique_count": 10700,
518
+ "unique_ratio": 0.177806,
519
+ "example_values": [
520
+ "0",
521
+ "10568",
522
+ "112",
523
+ "8558",
524
+ "3108"
525
+ ]
526
+ }
527
+ },
528
+ {
529
+ "name": "an_000",
530
+ "role": "feature",
531
+ "semantic_type": "numeric",
532
+ "nullable": true,
533
+ "missing_tokens": [
534
+ "na"
535
+ ],
536
+ "parse_format": null,
537
+ "impute_strategy": "median",
538
+ "profile_stats": {
539
+ "missing_rate": 0.010526,
540
+ "unique_count": 20000,
541
+ "unique_ratio": 0.332447,
542
+ "example_values": [
543
+ "89692",
544
+ "5651638",
545
+ "27644",
546
+ "2094250",
547
+ "2398938"
548
+ ]
549
+ }
550
+ },
551
+ {
552
+ "name": "ao_000",
553
+ "role": "feature",
554
+ "semantic_type": "numeric",
555
+ "nullable": true,
556
+ "missing_tokens": [
557
+ "na"
558
+ ],
559
+ "parse_format": null,
560
+ "impute_strategy": "median",
561
+ "profile_stats": {
562
+ "missing_rate": 0.009622,
563
+ "unique_count": 20000,
564
+ "unique_ratio": 0.332143,
565
+ "example_values": [
566
+ "79230",
567
+ "5400370",
568
+ "22286",
569
+ "1841978",
570
+ "2056840"
571
+ ]
572
+ }
573
+ },
574
+ {
575
+ "name": "ap_000",
576
+ "role": "feature",
577
+ "semantic_type": "numeric",
578
+ "nullable": true,
579
+ "missing_tokens": [
580
+ "na"
581
+ ],
582
+ "parse_format": null,
583
+ "impute_strategy": "median",
584
+ "profile_stats": {
585
+ "missing_rate": 0.010526,
586
+ "unique_count": 20000,
587
+ "unique_ratio": 0.332447,
588
+ "example_values": [
589
+ "15174",
590
+ "401448",
591
+ "28834",
592
+ "827808",
593
+ "632288"
594
+ ]
595
+ }
596
+ },
597
+ {
598
+ "name": "aq_000",
599
+ "role": "feature",
600
+ "semantic_type": "numeric",
601
+ "nullable": true,
602
+ "missing_tokens": [
603
+ "na"
604
+ ],
605
+ "parse_format": null,
606
+ "impute_strategy": "median",
607
+ "profile_stats": {
608
+ "missing_rate": 0.009622,
609
+ "unique_count": 20000,
610
+ "unique_ratio": 0.332143,
611
+ "example_values": [
612
+ "7856",
613
+ "174492",
614
+ "4192",
615
+ "211098",
616
+ "281914"
617
+ ]
618
+ }
619
+ },
620
+ {
621
+ "name": "ar_000",
622
+ "role": "feature",
623
+ "semantic_type": "numeric",
624
+ "nullable": true,
625
+ "missing_tokens": [
626
+ "na"
627
+ ],
628
+ "parse_format": null,
629
+ "impute_strategy": "median",
630
+ "profile_stats": {
631
+ "missing_rate": 0.045691,
632
+ "unique_count": 66,
633
+ "unique_ratio": 0.001137,
634
+ "example_values": [
635
+ "0",
636
+ "6",
637
+ "4",
638
+ "2",
639
+ "8"
640
+ ]
641
+ }
642
+ },
643
+ {
644
+ "name": "as_000",
645
+ "role": "feature",
646
+ "semantic_type": "boolean",
647
+ "nullable": true,
648
+ "missing_tokens": [
649
+ "na"
650
+ ],
651
+ "parse_format": null,
652
+ "impute_strategy": "mode",
653
+ "profile_stats": {
654
+ "missing_rate": 0.01023,
655
+ "unique_count": 23,
656
+ "unique_ratio": 0.000382,
657
+ "example_values": [
658
+ "0",
659
+ "1150508",
660
+ "357260",
661
+ "1246190",
662
+ "13752"
663
+ ]
664
+ }
665
+ },
666
+ {
667
+ "name": "at_000",
668
+ "role": "feature",
669
+ "semantic_type": "numeric",
670
+ "nullable": true,
671
+ "missing_tokens": [
672
+ "na"
673
+ ],
674
+ "parse_format": null,
675
+ "impute_strategy": "median",
676
+ "profile_stats": {
677
+ "missing_rate": 0.01023,
678
+ "unique_count": 3514,
679
+ "unique_ratio": 0.058393,
680
+ "example_values": [
681
+ "0",
682
+ "2202",
683
+ "26602",
684
+ "2968",
685
+ "2656"
686
+ ]
687
+ }
688
+ },
689
+ {
690
+ "name": "au_000",
691
+ "role": "feature",
692
+ "semantic_type": "boolean",
693
+ "nullable": true,
694
+ "missing_tokens": [
695
+ "na"
696
+ ],
697
+ "parse_format": null,
698
+ "impute_strategy": "mode",
699
+ "profile_stats": {
700
+ "missing_rate": 0.01023,
701
+ "unique_count": 55,
702
+ "unique_ratio": 0.000914,
703
+ "example_values": [
704
+ "0",
705
+ "748658",
706
+ "729144",
707
+ "588396",
708
+ "1248"
709
+ ]
710
+ }
711
+ },
712
+ {
713
+ "name": "av_000",
714
+ "role": "feature",
715
+ "semantic_type": "numeric",
716
+ "nullable": true,
717
+ "missing_tokens": [
718
+ "na"
719
+ ],
720
+ "parse_format": null,
721
+ "impute_strategy": "median",
722
+ "profile_stats": {
723
+ "missing_rate": 0.041727,
724
+ "unique_count": 3875,
725
+ "unique_ratio": 0.066509,
726
+ "example_values": [
727
+ "234",
728
+ "0",
729
+ "130",
730
+ "456",
731
+ "5754"
732
+ ]
733
+ }
734
+ },
735
+ {
736
+ "name": "ax_000",
737
+ "role": "feature",
738
+ "semantic_type": "numeric",
739
+ "nullable": true,
740
+ "missing_tokens": [
741
+ "na"
742
+ ],
743
+ "parse_format": null,
744
+ "impute_strategy": "median",
745
+ "profile_stats": {
746
+ "missing_rate": 0.041743,
747
+ "unique_count": 2244,
748
+ "unique_ratio": 0.038516,
749
+ "example_values": [
750
+ "66",
751
+ "0",
752
+ "138",
753
+ "1918",
754
+ "896"
755
+ ]
756
+ }
757
+ },
758
+ {
759
+ "name": "ay_000",
760
+ "role": "feature",
761
+ "semantic_type": "boolean",
762
+ "nullable": true,
763
+ "missing_tokens": [
764
+ "na"
765
+ ],
766
+ "parse_format": null,
767
+ "impute_strategy": "mode",
768
+ "profile_stats": {
769
+ "missing_rate": 0.011431,
770
+ "unique_count": 475,
771
+ "unique_ratio": 0.007903,
772
+ "example_values": [
773
+ "0",
774
+ "40584",
775
+ "38258",
776
+ "24630",
777
+ "32330"
778
+ ]
779
+ }
780
+ },
781
+ {
782
+ "name": "ay_001",
783
+ "role": "feature",
784
+ "semantic_type": "boolean",
785
+ "nullable": true,
786
+ "missing_tokens": [
787
+ "na"
788
+ ],
789
+ "parse_format": null,
790
+ "impute_strategy": "mode",
791
+ "profile_stats": {
792
+ "missing_rate": 0.011431,
793
+ "unique_count": 925,
794
+ "unique_ratio": 0.01539,
795
+ "example_values": [
796
+ "0",
797
+ "958",
798
+ "4894",
799
+ "17568",
800
+ "18570"
801
+ ]
802
+ }
803
+ },
804
+ {
805
+ "name": "ay_002",
806
+ "role": "feature",
807
+ "semantic_type": "boolean",
808
+ "nullable": true,
809
+ "missing_tokens": [
810
+ "na"
811
+ ],
812
+ "parse_format": null,
813
+ "impute_strategy": "mode",
814
+ "profile_stats": {
815
+ "missing_rate": 0.011431,
816
+ "unique_count": 995,
817
+ "unique_ratio": 0.016554,
818
+ "example_values": [
819
+ "0",
820
+ "4798",
821
+ "8256",
822
+ "15402",
823
+ "11316"
824
+ ]
825
+ }
826
+ },
827
+ {
828
+ "name": "ay_003",
829
+ "role": "feature",
830
+ "semantic_type": "numeric",
831
+ "nullable": true,
832
+ "missing_tokens": [
833
+ "na"
834
+ ],
835
+ "parse_format": null,
836
+ "impute_strategy": "median",
837
+ "profile_stats": {
838
+ "missing_rate": 0.011431,
839
+ "unique_count": 1038,
840
+ "unique_ratio": 0.01727,
841
+ "example_values": [
842
+ "0",
843
+ "5084",
844
+ "5736",
845
+ "7764",
846
+ "22594"
847
+ ]
848
+ }
849
+ },
850
+ {
851
+ "name": "ay_004",
852
+ "role": "feature",
853
+ "semantic_type": "numeric",
854
+ "nullable": true,
855
+ "missing_tokens": [
856
+ "na"
857
+ ],
858
+ "parse_format": null,
859
+ "impute_strategy": "median",
860
+ "profile_stats": {
861
+ "missing_rate": 0.011431,
862
+ "unique_count": 1770,
863
+ "unique_ratio": 0.029448,
864
+ "example_values": [
865
+ "0",
866
+ "10492",
867
+ "13892",
868
+ "1230",
869
+ "8894"
870
+ ]
871
+ }
872
+ },
873
+ {
874
+ "name": "ay_005",
875
+ "role": "feature",
876
+ "semantic_type": "numeric",
877
+ "nullable": true,
878
+ "missing_tokens": [
879
+ "na"
880
+ ],
881
+ "parse_format": null,
882
+ "impute_strategy": "median",
883
+ "profile_stats": {
884
+ "missing_rate": 0.011431,
885
+ "unique_count": 19817,
886
+ "unique_ratio": 0.329706,
887
+ "example_values": [
888
+ "0",
889
+ "60878",
890
+ "51752",
891
+ "40934",
892
+ "32600"
893
+ ]
894
+ }
895
+ },
896
+ {
897
+ "name": "ay_006",
898
+ "role": "feature",
899
+ "semantic_type": "numeric",
900
+ "nullable": true,
901
+ "missing_tokens": [
902
+ "na"
903
+ ],
904
+ "parse_format": null,
905
+ "impute_strategy": "median",
906
+ "profile_stats": {
907
+ "missing_rate": 0.011431,
908
+ "unique_count": 20000,
909
+ "unique_ratio": 0.332751,
910
+ "example_values": [
911
+ "83150",
912
+ "2211302",
913
+ "0",
914
+ "936702",
915
+ "450836"
916
+ ]
917
+ }
918
+ },
919
+ {
920
+ "name": "ay_007",
921
+ "role": "feature",
922
+ "semantic_type": "numeric",
923
+ "nullable": true,
924
+ "missing_tokens": [
925
+ "na"
926
+ ],
927
+ "parse_format": null,
928
+ "impute_strategy": "median",
929
+ "profile_stats": {
930
+ "missing_rate": 0.011431,
931
+ "unique_count": 20000,
932
+ "unique_ratio": 0.332751,
933
+ "example_values": [
934
+ "15332",
935
+ "3607098",
936
+ "5444",
937
+ "614794",
938
+ "1811692"
939
+ ]
940
+ }
941
+ },
942
+ {
943
+ "name": "ay_008",
944
+ "role": "feature",
945
+ "semantic_type": "numeric",
946
+ "nullable": true,
947
+ "missing_tokens": [
948
+ "na"
949
+ ],
950
+ "parse_format": null,
951
+ "impute_strategy": "median",
952
+ "profile_stats": {
953
+ "missing_rate": 0.011431,
954
+ "unique_count": 20000,
955
+ "unique_ratio": 0.332751,
956
+ "example_values": [
957
+ "2",
958
+ "14054",
959
+ "29552",
960
+ "664808",
961
+ "315906"
962
+ ]
963
+ }
964
+ },
965
+ {
966
+ "name": "ay_009",
967
+ "role": "feature",
968
+ "semantic_type": "boolean",
969
+ "nullable": true,
970
+ "missing_tokens": [
971
+ "na"
972
+ ],
973
+ "parse_format": null,
974
+ "impute_strategy": "mode",
975
+ "profile_stats": {
976
+ "missing_rate": 0.011431,
977
+ "unique_count": 457,
978
+ "unique_ratio": 0.007603,
979
+ "example_values": [
980
+ "0",
981
+ "118",
982
+ "1272",
983
+ "36954",
984
+ "5292"
985
+ ]
986
+ }
987
+ },
988
+ {
989
+ "name": "az_000",
990
+ "role": "feature",
991
+ "semantic_type": "numeric",
992
+ "nullable": true,
993
+ "missing_tokens": [
994
+ "na"
995
+ ],
996
+ "parse_format": null,
997
+ "impute_strategy": "median",
998
+ "profile_stats": {
999
+ "missing_rate": 0.011431,
1000
+ "unique_count": 9275,
1001
+ "unique_ratio": 0.154313,
1002
+ "example_values": [
1003
+ "110",
1004
+ "16710",
1005
+ "240",
1006
+ "1184",
1007
+ "2258"
1008
+ ]
1009
+ }
1010
+ },
1011
+ {
1012
+ "name": "az_001",
1013
+ "role": "feature",
1014
+ "semantic_type": "numeric",
1015
+ "nullable": true,
1016
+ "missing_tokens": [
1017
+ "na"
1018
+ ],
1019
+ "parse_format": null,
1020
+ "impute_strategy": "median",
1021
+ "profile_stats": {
1022
+ "missing_rate": 0.011431,
1023
+ "unique_count": 7402,
1024
+ "unique_ratio": 0.123151,
1025
+ "example_values": [
1026
+ "48",
1027
+ "890",
1028
+ "18",
1029
+ "450",
1030
+ "1596"
1031
+ ]
1032
+ }
1033
+ },
1034
+ {
1035
+ "name": "az_002",
1036
+ "role": "feature",
1037
+ "semantic_type": "numeric",
1038
+ "nullable": true,
1039
+ "missing_tokens": [
1040
+ "na"
1041
+ ],
1042
+ "parse_format": null,
1043
+ "impute_strategy": "median",
1044
+ "profile_stats": {
1045
+ "missing_rate": 0.011431,
1046
+ "unique_count": 9145,
1047
+ "unique_ratio": 0.15215,
1048
+ "example_values": [
1049
+ "46",
1050
+ "1344",
1051
+ "26",
1052
+ "1590",
1053
+ "1638"
1054
+ ]
1055
+ }
1056
+ },
1057
+ {
1058
+ "name": "az_003",
1059
+ "role": "feature",
1060
+ "semantic_type": "numeric",
1061
+ "nullable": true,
1062
+ "missing_tokens": [
1063
+ "na"
1064
+ ],
1065
+ "parse_format": null,
1066
+ "impute_strategy": "median",
1067
+ "profile_stats": {
1068
+ "missing_rate": 0.011431,
1069
+ "unique_count": 20000,
1070
+ "unique_ratio": 0.332751,
1071
+ "example_values": [
1072
+ "150",
1073
+ "3706",
1074
+ "1484",
1075
+ "143218",
1076
+ "2218"
1077
+ ]
1078
+ }
1079
+ },
1080
+ {
1081
+ "name": "az_004",
1082
+ "role": "feature",
1083
+ "semantic_type": "numeric",
1084
+ "nullable": true,
1085
+ "missing_tokens": [
1086
+ "na"
1087
+ ],
1088
+ "parse_format": null,
1089
+ "impute_strategy": "median",
1090
+ "profile_stats": {
1091
+ "missing_rate": 0.011431,
1092
+ "unique_count": 20000,
1093
+ "unique_ratio": 0.332751,
1094
+ "example_values": [
1095
+ "68536",
1096
+ "2497690",
1097
+ "576",
1098
+ "1839284",
1099
+ "109860"
1100
+ ]
1101
+ }
1102
+ },
1103
+ {
1104
+ "name": "az_005",
1105
+ "role": "feature",
1106
+ "semantic_type": "numeric",
1107
+ "nullable": true,
1108
+ "missing_tokens": [
1109
+ "na"
1110
+ ],
1111
+ "parse_format": null,
1112
+ "impute_strategy": "median",
1113
+ "profile_stats": {
1114
+ "missing_rate": 0.011431,
1115
+ "unique_count": 20000,
1116
+ "unique_ratio": 0.332751,
1117
+ "example_values": [
1118
+ "29594",
1119
+ "3371368",
1120
+ "4110",
1121
+ "282298",
1122
+ "2499914"
1123
+ ]
1124
+ }
1125
+ },
1126
+ {
1127
+ "name": "az_006",
1128
+ "role": "feature",
1129
+ "semantic_type": "numeric",
1130
+ "nullable": true,
1131
+ "missing_tokens": [
1132
+ "na"
1133
+ ],
1134
+ "parse_format": null,
1135
+ "impute_strategy": "median",
1136
+ "profile_stats": {
1137
+ "missing_rate": 0.011431,
1138
+ "unique_count": 12398,
1139
+ "unique_ratio": 0.206272,
1140
+ "example_values": [
1141
+ "0",
1142
+ "1624",
1143
+ "16918",
1144
+ "32",
1145
+ "1884"
1146
+ ]
1147
+ }
1148
+ },
1149
+ {
1150
+ "name": "az_007",
1151
+ "role": "feature",
1152
+ "semantic_type": "numeric",
1153
+ "nullable": true,
1154
+ "missing_tokens": [
1155
+ "na"
1156
+ ],
1157
+ "parse_format": null,
1158
+ "impute_strategy": "median",
1159
+ "profile_stats": {
1160
+ "missing_rate": 0.011431,
1161
+ "unique_count": 3863,
1162
+ "unique_ratio": 0.064271,
1163
+ "example_values": [
1164
+ "0",
1165
+ "11492",
1166
+ "4",
1167
+ "10",
1168
+ "1760"
1169
+ ]
1170
+ }
1171
+ },
1172
+ {
1173
+ "name": "az_008",
1174
+ "role": "feature",
1175
+ "semantic_type": "numeric",
1176
+ "nullable": true,
1177
+ "missing_tokens": [
1178
+ "na"
1179
+ ],
1180
+ "parse_format": null,
1181
+ "impute_strategy": "median",
1182
+ "profile_stats": {
1183
+ "missing_rate": 0.011431,
1184
+ "unique_count": 1257,
1185
+ "unique_ratio": 0.020913,
1186
+ "example_values": [
1187
+ "0",
1188
+ "132",
1189
+ "5064",
1190
+ "2998",
1191
+ "2"
1192
+ ]
1193
+ }
1194
+ },
1195
+ {
1196
+ "name": "az_009",
1197
+ "role": "feature",
1198
+ "semantic_type": "numeric",
1199
+ "nullable": true,
1200
+ "missing_tokens": [
1201
+ "na"
1202
+ ],
1203
+ "parse_format": null,
1204
+ "impute_strategy": "median",
1205
+ "profile_stats": {
1206
+ "missing_rate": 0.011431,
1207
+ "unique_count": 342,
1208
+ "unique_ratio": 0.00569,
1209
+ "example_values": [
1210
+ "0",
1211
+ "2",
1212
+ "12",
1213
+ "5240",
1214
+ "1208"
1215
+ ]
1216
+ }
1217
+ },
1218
+ {
1219
+ "name": "ba_000",
1220
+ "role": "feature",
1221
+ "semantic_type": "numeric",
1222
+ "nullable": true,
1223
+ "missing_tokens": [
1224
+ "na"
1225
+ ],
1226
+ "parse_format": null,
1227
+ "impute_strategy": "median",
1228
+ "profile_stats": {
1229
+ "missing_rate": 0.011694,
1230
+ "unique_count": 20000,
1231
+ "unique_ratio": 0.33284,
1232
+ "example_values": [
1233
+ "43510",
1234
+ "1449660",
1235
+ "27420",
1236
+ "668112",
1237
+ "1052220"
1238
+ ]
1239
+ }
1240
+ },
1241
+ {
1242
+ "name": "ba_001",
1243
+ "role": "feature",
1244
+ "semantic_type": "numeric",
1245
+ "nullable": true,
1246
+ "missing_tokens": [
1247
+ "na"
1248
+ ],
1249
+ "parse_format": null,
1250
+ "impute_strategy": "median",
1251
+ "profile_stats": {
1252
+ "missing_rate": 0.011694,
1253
+ "unique_count": 20000,
1254
+ "unique_ratio": 0.33284,
1255
+ "example_values": [
1256
+ "35882",
1257
+ "1098754",
1258
+ "3950",
1259
+ "612642",
1260
+ "641214"
1261
+ ]
1262
+ }
1263
+ },
1264
+ {
1265
+ "name": "ba_002",
1266
+ "role": "feature",
1267
+ "semantic_type": "numeric",
1268
+ "nullable": true,
1269
+ "missing_tokens": [
1270
+ "na"
1271
+ ],
1272
+ "parse_format": null,
1273
+ "impute_strategy": "median",
1274
+ "profile_stats": {
1275
+ "missing_rate": 0.011694,
1276
+ "unique_count": 20000,
1277
+ "unique_ratio": 0.33284,
1278
+ "example_values": [
1279
+ "11484",
1280
+ "583624",
1281
+ "902",
1282
+ "323232",
1283
+ "234314"
1284
+ ]
1285
+ }
1286
+ },
1287
+ {
1288
+ "name": "ba_003",
1289
+ "role": "feature",
1290
+ "semantic_type": "numeric",
1291
+ "nullable": true,
1292
+ "missing_tokens": [
1293
+ "na"
1294
+ ],
1295
+ "parse_format": null,
1296
+ "impute_strategy": "median",
1297
+ "profile_stats": {
1298
+ "missing_rate": 0.011694,
1299
+ "unique_count": 20000,
1300
+ "unique_ratio": 0.33284,
1301
+ "example_values": [
1302
+ "4784",
1303
+ "500568",
1304
+ "594",
1305
+ "220220",
1306
+ "156236"
1307
+ ]
1308
+ }
1309
+ },
1310
+ {
1311
+ "name": "ba_004",
1312
+ "role": "feature",
1313
+ "semantic_type": "numeric",
1314
+ "nullable": true,
1315
+ "missing_tokens": [
1316
+ "na"
1317
+ ],
1318
+ "parse_format": null,
1319
+ "impute_strategy": "median",
1320
+ "profile_stats": {
1321
+ "missing_rate": 0.011694,
1322
+ "unique_count": 20000,
1323
+ "unique_ratio": 0.33284,
1324
+ "example_values": [
1325
+ "1550",
1326
+ "445980",
1327
+ "524",
1328
+ "166770",
1329
+ "107440"
1330
+ ]
1331
+ }
1332
+ },
1333
+ {
1334
+ "name": "ba_005",
1335
+ "role": "feature",
1336
+ "semantic_type": "numeric",
1337
+ "nullable": true,
1338
+ "missing_tokens": [
1339
+ "na"
1340
+ ],
1341
+ "parse_format": null,
1342
+ "impute_strategy": "median",
1343
+ "profile_stats": {
1344
+ "missing_rate": 0.011694,
1345
+ "unique_count": 20000,
1346
+ "unique_ratio": 0.33284,
1347
+ "example_values": [
1348
+ "678",
1349
+ "394140",
1350
+ "308",
1351
+ "159564",
1352
+ "80012"
1353
+ ]
1354
+ }
1355
+ },
1356
+ {
1357
+ "name": "ba_006",
1358
+ "role": "feature",
1359
+ "semantic_type": "numeric",
1360
+ "nullable": true,
1361
+ "missing_tokens": [
1362
+ "na"
1363
+ ],
1364
+ "parse_format": null,
1365
+ "impute_strategy": "median",
1366
+ "profile_stats": {
1367
+ "missing_rate": 0.011694,
1368
+ "unique_count": 20000,
1369
+ "unique_ratio": 0.33284,
1370
+ "example_values": [
1371
+ "372",
1372
+ "424290",
1373
+ "1100",
1374
+ "117506",
1375
+ "90270"
1376
+ ]
1377
+ }
1378
+ },
1379
+ {
1380
+ "name": "ba_007",
1381
+ "role": "feature",
1382
+ "semantic_type": "numeric",
1383
+ "nullable": true,
1384
+ "missing_tokens": [
1385
+ "na"
1386
+ ],
1387
+ "parse_format": null,
1388
+ "impute_strategy": "median",
1389
+ "profile_stats": {
1390
+ "missing_rate": 0.011694,
1391
+ "unique_count": 20000,
1392
+ "unique_ratio": 0.33284,
1393
+ "example_values": [
1394
+ "224",
1395
+ "801640",
1396
+ "166",
1397
+ "10",
1398
+ "257660"
1399
+ ]
1400
+ }
1401
+ },
1402
+ {
1403
+ "name": "ba_008",
1404
+ "role": "feature",
1405
+ "semantic_type": "numeric",
1406
+ "nullable": true,
1407
+ "missing_tokens": [
1408
+ "na"
1409
+ ],
1410
+ "parse_format": null,
1411
+ "impute_strategy": "median",
1412
+ "profile_stats": {
1413
+ "missing_rate": 0.011694,
1414
+ "unique_count": 11894,
1415
+ "unique_ratio": 0.19794,
1416
+ "example_values": [
1417
+ "0",
1418
+ "194672",
1419
+ "26",
1420
+ "2",
1421
+ "38636"
1422
+ ]
1423
+ }
1424
+ },
1425
+ {
1426
+ "name": "ba_009",
1427
+ "role": "feature",
1428
+ "semantic_type": "numeric",
1429
+ "nullable": true,
1430
+ "missing_tokens": [
1431
+ "na"
1432
+ ],
1433
+ "parse_format": null,
1434
+ "impute_strategy": "median",
1435
+ "profile_stats": {
1436
+ "missing_rate": 0.011694,
1437
+ "unique_count": 6840,
1438
+ "unique_ratio": 0.113831,
1439
+ "example_values": [
1440
+ "0",
1441
+ "4",
1442
+ "6",
1443
+ "3288",
1444
+ "830"
1445
+ ]
1446
+ }
1447
+ },
1448
+ {
1449
+ "name": "bb_000",
1450
+ "role": "feature",
1451
+ "semantic_type": "numeric",
1452
+ "nullable": true,
1453
+ "missing_tokens": [
1454
+ "na"
1455
+ ],
1456
+ "parse_format": null,
1457
+ "impute_strategy": "median",
1458
+ "profile_stats": {
1459
+ "missing_rate": 0.010559,
1460
+ "unique_count": 20000,
1461
+ "unique_ratio": 0.332458,
1462
+ "example_values": [
1463
+ "104890",
1464
+ "6053972",
1465
+ "62144",
1466
+ "2922442",
1467
+ "3031738"
1468
+ ]
1469
+ }
1470
+ },
1471
+ {
1472
+ "name": "bc_000",
1473
+ "role": "feature",
1474
+ "semantic_type": "numeric",
1475
+ "nullable": true,
1476
+ "missing_tokens": [
1477
+ "na"
1478
+ ],
1479
+ "parse_format": null,
1480
+ "impute_strategy": "median",
1481
+ "profile_stats": {
1482
+ "missing_rate": 0.045691,
1483
+ "unique_count": 2853,
1484
+ "unique_ratio": 0.049171,
1485
+ "example_values": [
1486
+ "4",
1487
+ "0",
1488
+ "296",
1489
+ "96",
1490
+ "22"
1491
+ ]
1492
+ }
1493
+ },
1494
+ {
1495
+ "name": "bd_000",
1496
+ "role": "feature",
1497
+ "semantic_type": "numeric",
1498
+ "nullable": true,
1499
+ "missing_tokens": [
1500
+ "na"
1501
+ ],
1502
+ "parse_format": null,
1503
+ "impute_strategy": "median",
1504
+ "profile_stats": {
1505
+ "missing_rate": 0.045724,
1506
+ "unique_count": 3604,
1507
+ "unique_ratio": 0.062117,
1508
+ "example_values": [
1509
+ "6",
1510
+ "16",
1511
+ "8",
1512
+ "876",
1513
+ "1052"
1514
+ ]
1515
+ }
1516
+ },
1517
+ {
1518
+ "name": "be_000",
1519
+ "role": "feature",
1520
+ "semantic_type": "numeric",
1521
+ "nullable": true,
1522
+ "missing_tokens": [
1523
+ "na"
1524
+ ],
1525
+ "parse_format": null,
1526
+ "impute_strategy": "median",
1527
+ "profile_stats": {
1528
+ "missing_rate": 0.04176,
1529
+ "unique_count": 4000,
1530
+ "unique_ratio": 0.068657,
1531
+ "example_values": [
1532
+ "106",
1533
+ "260",
1534
+ "8",
1535
+ "266",
1536
+ "150"
1537
+ ]
1538
+ }
1539
+ },
1540
+ {
1541
+ "name": "bf_000",
1542
+ "role": "feature",
1543
+ "semantic_type": "numeric",
1544
+ "nullable": true,
1545
+ "missing_tokens": [
1546
+ "na"
1547
+ ],
1548
+ "parse_format": null,
1549
+ "impute_strategy": "median",
1550
+ "profile_stats": {
1551
+ "missing_rate": 0.041727,
1552
+ "unique_count": 1122,
1553
+ "unique_ratio": 0.019258,
1554
+ "example_values": [
1555
+ "0",
1556
+ "190",
1557
+ "42",
1558
+ "58",
1559
+ "36"
1560
+ ]
1561
+ }
1562
+ },
1563
+ {
1564
+ "name": "bg_000",
1565
+ "role": "feature",
1566
+ "semantic_type": "numeric",
1567
+ "nullable": true,
1568
+ "missing_tokens": [
1569
+ "na"
1570
+ ],
1571
+ "parse_format": null,
1572
+ "impute_strategy": "median",
1573
+ "profile_stats": {
1574
+ "missing_rate": 0.010526,
1575
+ "unique_count": 20000,
1576
+ "unique_ratio": 0.332447,
1577
+ "example_values": [
1578
+ "36080",
1579
+ "3165022",
1580
+ "10518",
1581
+ "1060220",
1582
+ "1167164"
1583
+ ]
1584
+ }
1585
+ },
1586
+ {
1587
+ "name": "bh_000",
1588
+ "role": "feature",
1589
+ "semantic_type": "numeric",
1590
+ "nullable": true,
1591
+ "missing_tokens": [
1592
+ "na"
1593
+ ],
1594
+ "parse_format": null,
1595
+ "impute_strategy": "median",
1596
+ "profile_stats": {
1597
+ "missing_rate": 0.010526,
1598
+ "unique_count": 20000,
1599
+ "unique_ratio": 0.332447,
1600
+ "example_values": [
1601
+ "1188",
1602
+ "37482",
1603
+ "466",
1604
+ "29150",
1605
+ "40680"
1606
+ ]
1607
+ }
1608
+ },
1609
+ {
1610
+ "name": "bi_000",
1611
+ "role": "feature",
1612
+ "semantic_type": "numeric",
1613
+ "nullable": true,
1614
+ "missing_tokens": [
1615
+ "na"
1616
+ ],
1617
+ "parse_format": null,
1618
+ "impute_strategy": "median",
1619
+ "profile_stats": {
1620
+ "missing_rate": 0.009622,
1621
+ "unique_count": 20000,
1622
+ "unique_ratio": 0.332143,
1623
+ "example_values": [
1624
+ "5890",
1625
+ "168126",
1626
+ "16940",
1627
+ "693886",
1628
+ "362196"
1629
+ ]
1630
+ }
1631
+ },
1632
+ {
1633
+ "name": "bj_000",
1634
+ "role": "feature",
1635
+ "semantic_type": "numeric",
1636
+ "nullable": true,
1637
+ "missing_tokens": [
1638
+ "na"
1639
+ ],
1640
+ "parse_format": null,
1641
+ "impute_strategy": "median",
1642
+ "profile_stats": {
1643
+ "missing_rate": 0.009622,
1644
+ "unique_count": 20000,
1645
+ "unique_ratio": 0.332143,
1646
+ "example_values": [
1647
+ "9244",
1648
+ "232192",
1649
+ "11536",
1650
+ "132634",
1651
+ "268290"
1652
+ ]
1653
+ }
1654
+ },
1655
+ {
1656
+ "name": "bk_000",
1657
+ "role": "feature",
1658
+ "semantic_type": "numeric",
1659
+ "nullable": true,
1660
+ "missing_tokens": [
1661
+ "na"
1662
+ ],
1663
+ "parse_format": null,
1664
+ "impute_strategy": "median",
1665
+ "profile_stats": {
1666
+ "missing_rate": 0.384737,
1667
+ "unique_count": 13038,
1668
+ "unique_ratio": 0.348535,
1669
+ "example_values": [
1670
+ "76900",
1671
+ "285120",
1672
+ "224680",
1673
+ "132180",
1674
+ "238240"
1675
+ ]
1676
+ }
1677
+ },
1678
+ {
1679
+ "name": "bl_000",
1680
+ "role": "feature",
1681
+ "semantic_type": "numeric",
1682
+ "nullable": true,
1683
+ "missing_tokens": [
1684
+ "na"
1685
+ ],
1686
+ "parse_format": null,
1687
+ "impute_strategy": "median",
1688
+ "profile_stats": {
1689
+ "missing_rate": 0.455609,
1690
+ "unique_count": 12055,
1691
+ "unique_ratio": 0.36421,
1692
+ "example_values": [
1693
+ "59240",
1694
+ "343500",
1695
+ "255560",
1696
+ "1310700",
1697
+ "188560"
1698
+ ]
1699
+ }
1700
+ },
1701
+ {
1702
+ "name": "bm_000",
1703
+ "role": "feature",
1704
+ "semantic_type": "numeric",
1705
+ "nullable": true,
1706
+ "missing_tokens": [
1707
+ "na"
1708
+ ],
1709
+ "parse_format": null,
1710
+ "impute_strategy": "median",
1711
+ "profile_stats": {
1712
+ "missing_rate": 0.661135,
1713
+ "unique_count": 9160,
1714
+ "unique_ratio": 0.444595,
1715
+ "example_values": [
1716
+ "71160",
1717
+ "1310700",
1718
+ "237300",
1719
+ "298620",
1720
+ "200400"
1721
+ ]
1722
+ }
1723
+ },
1724
+ {
1725
+ "name": "bn_000",
1726
+ "role": "feature",
1727
+ "semantic_type": "numeric",
1728
+ "nullable": true,
1729
+ "missing_tokens": [
1730
+ "na"
1731
+ ],
1732
+ "parse_format": null,
1733
+ "impute_strategy": "median",
1734
+ "profile_stats": {
1735
+ "missing_rate": 0.734095,
1736
+ "unique_count": 7196,
1737
+ "unique_ratio": 0.445104,
1738
+ "example_values": [
1739
+ "115600",
1740
+ "1310700",
1741
+ "221260",
1742
+ "0",
1743
+ "254060"
1744
+ ]
1745
+ }
1746
+ },
1747
+ {
1748
+ "name": "bo_000",
1749
+ "role": "feature",
1750
+ "semantic_type": "numeric",
1751
+ "nullable": true,
1752
+ "missing_tokens": [
1753
+ "na"
1754
+ ],
1755
+ "parse_format": null,
1756
+ "impute_strategy": "median",
1757
+ "profile_stats": {
1758
+ "missing_rate": 0.773405,
1759
+ "unique_count": 5932,
1760
+ "unique_ratio": 0.430573,
1761
+ "example_values": [
1762
+ "1310700",
1763
+ "248360",
1764
+ "0",
1765
+ "226380",
1766
+ "166140"
1767
+ ]
1768
+ }
1769
+ },
1770
+ {
1771
+ "name": "bp_000",
1772
+ "role": "feature",
1773
+ "semantic_type": "numeric",
1774
+ "nullable": true,
1775
+ "missing_tokens": [
1776
+ "na"
1777
+ ],
1778
+ "parse_format": null,
1779
+ "impute_strategy": "median",
1780
+ "profile_stats": {
1781
+ "missing_rate": 0.796118,
1782
+ "unique_count": 5059,
1783
+ "unique_ratio": 0.408116,
1784
+ "example_values": [
1785
+ "1310700",
1786
+ "0",
1787
+ "174400",
1788
+ "389060",
1789
+ "227500"
1790
+ ]
1791
+ }
1792
+ },
1793
+ {
1794
+ "name": "bq_000",
1795
+ "role": "feature",
1796
+ "semantic_type": "numeric",
1797
+ "nullable": true,
1798
+ "missing_tokens": [
1799
+ "na"
1800
+ ],
1801
+ "parse_format": null,
1802
+ "impute_strategy": "median",
1803
+ "profile_stats": {
1804
+ "missing_rate": 0.812632,
1805
+ "unique_count": 4349,
1806
+ "unique_ratio": 0.381759,
1807
+ "example_values": [
1808
+ "1310700",
1809
+ "0",
1810
+ "177920",
1811
+ "433740",
1812
+ "279280"
1813
+ ]
1814
+ }
1815
+ },
1816
+ {
1817
+ "name": "br_000",
1818
+ "role": "feature",
1819
+ "semantic_type": "numeric",
1820
+ "nullable": true,
1821
+ "missing_tokens": [
1822
+ "na"
1823
+ ],
1824
+ "parse_format": null,
1825
+ "impute_strategy": "median",
1826
+ "profile_stats": {
1827
+ "missing_rate": 0.821743,
1828
+ "unique_count": 3929,
1829
+ "unique_ratio": 0.362521,
1830
+ "example_values": [
1831
+ "1310700",
1832
+ "0",
1833
+ "158980",
1834
+ "404300",
1835
+ "232280"
1836
+ ]
1837
+ }
1838
+ },
1839
+ {
1840
+ "name": "bs_000",
1841
+ "role": "feature",
1842
+ "semantic_type": "numeric",
1843
+ "nullable": true,
1844
+ "missing_tokens": [
1845
+ "na"
1846
+ ],
1847
+ "parse_format": null,
1848
+ "impute_strategy": "median",
1849
+ "profile_stats": {
1850
+ "missing_rate": 0.011974,
1851
+ "unique_count": 12890,
1852
+ "unique_ratio": 0.214576,
1853
+ "example_values": [
1854
+ "14900",
1855
+ "69400",
1856
+ "28200",
1857
+ "195000",
1858
+ "146640"
1859
+ ]
1860
+ }
1861
+ },
1862
+ {
1863
+ "name": "bt_000",
1864
+ "role": "feature",
1865
+ "semantic_type": "numeric",
1866
+ "nullable": true,
1867
+ "missing_tokens": [
1868
+ "na"
1869
+ ],
1870
+ "parse_format": null,
1871
+ "impute_strategy": "median",
1872
+ "profile_stats": {
1873
+ "missing_rate": 0.002549,
1874
+ "unique_count": 20000,
1875
+ "unique_ratio": 0.329788,
1876
+ "example_values": [
1877
+ "1655.66",
1878
+ "118600.27",
1879
+ "129.51",
1880
+ "37015.76",
1881
+ "32929.03"
1882
+ ]
1883
+ }
1884
+ },
1885
+ {
1886
+ "name": "bu_000",
1887
+ "role": "feature",
1888
+ "semantic_type": "numeric",
1889
+ "nullable": true,
1890
+ "missing_tokens": [
1891
+ "na"
1892
+ ],
1893
+ "parse_format": null,
1894
+ "impute_strategy": "median",
1895
+ "profile_stats": {
1896
+ "missing_rate": 0.011365,
1897
+ "unique_count": 20000,
1898
+ "unique_ratio": 0.332729,
1899
+ "example_values": [
1900
+ "104890",
1901
+ "6053972",
1902
+ "62144",
1903
+ "2922442",
1904
+ "3031738"
1905
+ ]
1906
+ }
1907
+ },
1908
+ {
1909
+ "name": "bv_000",
1910
+ "role": "feature",
1911
+ "semantic_type": "numeric",
1912
+ "nullable": true,
1913
+ "missing_tokens": [
1914
+ "na"
1915
+ ],
1916
+ "parse_format": null,
1917
+ "impute_strategy": "median",
1918
+ "profile_stats": {
1919
+ "missing_rate": 0.011365,
1920
+ "unique_count": 20000,
1921
+ "unique_ratio": 0.332729,
1922
+ "example_values": [
1923
+ "104890",
1924
+ "6053972",
1925
+ "62144",
1926
+ "2922442",
1927
+ "3031738"
1928
+ ]
1929
+ }
1930
+ },
1931
+ {
1932
+ "name": "bx_000",
1933
+ "role": "feature",
1934
+ "semantic_type": "numeric",
1935
+ "nullable": true,
1936
+ "missing_tokens": [
1937
+ "na"
1938
+ ],
1939
+ "parse_format": null,
1940
+ "impute_strategy": "median",
1941
+ "profile_stats": {
1942
+ "missing_rate": 0.052845,
1943
+ "unique_count": 20000,
1944
+ "unique_ratio": 0.347301,
1945
+ "example_values": [
1946
+ "106798",
1947
+ "6017402",
1948
+ "63248",
1949
+ "2922030",
1950
+ "3026214"
1951
+ ]
1952
+ }
1953
+ },
1954
+ {
1955
+ "name": "by_000",
1956
+ "role": "feature",
1957
+ "semantic_type": "numeric",
1958
+ "nullable": true,
1959
+ "missing_tokens": [
1960
+ "na"
1961
+ ],
1962
+ "parse_format": null,
1963
+ "impute_strategy": "median",
1964
+ "profile_stats": {
1965
+ "missing_rate": 0.00778,
1966
+ "unique_count": 20000,
1967
+ "unique_ratio": 0.331527,
1968
+ "example_values": [
1969
+ "392",
1970
+ "35561.0",
1971
+ "120",
1972
+ "13359.0",
1973
+ "15622"
1974
+ ]
1975
+ }
1976
+ },
1977
+ {
1978
+ "name": "bz_000",
1979
+ "role": "feature",
1980
+ "semantic_type": "numeric",
1981
+ "nullable": true,
1982
+ "missing_tokens": [
1983
+ "na"
1984
+ ],
1985
+ "parse_format": null,
1986
+ "impute_strategy": "median",
1987
+ "profile_stats": {
1988
+ "missing_rate": 0.045674,
1989
+ "unique_count": 16718,
1990
+ "unique_ratio": 0.288127,
1991
+ "example_values": [
1992
+ "0",
1993
+ "1820080",
1994
+ "2350",
1995
+ "119886",
1996
+ "138476"
1997
+ ]
1998
+ }
1999
+ },
2000
+ {
2001
+ "name": "ca_000",
2002
+ "role": "feature",
2003
+ "semantic_type": "numeric",
2004
+ "nullable": true,
2005
+ "missing_tokens": [
2006
+ "na"
2007
+ ],
2008
+ "parse_format": null,
2009
+ "impute_strategy": "median",
2010
+ "profile_stats": {
2011
+ "missing_rate": 0.072105,
2012
+ "unique_count": 20000,
2013
+ "unique_ratio": 0.354509,
2014
+ "example_values": [
2015
+ "10292",
2016
+ "115788",
2017
+ "5744",
2018
+ "47768",
2019
+ "57472"
2020
+ ]
2021
+ }
2022
+ },
2023
+ {
2024
+ "name": "cb_000",
2025
+ "role": "feature",
2026
+ "semantic_type": "numeric",
2027
+ "nullable": true,
2028
+ "missing_tokens": [
2029
+ "na"
2030
+ ],
2031
+ "parse_format": null,
2032
+ "impute_strategy": "median",
2033
+ "profile_stats": {
2034
+ "missing_rate": 0.011974,
2035
+ "unique_count": 20000,
2036
+ "unique_ratio": 0.332934,
2037
+ "example_values": [
2038
+ "104580",
2039
+ "1205680",
2040
+ "61420",
2041
+ "498440",
2042
+ "606660"
2043
+ ]
2044
+ }
2045
+ },
2046
+ {
2047
+ "name": "cc_000",
2048
+ "role": "feature",
2049
+ "semantic_type": "numeric",
2050
+ "nullable": true,
2051
+ "missing_tokens": [
2052
+ "na"
2053
+ ],
2054
+ "parse_format": null,
2055
+ "impute_strategy": "median",
2056
+ "profile_stats": {
2057
+ "missing_rate": 0.052796,
2058
+ "unique_count": 20000,
2059
+ "unique_ratio": 0.347283,
2060
+ "example_values": [
2061
+ "98484",
2062
+ "5893332",
2063
+ "35116",
2064
+ "2268056",
2065
+ "2619368"
2066
+ ]
2067
+ }
2068
+ },
2069
+ {
2070
+ "name": "cd_000",
2071
+ "role": "feature",
2072
+ "semantic_type": "numeric",
2073
+ "nullable": true,
2074
+ "missing_tokens": [
2075
+ "na"
2076
+ ],
2077
+ "parse_format": null,
2078
+ "impute_strategy": "median",
2079
+ "profile_stats": {
2080
+ "missing_rate": 0.011217,
2081
+ "unique_count": 1,
2082
+ "unique_ratio": 1.7e-05,
2083
+ "example_values": [
2084
+ "1209600"
2085
+ ]
2086
+ }
2087
+ },
2088
+ {
2089
+ "name": "ce_000",
2090
+ "role": "feature",
2091
+ "semantic_type": "numeric",
2092
+ "nullable": true,
2093
+ "missing_tokens": [
2094
+ "na"
2095
+ ],
2096
+ "parse_format": null,
2097
+ "impute_strategy": "median",
2098
+ "profile_stats": {
2099
+ "missing_rate": 0.04176,
2100
+ "unique_count": 20000,
2101
+ "unique_ratio": 0.343283,
2102
+ "example_values": [
2103
+ "2436",
2104
+ "0",
2105
+ "1348",
2106
+ "64960",
2107
+ "99092"
2108
+ ]
2109
+ }
2110
+ },
2111
+ {
2112
+ "name": "cf_000",
2113
+ "role": "feature",
2114
+ "semantic_type": "numeric",
2115
+ "nullable": true,
2116
+ "missing_tokens": [
2117
+ "na"
2118
+ ],
2119
+ "parse_format": null,
2120
+ "impute_strategy": "median",
2121
+ "profile_stats": {
2122
+ "missing_rate": 0.246727,
2123
+ "unique_count": 528,
2124
+ "unique_ratio": 0.011529,
2125
+ "example_values": [
2126
+ "2",
2127
+ "8",
2128
+ "0",
2129
+ "4",
2130
+ "190"
2131
+ ]
2132
+ }
2133
+ },
2134
+ {
2135
+ "name": "cg_000",
2136
+ "role": "feature",
2137
+ "semantic_type": "numeric",
2138
+ "nullable": true,
2139
+ "missing_tokens": [
2140
+ "na"
2141
+ ],
2142
+ "parse_format": null,
2143
+ "impute_strategy": "median",
2144
+ "profile_stats": {
2145
+ "missing_rate": 0.246727,
2146
+ "unique_count": 666,
2147
+ "unique_ratio": 0.014542,
2148
+ "example_values": [
2149
+ "10",
2150
+ "8",
2151
+ "46",
2152
+ "70",
2153
+ "6"
2154
+ ]
2155
+ }
2156
+ },
2157
+ {
2158
+ "name": "ch_000",
2159
+ "role": "feature",
2160
+ "semantic_type": "boolean",
2161
+ "nullable": true,
2162
+ "missing_tokens": [
2163
+ "na"
2164
+ ],
2165
+ "parse_format": null,
2166
+ "impute_strategy": "mode",
2167
+ "profile_stats": {
2168
+ "missing_rate": 0.246727,
2169
+ "unique_count": 2,
2170
+ "unique_ratio": 4.4e-05,
2171
+ "example_values": [
2172
+ "0",
2173
+ "2"
2174
+ ]
2175
+ }
2176
+ },
2177
+ {
2178
+ "name": "ci_000",
2179
+ "role": "feature",
2180
+ "semantic_type": "numeric",
2181
+ "nullable": true,
2182
+ "missing_tokens": [
2183
+ "na"
2184
+ ],
2185
+ "parse_format": null,
2186
+ "impute_strategy": "median",
2187
+ "profile_stats": {
2188
+ "missing_rate": 0.005559,
2189
+ "unique_count": 20000,
2190
+ "unique_ratio": 0.330786,
2191
+ "example_values": [
2192
+ "86199.36",
2193
+ "5383493.76",
2194
+ "12072",
2195
+ "2022616.32",
2196
+ "2018493.12"
2197
+ ]
2198
+ }
2199
+ },
2200
+ {
2201
+ "name": "cj_000",
2202
+ "role": "feature",
2203
+ "semantic_type": "numeric",
2204
+ "nullable": true,
2205
+ "missing_tokens": [
2206
+ "na"
2207
+ ],
2208
+ "parse_format": null,
2209
+ "impute_strategy": "median",
2210
+ "profile_stats": {
2211
+ "missing_rate": 0.005559,
2212
+ "unique_count": 7685,
2213
+ "unique_ratio": 0.127105,
2214
+ "example_values": [
2215
+ "0",
2216
+ "2187817.92",
2217
+ "287.04",
2218
+ "36538.56",
2219
+ "7788.48"
2220
+ ]
2221
+ }
2222
+ },
2223
+ {
2224
+ "name": "ck_000",
2225
+ "role": "feature",
2226
+ "semantic_type": "numeric",
2227
+ "nullable": true,
2228
+ "missing_tokens": [
2229
+ "na"
2230
+ ],
2231
+ "parse_format": null,
2232
+ "impute_strategy": "median",
2233
+ "profile_stats": {
2234
+ "missing_rate": 0.005559,
2235
+ "unique_count": 20000,
2236
+ "unique_ratio": 0.330786,
2237
+ "example_values": [
2238
+ "12177.6",
2239
+ "489533.76",
2240
+ "20935.68",
2241
+ "244064.64",
2242
+ "598942.08"
2243
+ ]
2244
+ }
2245
+ },
2246
+ {
2247
+ "name": "cl_000",
2248
+ "role": "feature",
2249
+ "semantic_type": "numeric",
2250
+ "nullable": true,
2251
+ "missing_tokens": [
2252
+ "na"
2253
+ ],
2254
+ "parse_format": null,
2255
+ "impute_strategy": "median",
2256
+ "profile_stats": {
2257
+ "missing_rate": 0.156793,
2258
+ "unique_count": 989,
2259
+ "unique_ratio": 0.019291,
2260
+ "example_values": [
2261
+ "0",
2262
+ "2",
2263
+ "1800",
2264
+ "6",
2265
+ "10"
2266
+ ]
2267
+ }
2268
+ },
2269
+ {
2270
+ "name": "cm_000",
2271
+ "role": "feature",
2272
+ "semantic_type": "numeric",
2273
+ "nullable": true,
2274
+ "missing_tokens": [
2275
+ "na"
2276
+ ],
2277
+ "parse_format": null,
2278
+ "impute_strategy": "median",
2279
+ "profile_stats": {
2280
+ "missing_rate": 0.162845,
2281
+ "unique_count": 2141,
2282
+ "unique_ratio": 0.042064,
2283
+ "example_values": [
2284
+ "0",
2285
+ "32",
2286
+ "1006",
2287
+ "6",
2288
+ "652"
2289
+ ]
2290
+ }
2291
+ },
2292
+ {
2293
+ "name": "cn_000",
2294
+ "role": "feature",
2295
+ "semantic_type": "numeric",
2296
+ "nullable": true,
2297
+ "missing_tokens": [
2298
+ "na"
2299
+ ],
2300
+ "parse_format": null,
2301
+ "impute_strategy": "median",
2302
+ "profile_stats": {
2303
+ "missing_rate": 0.011694,
2304
+ "unique_count": 1570,
2305
+ "unique_ratio": 0.026128,
2306
+ "example_values": [
2307
+ "0",
2308
+ "3646",
2309
+ "364",
2310
+ "38904",
2311
+ "36044"
2312
+ ]
2313
+ }
2314
+ },
2315
+ {
2316
+ "name": "cn_001",
2317
+ "role": "feature",
2318
+ "semantic_type": "numeric",
2319
+ "nullable": true,
2320
+ "missing_tokens": [
2321
+ "na"
2322
+ ],
2323
+ "parse_format": null,
2324
+ "impute_strategy": "median",
2325
+ "profile_stats": {
2326
+ "missing_rate": 0.011694,
2327
+ "unique_count": 5489,
2328
+ "unique_ratio": 0.091348,
2329
+ "example_values": [
2330
+ "0",
2331
+ "6696",
2332
+ "538",
2333
+ "578",
2334
+ "3568"
2335
+ ]
2336
+ }
2337
+ },
2338
+ {
2339
+ "name": "cn_002",
2340
+ "role": "feature",
2341
+ "semantic_type": "numeric",
2342
+ "nullable": true,
2343
+ "missing_tokens": [
2344
+ "na"
2345
+ ],
2346
+ "parse_format": null,
2347
+ "impute_strategy": "median",
2348
+ "profile_stats": {
2349
+ "missing_rate": 0.011694,
2350
+ "unique_count": 14897,
2351
+ "unique_ratio": 0.247916,
2352
+ "example_values": [
2353
+ "0",
2354
+ "15704",
2355
+ "6506",
2356
+ "390",
2357
+ "63466"
2358
+ ]
2359
+ }
2360
+ },
2361
+ {
2362
+ "name": "cn_003",
2363
+ "role": "feature",
2364
+ "semantic_type": "numeric",
2365
+ "nullable": true,
2366
+ "missing_tokens": [
2367
+ "na"
2368
+ ],
2369
+ "parse_format": null,
2370
+ "impute_strategy": "median",
2371
+ "profile_stats": {
2372
+ "missing_rate": 0.011694,
2373
+ "unique_count": 20000,
2374
+ "unique_ratio": 0.33284,
2375
+ "example_values": [
2376
+ "0",
2377
+ "71316",
2378
+ "9292",
2379
+ "246136",
2380
+ "22938"
2381
+ ]
2382
+ }
2383
+ },
2384
+ {
2385
+ "name": "cn_004",
2386
+ "role": "feature",
2387
+ "semantic_type": "numeric",
2388
+ "nullable": true,
2389
+ "missing_tokens": [
2390
+ "na"
2391
+ ],
2392
+ "parse_format": null,
2393
+ "impute_strategy": "median",
2394
+ "profile_stats": {
2395
+ "missing_rate": 0.011694,
2396
+ "unique_count": 20000,
2397
+ "unique_ratio": 0.33284,
2398
+ "example_values": [
2399
+ "53668",
2400
+ "2416614",
2401
+ "1288",
2402
+ "896600",
2403
+ "364342"
2404
+ ]
2405
+ }
2406
+ },
2407
+ {
2408
+ "name": "cn_005",
2409
+ "role": "feature",
2410
+ "semantic_type": "numeric",
2411
+ "nullable": true,
2412
+ "missing_tokens": [
2413
+ "na"
2414
+ ],
2415
+ "parse_format": null,
2416
+ "impute_strategy": "median",
2417
+ "profile_stats": {
2418
+ "missing_rate": 0.011694,
2419
+ "unique_count": 20000,
2420
+ "unique_ratio": 0.33284,
2421
+ "example_values": [
2422
+ "43094",
2423
+ "2933718",
2424
+ "1724",
2425
+ "798980",
2426
+ "1485336"
2427
+ ]
2428
+ }
2429
+ },
2430
+ {
2431
+ "name": "cn_006",
2432
+ "role": "feature",
2433
+ "semantic_type": "numeric",
2434
+ "nullable": true,
2435
+ "missing_tokens": [
2436
+ "na"
2437
+ ],
2438
+ "parse_format": null,
2439
+ "impute_strategy": "median",
2440
+ "profile_stats": {
2441
+ "missing_rate": 0.011694,
2442
+ "unique_count": 20000,
2443
+ "unique_ratio": 0.33284,
2444
+ "example_values": [
2445
+ "1432",
2446
+ "420450",
2447
+ "292",
2448
+ "304872",
2449
+ "706156"
2450
+ ]
2451
+ }
2452
+ },
2453
+ {
2454
+ "name": "cn_007",
2455
+ "role": "feature",
2456
+ "semantic_type": "numeric",
2457
+ "nullable": true,
2458
+ "missing_tokens": [
2459
+ "na"
2460
+ ],
2461
+ "parse_format": null,
2462
+ "impute_strategy": "median",
2463
+ "profile_stats": {
2464
+ "missing_rate": 0.011694,
2465
+ "unique_count": 20000,
2466
+ "unique_ratio": 0.33284,
2467
+ "example_values": [
2468
+ "238",
2469
+ "43048",
2470
+ "0",
2471
+ "12792",
2472
+ "34492"
2473
+ ]
2474
+ }
2475
+ },
2476
+ {
2477
+ "name": "cn_008",
2478
+ "role": "feature",
2479
+ "semantic_type": "numeric",
2480
+ "nullable": true,
2481
+ "missing_tokens": [
2482
+ "na"
2483
+ ],
2484
+ "parse_format": null,
2485
+ "impute_strategy": "median",
2486
+ "profile_stats": {
2487
+ "missing_rate": 0.011694,
2488
+ "unique_count": 10126,
2489
+ "unique_ratio": 0.168517,
2490
+ "example_values": [
2491
+ "52",
2492
+ "7932",
2493
+ "0",
2494
+ "1966",
2495
+ "5644"
2496
+ ]
2497
+ }
2498
+ },
2499
+ {
2500
+ "name": "cn_009",
2501
+ "role": "feature",
2502
+ "semantic_type": "numeric",
2503
+ "nullable": true,
2504
+ "missing_tokens": [
2505
+ "na"
2506
+ ],
2507
+ "parse_format": null,
2508
+ "impute_strategy": "median",
2509
+ "profile_stats": {
2510
+ "missing_rate": 0.011694,
2511
+ "unique_count": 3064,
2512
+ "unique_ratio": 0.050991,
2513
+ "example_values": [
2514
+ "0",
2515
+ "254",
2516
+ "204",
2517
+ "460",
2518
+ "12"
2519
+ ]
2520
+ }
2521
+ },
2522
+ {
2523
+ "name": "co_000",
2524
+ "role": "feature",
2525
+ "semantic_type": "numeric",
2526
+ "nullable": true,
2527
+ "missing_tokens": [
2528
+ "na"
2529
+ ],
2530
+ "parse_format": null,
2531
+ "impute_strategy": "median",
2532
+ "profile_stats": {
2533
+ "missing_rate": 0.246727,
2534
+ "unique_count": 1873,
2535
+ "unique_ratio": 0.040896,
2536
+ "example_values": [
2537
+ "2",
2538
+ "100",
2539
+ "2522",
2540
+ "8",
2541
+ "882"
2542
+ ]
2543
+ }
2544
+ },
2545
+ {
2546
+ "name": "cp_000",
2547
+ "role": "feature",
2548
+ "semantic_type": "numeric",
2549
+ "nullable": true,
2550
+ "missing_tokens": [
2551
+ "na"
2552
+ ],
2553
+ "parse_format": null,
2554
+ "impute_strategy": "median",
2555
+ "profile_stats": {
2556
+ "missing_rate": 0.045691,
2557
+ "unique_count": 2328,
2558
+ "unique_ratio": 0.040123,
2559
+ "example_values": [
2560
+ "6",
2561
+ "0",
2562
+ "24",
2563
+ "230",
2564
+ "2534"
2565
+ ]
2566
+ }
2567
+ },
2568
+ {
2569
+ "name": "cq_000",
2570
+ "role": "feature",
2571
+ "semantic_type": "numeric",
2572
+ "nullable": true,
2573
+ "missing_tokens": [
2574
+ "na"
2575
+ ],
2576
+ "parse_format": null,
2577
+ "impute_strategy": "median",
2578
+ "profile_stats": {
2579
+ "missing_rate": 0.011365,
2580
+ "unique_count": 20000,
2581
+ "unique_ratio": 0.332729,
2582
+ "example_values": [
2583
+ "104890",
2584
+ "6053972",
2585
+ "62144",
2586
+ "2922442",
2587
+ "3031738"
2588
+ ]
2589
+ }
2590
+ },
2591
+ {
2592
+ "name": "cr_000",
2593
+ "role": "feature",
2594
+ "semantic_type": "boolean",
2595
+ "nullable": true,
2596
+ "missing_tokens": [
2597
+ "na"
2598
+ ],
2599
+ "parse_format": null,
2600
+ "impute_strategy": "mode",
2601
+ "profile_stats": {
2602
+ "missing_rate": 0.772253,
2603
+ "unique_count": 73,
2604
+ "unique_ratio": 0.005272,
2605
+ "example_values": [
2606
+ "0",
2607
+ "22",
2608
+ "8106",
2609
+ "30812",
2610
+ "2632"
2611
+ ]
2612
+ }
2613
+ },
2614
+ {
2615
+ "name": "cs_000",
2616
+ "role": "feature",
2617
+ "semantic_type": "numeric",
2618
+ "nullable": true,
2619
+ "missing_tokens": [
2620
+ "na"
2621
+ ],
2622
+ "parse_format": null,
2623
+ "impute_strategy": "median",
2624
+ "profile_stats": {
2625
+ "missing_rate": 0.011349,
2626
+ "unique_count": 9374,
2627
+ "unique_ratio": 0.155947,
2628
+ "example_values": [
2629
+ "210",
2630
+ "17408",
2631
+ "2228",
2632
+ "2586",
2633
+ "4430"
2634
+ ]
2635
+ }
2636
+ },
2637
+ {
2638
+ "name": "cs_001",
2639
+ "role": "feature",
2640
+ "semantic_type": "numeric",
2641
+ "nullable": true,
2642
+ "missing_tokens": [
2643
+ "na"
2644
+ ],
2645
+ "parse_format": null,
2646
+ "impute_strategy": "median",
2647
+ "profile_stats": {
2648
+ "missing_rate": 0.011349,
2649
+ "unique_count": 3405,
2650
+ "unique_ratio": 0.056646,
2651
+ "example_values": [
2652
+ "26",
2653
+ "724",
2654
+ "22",
2655
+ "322",
2656
+ "500"
2657
+ ]
2658
+ }
2659
+ },
2660
+ {
2661
+ "name": "cs_002",
2662
+ "role": "feature",
2663
+ "semantic_type": "numeric",
2664
+ "nullable": true,
2665
+ "missing_tokens": [
2666
+ "na"
2667
+ ],
2668
+ "parse_format": null,
2669
+ "impute_strategy": "median",
2670
+ "profile_stats": {
2671
+ "missing_rate": 0.011349,
2672
+ "unique_count": 20000,
2673
+ "unique_ratio": 0.332723,
2674
+ "example_values": [
2675
+ "7100",
2676
+ "2454",
2677
+ "50",
2678
+ "63980",
2679
+ "86580"
2680
+ ]
2681
+ }
2682
+ },
2683
+ {
2684
+ "name": "cs_003",
2685
+ "role": "feature",
2686
+ "semantic_type": "numeric",
2687
+ "nullable": true,
2688
+ "missing_tokens": [
2689
+ "na"
2690
+ ],
2691
+ "parse_format": null,
2692
+ "impute_strategy": "median",
2693
+ "profile_stats": {
2694
+ "missing_rate": 0.011349,
2695
+ "unique_count": 20000,
2696
+ "unique_ratio": 0.332723,
2697
+ "example_values": [
2698
+ "2268",
2699
+ "225796",
2700
+ "726",
2701
+ "102484",
2702
+ "241144"
2703
+ ]
2704
+ }
2705
+ },
2706
+ {
2707
+ "name": "cs_004",
2708
+ "role": "feature",
2709
+ "semantic_type": "numeric",
2710
+ "nullable": true,
2711
+ "missing_tokens": [
2712
+ "na"
2713
+ ],
2714
+ "parse_format": null,
2715
+ "impute_strategy": "median",
2716
+ "profile_stats": {
2717
+ "missing_rate": 0.011349,
2718
+ "unique_count": 20000,
2719
+ "unique_ratio": 0.332723,
2720
+ "example_values": [
2721
+ "1520",
2722
+ "196192",
2723
+ "3242",
2724
+ "102782",
2725
+ "137060"
2726
+ ]
2727
+ }
2728
+ },
2729
+ {
2730
+ "name": "cs_005",
2731
+ "role": "feature",
2732
+ "semantic_type": "numeric",
2733
+ "nullable": true,
2734
+ "missing_tokens": [
2735
+ "na"
2736
+ ],
2737
+ "parse_format": null,
2738
+ "impute_strategy": "median",
2739
+ "profile_stats": {
2740
+ "missing_rate": 0.011349,
2741
+ "unique_count": 20000,
2742
+ "unique_ratio": 0.332723,
2743
+ "example_values": [
2744
+ "41000",
2745
+ "1273478",
2746
+ "24804",
2747
+ "1712116",
2748
+ "1491190"
2749
+ ]
2750
+ }
2751
+ },
2752
+ {
2753
+ "name": "cs_006",
2754
+ "role": "feature",
2755
+ "semantic_type": "numeric",
2756
+ "nullable": true,
2757
+ "missing_tokens": [
2758
+ "na"
2759
+ ],
2760
+ "parse_format": null,
2761
+ "impute_strategy": "median",
2762
+ "profile_stats": {
2763
+ "missing_rate": 0.011349,
2764
+ "unique_count": 20000,
2765
+ "unique_ratio": 0.332723,
2766
+ "example_values": [
2767
+ "45554",
2768
+ "4141758",
2769
+ "3910",
2770
+ "266134",
2771
+ "639496"
2772
+ ]
2773
+ }
2774
+ },
2775
+ {
2776
+ "name": "cs_007",
2777
+ "role": "feature",
2778
+ "semantic_type": "numeric",
2779
+ "nullable": true,
2780
+ "missing_tokens": [
2781
+ "na"
2782
+ ],
2783
+ "parse_format": null,
2784
+ "impute_strategy": "median",
2785
+ "profile_stats": {
2786
+ "missing_rate": 0.011349,
2787
+ "unique_count": 17357,
2788
+ "unique_ratio": 0.288754,
2789
+ "example_values": [
2790
+ "796",
2791
+ "35486",
2792
+ "14",
2793
+ "17560",
2794
+ "18796"
2795
+ ]
2796
+ }
2797
+ },
2798
+ {
2799
+ "name": "cs_008",
2800
+ "role": "feature",
2801
+ "semantic_type": "numeric",
2802
+ "nullable": true,
2803
+ "missing_tokens": [
2804
+ "na"
2805
+ ],
2806
+ "parse_format": null,
2807
+ "impute_strategy": "median",
2808
+ "profile_stats": {
2809
+ "missing_rate": 0.011349,
2810
+ "unique_count": 777,
2811
+ "unique_ratio": 0.012926,
2812
+ "example_values": [
2813
+ "10",
2814
+ "36",
2815
+ "0",
2816
+ "92",
2817
+ "172"
2818
+ ]
2819
+ }
2820
+ },
2821
+ {
2822
+ "name": "cs_009",
2823
+ "role": "feature",
2824
+ "semantic_type": "numeric",
2825
+ "nullable": true,
2826
+ "missing_tokens": [
2827
+ "na"
2828
+ ],
2829
+ "parse_format": null,
2830
+ "impute_strategy": "median",
2831
+ "profile_stats": {
2832
+ "missing_rate": 0.011349,
2833
+ "unique_count": 62,
2834
+ "unique_ratio": 0.001031,
2835
+ "example_values": [
2836
+ "0",
2837
+ "6",
2838
+ "2",
2839
+ "4",
2840
+ "16"
2841
+ ]
2842
+ }
2843
+ },
2844
+ {
2845
+ "name": "ct_000",
2846
+ "role": "feature",
2847
+ "semantic_type": "numeric",
2848
+ "nullable": true,
2849
+ "missing_tokens": [
2850
+ "na"
2851
+ ],
2852
+ "parse_format": null,
2853
+ "impute_strategy": "median",
2854
+ "profile_stats": {
2855
+ "missing_rate": 0.23,
2856
+ "unique_count": 2629,
2857
+ "unique_ratio": 0.056156,
2858
+ "example_values": [
2859
+ "170",
2860
+ "64",
2861
+ "1086",
2862
+ "2314",
2863
+ "50"
2864
+ ]
2865
+ }
2866
+ },
2867
+ {
2868
+ "name": "cu_000",
2869
+ "role": "feature",
2870
+ "semantic_type": "numeric",
2871
+ "nullable": true,
2872
+ "missing_tokens": [
2873
+ "na"
2874
+ ],
2875
+ "parse_format": null,
2876
+ "impute_strategy": "median",
2877
+ "profile_stats": {
2878
+ "missing_rate": 0.23,
2879
+ "unique_count": 3510,
2880
+ "unique_ratio": 0.074974,
2881
+ "example_values": [
2882
+ "250",
2883
+ "204",
2884
+ "5802",
2885
+ "2174",
2886
+ "116"
2887
+ ]
2888
+ }
2889
+ },
2890
+ {
2891
+ "name": "cv_000",
2892
+ "role": "feature",
2893
+ "semantic_type": "numeric",
2894
+ "nullable": true,
2895
+ "missing_tokens": [
2896
+ "na"
2897
+ ],
2898
+ "parse_format": null,
2899
+ "impute_strategy": "median",
2900
+ "profile_stats": {
2901
+ "missing_rate": 0.23,
2902
+ "unique_count": 20000,
2903
+ "unique_ratio": 0.427204,
2904
+ "example_values": [
2905
+ "87446",
2906
+ "13252",
2907
+ "2020630",
2908
+ "1765100",
2909
+ "7728"
2910
+ ]
2911
+ }
2912
+ },
2913
+ {
2914
+ "name": "cx_000",
2915
+ "role": "feature",
2916
+ "semantic_type": "numeric",
2917
+ "nullable": true,
2918
+ "missing_tokens": [
2919
+ "na"
2920
+ ],
2921
+ "parse_format": null,
2922
+ "impute_strategy": "median",
2923
+ "profile_stats": {
2924
+ "missing_rate": 0.23,
2925
+ "unique_count": 20000,
2926
+ "unique_ratio": 0.427204,
2927
+ "example_values": [
2928
+ "35022",
2929
+ "408",
2930
+ "227550",
2931
+ "14782",
2932
+ "1044"
2933
+ ]
2934
+ }
2935
+ },
2936
+ {
2937
+ "name": "cy_000",
2938
+ "role": "feature",
2939
+ "semantic_type": "numeric",
2940
+ "nullable": true,
2941
+ "missing_tokens": [
2942
+ "na"
2943
+ ],
2944
+ "parse_format": null,
2945
+ "impute_strategy": "median",
2946
+ "profile_stats": {
2947
+ "missing_rate": 0.23,
2948
+ "unique_count": 743,
2949
+ "unique_ratio": 0.015871,
2950
+ "example_values": [
2951
+ "0",
2952
+ "384",
2953
+ "5030",
2954
+ "2930",
2955
+ "54"
2956
+ ]
2957
+ }
2958
+ },
2959
+ {
2960
+ "name": "cz_000",
2961
+ "role": "feature",
2962
+ "semantic_type": "numeric",
2963
+ "nullable": true,
2964
+ "missing_tokens": [
2965
+ "na"
2966
+ ],
2967
+ "parse_format": null,
2968
+ "impute_strategy": "median",
2969
+ "profile_stats": {
2970
+ "missing_rate": 0.23,
2971
+ "unique_count": 10768,
2972
+ "unique_ratio": 0.230007,
2973
+ "example_values": [
2974
+ "28",
2975
+ "2",
2976
+ "60784",
2977
+ "36524",
2978
+ "0"
2979
+ ]
2980
+ }
2981
+ },
2982
+ {
2983
+ "name": "da_000",
2984
+ "role": "feature",
2985
+ "semantic_type": "boolean",
2986
+ "nullable": true,
2987
+ "missing_tokens": [
2988
+ "na"
2989
+ ],
2990
+ "parse_format": null,
2991
+ "impute_strategy": "mode",
2992
+ "profile_stats": {
2993
+ "missing_rate": 0.23,
2994
+ "unique_count": 257,
2995
+ "unique_ratio": 0.00549,
2996
+ "example_values": [
2997
+ "0",
2998
+ "302",
2999
+ "308",
3000
+ "58",
3001
+ "272"
3002
+ ]
3003
+ }
3004
+ },
3005
+ {
3006
+ "name": "db_000",
3007
+ "role": "feature",
3008
+ "semantic_type": "numeric",
3009
+ "nullable": true,
3010
+ "missing_tokens": [
3011
+ "na"
3012
+ ],
3013
+ "parse_format": null,
3014
+ "impute_strategy": "median",
3015
+ "profile_stats": {
3016
+ "missing_rate": 0.23,
3017
+ "unique_count": 141,
3018
+ "unique_ratio": 0.003012,
3019
+ "example_values": [
3020
+ "18",
3021
+ "0",
3022
+ "20",
3023
+ "14",
3024
+ "34"
3025
+ ]
3026
+ }
3027
+ },
3028
+ {
3029
+ "name": "dc_000",
3030
+ "role": "feature",
3031
+ "semantic_type": "numeric",
3032
+ "nullable": true,
3033
+ "missing_tokens": [
3034
+ "na"
3035
+ ],
3036
+ "parse_format": null,
3037
+ "impute_strategy": "median",
3038
+ "profile_stats": {
3039
+ "missing_rate": 0.23,
3040
+ "unique_count": 20000,
3041
+ "unique_ratio": 0.427204,
3042
+ "example_values": [
3043
+ "87734",
3044
+ "13272",
3045
+ "2039720",
3046
+ "2079548",
3047
+ "8936"
3048
+ ]
3049
+ }
3050
+ },
3051
+ {
3052
+ "name": "dd_000",
3053
+ "role": "feature",
3054
+ "semantic_type": "numeric",
3055
+ "nullable": true,
3056
+ "missing_tokens": [
3057
+ "na"
3058
+ ],
3059
+ "parse_format": null,
3060
+ "impute_strategy": "median",
3061
+ "profile_stats": {
3062
+ "missing_rate": 0.041776,
3063
+ "unique_count": 6626,
3064
+ "unique_ratio": 0.113732,
3065
+ "example_values": [
3066
+ "128",
3067
+ "2812",
3068
+ "182",
3069
+ "1232",
3070
+ "2136"
3071
+ ]
3072
+ }
3073
+ },
3074
+ {
3075
+ "name": "de_000",
3076
+ "role": "feature",
3077
+ "semantic_type": "numeric",
3078
+ "nullable": true,
3079
+ "missing_tokens": [
3080
+ "na"
3081
+ ],
3082
+ "parse_format": null,
3083
+ "impute_strategy": "median",
3084
+ "profile_stats": {
3085
+ "missing_rate": 0.045691,
3086
+ "unique_count": 1935,
3087
+ "unique_ratio": 0.033349,
3088
+ "example_values": [
3089
+ "50",
3090
+ "270",
3091
+ "328",
3092
+ "116",
3093
+ "240"
3094
+ ]
3095
+ }
3096
+ },
3097
+ {
3098
+ "name": "df_000",
3099
+ "role": "feature",
3100
+ "semantic_type": "boolean",
3101
+ "nullable": true,
3102
+ "missing_tokens": [
3103
+ "na"
3104
+ ],
3105
+ "parse_format": null,
3106
+ "impute_strategy": "mode",
3107
+ "profile_stats": {
3108
+ "missing_rate": 0.066299,
3109
+ "unique_count": 404,
3110
+ "unique_ratio": 0.007117,
3111
+ "example_values": [
3112
+ "0",
3113
+ "40",
3114
+ "440",
3115
+ "1100",
3116
+ "2418750"
3117
+ ]
3118
+ }
3119
+ },
3120
+ {
3121
+ "name": "dg_000",
3122
+ "role": "feature",
3123
+ "semantic_type": "numeric",
3124
+ "nullable": true,
3125
+ "missing_tokens": [
3126
+ "na"
3127
+ ],
3128
+ "parse_format": null,
3129
+ "impute_strategy": "median",
3130
+ "profile_stats": {
3131
+ "missing_rate": 0.066283,
3132
+ "unique_count": 1333,
3133
+ "unique_ratio": 0.023481,
3134
+ "example_values": [
3135
+ "0",
3136
+ "1172",
3137
+ "17600",
3138
+ "10482",
3139
+ "4176232"
3140
+ ]
3141
+ }
3142
+ },
3143
+ {
3144
+ "name": "dh_000",
3145
+ "role": "feature",
3146
+ "semantic_type": "numeric",
3147
+ "nullable": true,
3148
+ "missing_tokens": [
3149
+ "na"
3150
+ ],
3151
+ "parse_format": null,
3152
+ "impute_strategy": "median",
3153
+ "profile_stats": {
3154
+ "missing_rate": 0.066299,
3155
+ "unique_count": 1059,
3156
+ "unique_ratio": 0.018655,
3157
+ "example_values": [
3158
+ "0",
3159
+ "80",
3160
+ "5510",
3161
+ "110",
3162
+ "160"
3163
+ ]
3164
+ }
3165
+ },
3166
+ {
3167
+ "name": "di_000",
3168
+ "role": "feature",
3169
+ "semantic_type": "numeric",
3170
+ "nullable": true,
3171
+ "missing_tokens": [
3172
+ "na"
3173
+ ],
3174
+ "parse_format": null,
3175
+ "impute_strategy": "median",
3176
+ "profile_stats": {
3177
+ "missing_rate": 0.066283,
3178
+ "unique_count": 5674,
3179
+ "unique_ratio": 0.099947,
3180
+ "example_values": [
3181
+ "0",
3182
+ "286",
3183
+ "36630",
3184
+ "7796",
3185
+ "66"
3186
+ ]
3187
+ }
3188
+ },
3189
+ {
3190
+ "name": "dj_000",
3191
+ "role": "feature",
3192
+ "semantic_type": "boolean",
3193
+ "nullable": true,
3194
+ "missing_tokens": [
3195
+ "na"
3196
+ ],
3197
+ "parse_format": null,
3198
+ "impute_strategy": "mode",
3199
+ "profile_stats": {
3200
+ "missing_rate": 0.066283,
3201
+ "unique_count": 72,
3202
+ "unique_ratio": 0.001268,
3203
+ "example_values": [
3204
+ "0",
3205
+ "40",
3206
+ "260",
3207
+ "10",
3208
+ "200"
3209
+ ]
3210
+ }
3211
+ },
3212
+ {
3213
+ "name": "dk_000",
3214
+ "role": "feature",
3215
+ "semantic_type": "boolean",
3216
+ "nullable": true,
3217
+ "missing_tokens": [
3218
+ "na"
3219
+ ],
3220
+ "parse_format": null,
3221
+ "impute_strategy": "mode",
3222
+ "profile_stats": {
3223
+ "missing_rate": 0.066283,
3224
+ "unique_count": 267,
3225
+ "unique_ratio": 0.004703,
3226
+ "example_values": [
3227
+ "0",
3228
+ "5646",
3229
+ "502",
3230
+ "54",
3231
+ "572"
3232
+ ]
3233
+ }
3234
+ },
3235
+ {
3236
+ "name": "dl_000",
3237
+ "role": "feature",
3238
+ "semantic_type": "boolean",
3239
+ "nullable": true,
3240
+ "missing_tokens": [
3241
+ "na"
3242
+ ],
3243
+ "parse_format": null,
3244
+ "impute_strategy": "mode",
3245
+ "profile_stats": {
3246
+ "missing_rate": 0.066299,
3247
+ "unique_count": 191,
3248
+ "unique_ratio": 0.003365,
3249
+ "example_values": [
3250
+ "0",
3251
+ "160",
3252
+ "1190",
3253
+ "25620",
3254
+ "1900"
3255
+ ]
3256
+ }
3257
+ },
3258
+ {
3259
+ "name": "dm_000",
3260
+ "role": "feature",
3261
+ "semantic_type": "boolean",
3262
+ "nullable": true,
3263
+ "missing_tokens": [
3264
+ "na"
3265
+ ],
3266
+ "parse_format": null,
3267
+ "impute_strategy": "mode",
3268
+ "profile_stats": {
3269
+ "missing_rate": 0.066299,
3270
+ "unique_count": 236,
3271
+ "unique_ratio": 0.004157,
3272
+ "example_values": [
3273
+ "0",
3274
+ "7842",
3275
+ "47464",
3276
+ "136746",
3277
+ "25864"
3278
+ ]
3279
+ }
3280
+ },
3281
+ {
3282
+ "name": "dn_000",
3283
+ "role": "feature",
3284
+ "semantic_type": "numeric",
3285
+ "nullable": true,
3286
+ "missing_tokens": [
3287
+ "na"
3288
+ ],
3289
+ "parse_format": null,
3290
+ "impute_strategy": "median",
3291
+ "profile_stats": {
3292
+ "missing_rate": 0.011365,
3293
+ "unique_count": 20000,
3294
+ "unique_ratio": 0.332729,
3295
+ "example_values": [
3296
+ "582",
3297
+ "18072",
3298
+ "676",
3299
+ "15162",
3300
+ "24566"
3301
+ ]
3302
+ }
3303
+ },
3304
+ {
3305
+ "name": "do_000",
3306
+ "role": "feature",
3307
+ "semantic_type": "numeric",
3308
+ "nullable": true,
3309
+ "missing_tokens": [
3310
+ "na"
3311
+ ],
3312
+ "parse_format": null,
3313
+ "impute_strategy": "median",
3314
+ "profile_stats": {
3315
+ "missing_rate": 0.045674,
3316
+ "unique_count": 20000,
3317
+ "unique_ratio": 0.344691,
3318
+ "example_values": [
3319
+ "676",
3320
+ "71612",
3321
+ "0",
3322
+ "27588",
3323
+ "27348"
3324
+ ]
3325
+ }
3326
+ },
3327
+ {
3328
+ "name": "dp_000",
3329
+ "role": "feature",
3330
+ "semantic_type": "numeric",
3331
+ "nullable": true,
3332
+ "missing_tokens": [
3333
+ "na"
3334
+ ],
3335
+ "parse_format": null,
3336
+ "impute_strategy": "median",
3337
+ "profile_stats": {
3338
+ "missing_rate": 0.045707,
3339
+ "unique_count": 11680,
3340
+ "unique_ratio": 0.201306,
3341
+ "example_values": [
3342
+ "274",
3343
+ "14700",
3344
+ "0",
3345
+ "6920",
3346
+ "9376"
3347
+ ]
3348
+ }
3349
+ },
3350
+ {
3351
+ "name": "dq_000",
3352
+ "role": "feature",
3353
+ "semantic_type": "numeric",
3354
+ "nullable": true,
3355
+ "missing_tokens": [
3356
+ "na"
3357
+ ],
3358
+ "parse_format": null,
3359
+ "impute_strategy": "median",
3360
+ "profile_stats": {
3361
+ "missing_rate": 0.045707,
3362
+ "unique_count": 8172,
3363
+ "unique_ratio": 0.140846,
3364
+ "example_values": [
3365
+ "0",
3366
+ "5916",
3367
+ "80",
3368
+ "46424",
3369
+ "1634"
3370
+ ]
3371
+ }
3372
+ },
3373
+ {
3374
+ "name": "dr_000",
3375
+ "role": "feature",
3376
+ "semantic_type": "numeric",
3377
+ "nullable": true,
3378
+ "missing_tokens": [
3379
+ "na"
3380
+ ],
3381
+ "parse_format": null,
3382
+ "impute_strategy": "median",
3383
+ "profile_stats": {
3384
+ "missing_rate": 0.045707,
3385
+ "unique_count": 6718,
3386
+ "unique_ratio": 0.115786,
3387
+ "example_values": [
3388
+ "0",
3389
+ "1822",
3390
+ "20",
3391
+ "22158",
3392
+ "462"
3393
+ ]
3394
+ }
3395
+ },
3396
+ {
3397
+ "name": "ds_000",
3398
+ "role": "feature",
3399
+ "semantic_type": "numeric",
3400
+ "nullable": true,
3401
+ "missing_tokens": [
3402
+ "na"
3403
+ ],
3404
+ "parse_format": null,
3405
+ "impute_strategy": "median",
3406
+ "profile_stats": {
3407
+ "missing_rate": 0.045724,
3408
+ "unique_count": 20000,
3409
+ "unique_ratio": 0.344709,
3410
+ "example_values": [
3411
+ "1818",
3412
+ "195476",
3413
+ "382",
3414
+ "67782",
3415
+ "81362"
3416
+ ]
3417
+ }
3418
+ },
3419
+ {
3420
+ "name": "dt_000",
3421
+ "role": "feature",
3422
+ "semantic_type": "numeric",
3423
+ "nullable": true,
3424
+ "missing_tokens": [
3425
+ "na"
3426
+ ],
3427
+ "parse_format": null,
3428
+ "impute_strategy": "median",
3429
+ "profile_stats": {
3430
+ "missing_rate": 0.045724,
3431
+ "unique_count": 15973,
3432
+ "unique_ratio": 0.275302,
3433
+ "example_values": [
3434
+ "366",
3435
+ "45576",
3436
+ "118",
3437
+ "9494",
3438
+ "14780"
3439
+ ]
3440
+ }
3441
+ },
3442
+ {
3443
+ "name": "du_000",
3444
+ "role": "feature",
3445
+ "semantic_type": "numeric",
3446
+ "nullable": true,
3447
+ "missing_tokens": [
3448
+ "na"
3449
+ ],
3450
+ "parse_format": null,
3451
+ "impute_strategy": "median",
3452
+ "profile_stats": {
3453
+ "missing_rate": 0.045707,
3454
+ "unique_count": 20000,
3455
+ "unique_ratio": 0.344703,
3456
+ "example_values": [
3457
+ "172440",
3458
+ "4797440",
3459
+ "44360",
3460
+ "50580",
3461
+ "7797080"
3462
+ ]
3463
+ }
3464
+ },
3465
+ {
3466
+ "name": "dv_000",
3467
+ "role": "feature",
3468
+ "semantic_type": "numeric",
3469
+ "nullable": true,
3470
+ "missing_tokens": [
3471
+ "na"
3472
+ ],
3473
+ "parse_format": null,
3474
+ "impute_strategy": "median",
3475
+ "profile_stats": {
3476
+ "missing_rate": 0.045707,
3477
+ "unique_count": 20000,
3478
+ "unique_ratio": 0.344703,
3479
+ "example_values": [
3480
+ "17258",
3481
+ "2234018",
3482
+ "4450",
3483
+ "10454",
3484
+ "1354532"
3485
+ ]
3486
+ }
3487
+ },
3488
+ {
3489
+ "name": "dx_000",
3490
+ "role": "feature",
3491
+ "semantic_type": "numeric",
3492
+ "nullable": true,
3493
+ "missing_tokens": [
3494
+ "na"
3495
+ ],
3496
+ "parse_format": null,
3497
+ "impute_strategy": "median",
3498
+ "profile_stats": {
3499
+ "missing_rate": 0.045691,
3500
+ "unique_count": 14891,
3501
+ "unique_ratio": 0.256644,
3502
+ "example_values": [
3503
+ "28760",
3504
+ "0",
3505
+ "9742",
3506
+ "9654",
3507
+ "54468"
3508
+ ]
3509
+ }
3510
+ },
3511
+ {
3512
+ "name": "dy_000",
3513
+ "role": "feature",
3514
+ "semantic_type": "numeric",
3515
+ "nullable": true,
3516
+ "missing_tokens": [
3517
+ "na"
3518
+ ],
3519
+ "parse_format": null,
3520
+ "impute_strategy": "median",
3521
+ "profile_stats": {
3522
+ "missing_rate": 0.045707,
3523
+ "unique_count": 6366,
3524
+ "unique_ratio": 0.109719,
3525
+ "example_values": [
3526
+ "96",
3527
+ "0",
3528
+ "12",
3529
+ "26",
3530
+ "76"
3531
+ ]
3532
+ }
3533
+ },
3534
+ {
3535
+ "name": "dz_000",
3536
+ "role": "feature",
3537
+ "semantic_type": "boolean",
3538
+ "nullable": true,
3539
+ "missing_tokens": [
3540
+ "na"
3541
+ ],
3542
+ "parse_format": null,
3543
+ "impute_strategy": "mode",
3544
+ "profile_stats": {
3545
+ "missing_rate": 0.045674,
3546
+ "unique_count": 45,
3547
+ "unique_ratio": 0.000776,
3548
+ "example_values": [
3549
+ "0",
3550
+ "2",
3551
+ "6",
3552
+ "12",
3553
+ "4"
3554
+ ]
3555
+ }
3556
+ },
3557
+ {
3558
+ "name": "ea_000",
3559
+ "role": "feature",
3560
+ "semantic_type": "boolean",
3561
+ "nullable": true,
3562
+ "missing_tokens": [
3563
+ "na"
3564
+ ],
3565
+ "parse_format": null,
3566
+ "impute_strategy": "mode",
3567
+ "profile_stats": {
3568
+ "missing_rate": 0.045674,
3569
+ "unique_count": 131,
3570
+ "unique_ratio": 0.002258,
3571
+ "example_values": [
3572
+ "0",
3573
+ "2",
3574
+ "8",
3575
+ "10",
3576
+ "18"
3577
+ ]
3578
+ }
3579
+ },
3580
+ {
3581
+ "name": "eb_000",
3582
+ "role": "feature",
3583
+ "semantic_type": "numeric",
3584
+ "nullable": true,
3585
+ "missing_tokens": [
3586
+ "na"
3587
+ ],
3588
+ "parse_format": null,
3589
+ "impute_strategy": "median",
3590
+ "profile_stats": {
3591
+ "missing_rate": 0.066283,
3592
+ "unique_count": 20000,
3593
+ "unique_ratio": 0.352299,
3594
+ "example_values": [
3595
+ "655720",
3596
+ "1186300",
3597
+ "0",
3598
+ "1304800",
3599
+ "2929070"
3600
+ ]
3601
+ }
3602
+ },
3603
+ {
3604
+ "name": "ec_00",
3605
+ "role": "feature",
3606
+ "semantic_type": "numeric",
3607
+ "nullable": true,
3608
+ "missing_tokens": [
3609
+ "na"
3610
+ ],
3611
+ "parse_format": null,
3612
+ "impute_strategy": "median",
3613
+ "profile_stats": {
3614
+ "missing_rate": 0.167862,
3615
+ "unique_count": 20000,
3616
+ "unique_ratio": 0.395304,
3617
+ "example_values": [
3618
+ "65.78",
3619
+ "277.6",
3620
+ "687.2",
3621
+ "1133.78",
3622
+ "127.84"
3623
+ ]
3624
+ }
3625
+ },
3626
+ {
3627
+ "name": "ed_000",
3628
+ "role": "feature",
3629
+ "semantic_type": "numeric",
3630
+ "nullable": true,
3631
+ "missing_tokens": [
3632
+ "na"
3633
+ ],
3634
+ "parse_format": null,
3635
+ "impute_strategy": "median",
3636
+ "profile_stats": {
3637
+ "missing_rate": 0.156793,
3638
+ "unique_count": 3976,
3639
+ "unique_ratio": 0.077555,
3640
+ "example_values": [
3641
+ "68",
3642
+ "130",
3643
+ "756",
3644
+ "1192",
3645
+ "70"
3646
+ ]
3647
+ }
3648
+ },
3649
+ {
3650
+ "name": "ee_000",
3651
+ "role": "feature",
3652
+ "semantic_type": "numeric",
3653
+ "nullable": true,
3654
+ "missing_tokens": [
3655
+ "na"
3656
+ ],
3657
+ "parse_format": null,
3658
+ "impute_strategy": "median",
3659
+ "profile_stats": {
3660
+ "missing_rate": 0.011431,
3661
+ "unique_count": 20000,
3662
+ "unique_ratio": 0.332751,
3663
+ "example_values": [
3664
+ "13308",
3665
+ "536366",
3666
+ "23816",
3667
+ "258900",
3668
+ "622930"
3669
+ ]
3670
+ }
3671
+ },
3672
+ {
3673
+ "name": "ee_001",
3674
+ "role": "feature",
3675
+ "semantic_type": "numeric",
3676
+ "nullable": true,
3677
+ "missing_tokens": [
3678
+ "na"
3679
+ ],
3680
+ "parse_format": null,
3681
+ "impute_strategy": "median",
3682
+ "profile_stats": {
3683
+ "missing_rate": 0.011431,
3684
+ "unique_count": 20000,
3685
+ "unique_ratio": 0.332751,
3686
+ "example_values": [
3687
+ "12120",
3688
+ "707172",
3689
+ "6194",
3690
+ "312464",
3691
+ "546652"
3692
+ ]
3693
+ }
3694
+ },
3695
+ {
3696
+ "name": "ee_002",
3697
+ "role": "feature",
3698
+ "semantic_type": "numeric",
3699
+ "nullable": true,
3700
+ "missing_tokens": [
3701
+ "na"
3702
+ ],
3703
+ "parse_format": null,
3704
+ "impute_strategy": "median",
3705
+ "profile_stats": {
3706
+ "missing_rate": 0.011431,
3707
+ "unique_count": 20000,
3708
+ "unique_ratio": 0.332751,
3709
+ "example_values": [
3710
+ "5308",
3711
+ "421568",
3712
+ "1256",
3713
+ "262268",
3714
+ "319658"
3715
+ ]
3716
+ }
3717
+ },
3718
+ {
3719
+ "name": "ee_003",
3720
+ "role": "feature",
3721
+ "semantic_type": "numeric",
3722
+ "nullable": true,
3723
+ "missing_tokens": [
3724
+ "na"
3725
+ ],
3726
+ "parse_format": null,
3727
+ "impute_strategy": "median",
3728
+ "profile_stats": {
3729
+ "missing_rate": 0.011431,
3730
+ "unique_count": 20000,
3731
+ "unique_ratio": 0.332751,
3732
+ "example_values": [
3733
+ "3258",
3734
+ "212454",
3735
+ "542",
3736
+ "152306",
3737
+ "144106"
3738
+ ]
3739
+ }
3740
+ },
3741
+ {
3742
+ "name": "ee_004",
3743
+ "role": "feature",
3744
+ "semantic_type": "numeric",
3745
+ "nullable": true,
3746
+ "missing_tokens": [
3747
+ "na"
3748
+ ],
3749
+ "parse_format": null,
3750
+ "impute_strategy": "median",
3751
+ "profile_stats": {
3752
+ "missing_rate": 0.011431,
3753
+ "unique_count": 20000,
3754
+ "unique_ratio": 0.332751,
3755
+ "example_values": [
3756
+ "8582",
3757
+ "446284",
3758
+ "1046",
3759
+ "325008",
3760
+ "283446"
3761
+ ]
3762
+ }
3763
+ },
3764
+ {
3765
+ "name": "ee_005",
3766
+ "role": "feature",
3767
+ "semantic_type": "numeric",
3768
+ "nullable": true,
3769
+ "missing_tokens": [
3770
+ "na"
3771
+ ],
3772
+ "parse_format": null,
3773
+ "impute_strategy": "median",
3774
+ "profile_stats": {
3775
+ "missing_rate": 0.011431,
3776
+ "unique_count": 20000,
3777
+ "unique_ratio": 0.332751,
3778
+ "example_values": [
3779
+ "43912",
3780
+ "460602",
3781
+ "350",
3782
+ "446416",
3783
+ "260842"
3784
+ ]
3785
+ }
3786
+ },
3787
+ {
3788
+ "name": "ee_006",
3789
+ "role": "feature",
3790
+ "semantic_type": "numeric",
3791
+ "nullable": true,
3792
+ "missing_tokens": [
3793
+ "na"
3794
+ ],
3795
+ "parse_format": null,
3796
+ "impute_strategy": "median",
3797
+ "profile_stats": {
3798
+ "missing_rate": 0.011431,
3799
+ "unique_count": 20000,
3800
+ "unique_ratio": 0.332751,
3801
+ "example_values": [
3802
+ "6370",
3803
+ "374400",
3804
+ "680",
3805
+ "377770",
3806
+ "168748"
3807
+ ]
3808
+ }
3809
+ },
3810
+ {
3811
+ "name": "ee_007",
3812
+ "role": "feature",
3813
+ "semantic_type": "numeric",
3814
+ "nullable": true,
3815
+ "missing_tokens": [
3816
+ "na"
3817
+ ],
3818
+ "parse_format": null,
3819
+ "impute_strategy": "median",
3820
+ "profile_stats": {
3821
+ "missing_rate": 0.011431,
3822
+ "unique_count": 20000,
3823
+ "unique_ratio": 0.332751,
3824
+ "example_values": [
3825
+ "2886",
3826
+ "371258",
3827
+ "1112",
3828
+ "76752",
3829
+ "108786"
3830
+ ]
3831
+ }
3832
+ },
3833
+ {
3834
+ "name": "ee_008",
3835
+ "role": "feature",
3836
+ "semantic_type": "numeric",
3837
+ "nullable": true,
3838
+ "missing_tokens": [
3839
+ "na"
3840
+ ],
3841
+ "parse_format": null,
3842
+ "impute_strategy": "median",
3843
+ "profile_stats": {
3844
+ "missing_rate": 0.011431,
3845
+ "unique_count": 20000,
3846
+ "unique_ratio": 0.332751,
3847
+ "example_values": [
3848
+ "2584",
3849
+ "2041592",
3850
+ "0",
3851
+ "55228",
3852
+ "151796"
3853
+ ]
3854
+ }
3855
+ },
3856
+ {
3857
+ "name": "ee_009",
3858
+ "role": "feature",
3859
+ "semantic_type": "numeric",
3860
+ "nullable": true,
3861
+ "missing_tokens": [
3862
+ "na"
3863
+ ],
3864
+ "parse_format": null,
3865
+ "impute_strategy": "median",
3866
+ "profile_stats": {
3867
+ "missing_rate": 0.011431,
3868
+ "unique_count": 9722,
3869
+ "unique_ratio": 0.16175,
3870
+ "example_values": [
3871
+ "156",
3872
+ "321636",
3873
+ "0",
3874
+ "944",
3875
+ "12404"
3876
+ ]
3877
+ }
3878
+ },
3879
+ {
3880
+ "name": "ef_000",
3881
+ "role": "feature",
3882
+ "semantic_type": "boolean",
3883
+ "nullable": true,
3884
+ "missing_tokens": [
3885
+ "na"
3886
+ ],
3887
+ "parse_format": null,
3888
+ "impute_strategy": "mode",
3889
+ "profile_stats": {
3890
+ "missing_rate": 0.045691,
3891
+ "unique_count": 27,
3892
+ "unique_ratio": 0.000465,
3893
+ "example_values": [
3894
+ "0",
3895
+ "2",
3896
+ "8",
3897
+ "4",
3898
+ "362"
3899
+ ]
3900
+ }
3901
+ },
3902
+ {
3903
+ "name": "eg_000",
3904
+ "role": "feature",
3905
+ "semantic_type": "boolean",
3906
+ "nullable": true,
3907
+ "missing_tokens": [
3908
+ "na"
3909
+ ],
3910
+ "parse_format": null,
3911
+ "impute_strategy": "mode",
3912
+ "profile_stats": {
3913
+ "missing_rate": 0.045674,
3914
+ "unique_count": 49,
3915
+ "unique_ratio": 0.000844,
3916
+ "example_values": [
3917
+ "0",
3918
+ "2",
3919
+ "6",
3920
+ "8",
3921
+ "20"
3922
+ ]
3923
+ }
3924
+ }
3925
+ ]
3926
+ }
syntheticFail/n18/tabddpm/tabddpm-n18-20260510_215518/public_gate/public_gate_report.json ADDED
@@ -0,0 +1,37 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "dataset_id": "n18",
3
+ "status": "pass",
4
+ "checks": [
5
+ {
6
+ "check_id": "PG001_csv_parse_ok",
7
+ "status": "pass"
8
+ },
9
+ {
10
+ "check_id": "PG002_split_header_consistent",
11
+ "status": "pass"
12
+ },
13
+ {
14
+ "check_id": "PG003_profile_header_match",
15
+ "status": "pass"
16
+ },
17
+ {
18
+ "check_id": "PG004_missing_token_normalized",
19
+ "status": "pass"
20
+ },
21
+ {
22
+ "check_id": "PG005_semantic_type_validated",
23
+ "status": "pass"
24
+ },
25
+ {
26
+ "check_id": "PG006_target_defined_and_valid",
27
+ "status": "pass"
28
+ }
29
+ ],
30
+ "target_column": "class",
31
+ "task_type": "classification",
32
+ "input_splits": {
33
+ "train": "/data/jialinzhang/SynthesizePipeline-server/DatasetNew/n18/n18-train.csv",
34
+ "val": "/data/jialinzhang/SynthesizePipeline-server/DatasetNew/n18/n18-val.csv",
35
+ "test": "/data/jialinzhang/SynthesizePipeline-server/DatasetNew/n18/n18-test.csv"
36
+ }
37
+ }
syntheticFail/n18/tabddpm/tabddpm-n18-20260510_215518/public_gate/staged_input_manifest.json ADDED
@@ -0,0 +1,3931 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "dataset_id": "n18",
3
+ "target_column": "class",
4
+ "task_type": "classification",
5
+ "train_csv": "/data/jialinzhang/SynthesizePipeline-server/output-Benchmark-trainonly-v1/n18/tabddpm/tabddpm-n18-20260510_215518/staged/public/train.csv",
6
+ "val_csv": "/data/jialinzhang/SynthesizePipeline-server/output-Benchmark-trainonly-v1/n18/tabddpm/tabddpm-n18-20260510_215518/staged/public/val.csv",
7
+ "test_csv": "/data/jialinzhang/SynthesizePipeline-server/output-Benchmark-trainonly-v1/n18/tabddpm/tabddpm-n18-20260510_215518/staged/public/test.csv",
8
+ "features_json": "/data/jialinzhang/SynthesizePipeline-server/output-Benchmark-trainonly-v1/n18/tabddpm/tabddpm-n18-20260510_215518/staged/public/staged_features.json",
9
+ "public_gate_report": "/data/jialinzhang/SynthesizePipeline-server/output-Benchmark-trainonly-v1/n18/tabddpm/tabddpm-n18-20260510_215518/public_gate/public_gate_report.json",
10
+ "column_schema": [
11
+ {
12
+ "name": "class",
13
+ "role": "target",
14
+ "semantic_type": "categorical",
15
+ "nullable": false,
16
+ "missing_tokens": [],
17
+ "parse_format": null,
18
+ "impute_strategy": "mode",
19
+ "profile_stats": {
20
+ "missing_rate": 0.0,
21
+ "unique_count": 2,
22
+ "unique_ratio": 3.3e-05,
23
+ "example_values": [
24
+ "neg",
25
+ "pos"
26
+ ]
27
+ }
28
+ },
29
+ {
30
+ "name": "aa_000",
31
+ "role": "feature",
32
+ "semantic_type": "numeric",
33
+ "nullable": false,
34
+ "missing_tokens": [],
35
+ "parse_format": null,
36
+ "impute_strategy": "median",
37
+ "profile_stats": {
38
+ "missing_rate": 0.0,
39
+ "unique_count": 20000,
40
+ "unique_ratio": 0.328947,
41
+ "example_values": [
42
+ "1656",
43
+ "118600",
44
+ "130",
45
+ "37016",
46
+ "32930"
47
+ ]
48
+ }
49
+ },
50
+ {
51
+ "name": "ab_000",
52
+ "role": "feature",
53
+ "semantic_type": "numeric",
54
+ "nullable": true,
55
+ "missing_tokens": [
56
+ "na"
57
+ ],
58
+ "parse_format": null,
59
+ "impute_strategy": "median",
60
+ "profile_stats": {
61
+ "missing_rate": 0.772253,
62
+ "unique_count": 30,
63
+ "unique_ratio": 0.002167,
64
+ "example_values": [
65
+ "0",
66
+ "2",
67
+ "4",
68
+ "58",
69
+ "18"
70
+ ]
71
+ }
72
+ },
73
+ {
74
+ "name": "ac_000",
75
+ "role": "feature",
76
+ "semantic_type": "numeric",
77
+ "nullable": true,
78
+ "missing_tokens": [
79
+ "na"
80
+ ],
81
+ "parse_format": null,
82
+ "impute_strategy": "median",
83
+ "profile_stats": {
84
+ "missing_rate": 0.055691,
85
+ "unique_count": 2095,
86
+ "unique_ratio": 0.036489,
87
+ "example_values": [
88
+ "126",
89
+ "0",
90
+ "76",
91
+ "1204",
92
+ "2130706432"
93
+ ]
94
+ }
95
+ },
96
+ {
97
+ "name": "ad_000",
98
+ "role": "feature",
99
+ "semantic_type": "numeric",
100
+ "nullable": true,
101
+ "missing_tokens": [
102
+ "na"
103
+ ],
104
+ "parse_format": null,
105
+ "impute_strategy": "median",
106
+ "profile_stats": {
107
+ "missing_rate": 0.246727,
108
+ "unique_count": 1897,
109
+ "unique_ratio": 0.04142,
110
+ "example_values": [
111
+ "118",
112
+ "68",
113
+ "952",
114
+ "1484",
115
+ "24"
116
+ ]
117
+ }
118
+ },
119
+ {
120
+ "name": "ae_000",
121
+ "role": "feature",
122
+ "semantic_type": "numeric",
123
+ "nullable": true,
124
+ "missing_tokens": [
125
+ "na"
126
+ ],
127
+ "parse_format": null,
128
+ "impute_strategy": "median",
129
+ "profile_stats": {
130
+ "missing_rate": 0.041727,
131
+ "unique_count": 324,
132
+ "unique_ratio": 0.005561,
133
+ "example_values": [
134
+ "0",
135
+ "120",
136
+ "2",
137
+ "58",
138
+ "74"
139
+ ]
140
+ }
141
+ },
142
+ {
143
+ "name": "af_000",
144
+ "role": "feature",
145
+ "semantic_type": "numeric",
146
+ "nullable": true,
147
+ "missing_tokens": [
148
+ "na"
149
+ ],
150
+ "parse_format": null,
151
+ "impute_strategy": "median",
152
+ "profile_stats": {
153
+ "missing_rate": 0.041727,
154
+ "unique_count": 418,
155
+ "unique_ratio": 0.007174,
156
+ "example_values": [
157
+ "0",
158
+ "214",
159
+ "2",
160
+ "98",
161
+ "608"
162
+ ]
163
+ }
164
+ },
165
+ {
166
+ "name": "ag_000",
167
+ "role": "feature",
168
+ "semantic_type": "boolean",
169
+ "nullable": true,
170
+ "missing_tokens": [
171
+ "na"
172
+ ],
173
+ "parse_format": null,
174
+ "impute_strategy": "mode",
175
+ "profile_stats": {
176
+ "missing_rate": 0.011382,
177
+ "unique_count": 166,
178
+ "unique_ratio": 0.002762,
179
+ "example_values": [
180
+ "0",
181
+ "228",
182
+ "318",
183
+ "6554",
184
+ "10"
185
+ ]
186
+ }
187
+ },
188
+ {
189
+ "name": "ag_001",
190
+ "role": "feature",
191
+ "semantic_type": "boolean",
192
+ "nullable": true,
193
+ "missing_tokens": [
194
+ "na"
195
+ ],
196
+ "parse_format": null,
197
+ "impute_strategy": "mode",
198
+ "profile_stats": {
199
+ "missing_rate": 0.011382,
200
+ "unique_count": 659,
201
+ "unique_ratio": 0.010964,
202
+ "example_values": [
203
+ "0",
204
+ "2276",
205
+ "102",
206
+ "32",
207
+ "5128"
208
+ ]
209
+ }
210
+ },
211
+ {
212
+ "name": "ag_002",
213
+ "role": "feature",
214
+ "semantic_type": "numeric",
215
+ "nullable": true,
216
+ "missing_tokens": [
217
+ "na"
218
+ ],
219
+ "parse_format": null,
220
+ "impute_strategy": "median",
221
+ "profile_stats": {
222
+ "missing_rate": 0.011382,
223
+ "unique_count": 2456,
224
+ "unique_ratio": 0.04086,
225
+ "example_values": [
226
+ "0",
227
+ "108",
228
+ "38",
229
+ "5274",
230
+ "292"
231
+ ]
232
+ }
233
+ },
234
+ {
235
+ "name": "ag_003",
236
+ "role": "feature",
237
+ "semantic_type": "numeric",
238
+ "nullable": true,
239
+ "missing_tokens": [
240
+ "na"
241
+ ],
242
+ "parse_format": null,
243
+ "impute_strategy": "median",
244
+ "profile_stats": {
245
+ "missing_rate": 0.011382,
246
+ "unique_count": 7967,
247
+ "unique_ratio": 0.132545,
248
+ "example_values": [
249
+ "0",
250
+ "8608",
251
+ "4038",
252
+ "2450",
253
+ "548"
254
+ ]
255
+ }
256
+ },
257
+ {
258
+ "name": "ag_004",
259
+ "role": "feature",
260
+ "semantic_type": "numeric",
261
+ "nullable": true,
262
+ "missing_tokens": [
263
+ "na"
264
+ ],
265
+ "parse_format": null,
266
+ "impute_strategy": "median",
267
+ "profile_stats": {
268
+ "missing_rate": 0.011382,
269
+ "unique_count": 20000,
270
+ "unique_ratio": 0.332734,
271
+ "example_values": [
272
+ "98",
273
+ "2346",
274
+ "16590",
275
+ "14782",
276
+ "204"
277
+ ]
278
+ }
279
+ },
280
+ {
281
+ "name": "ag_005",
282
+ "role": "feature",
283
+ "semantic_type": "numeric",
284
+ "nullable": true,
285
+ "missing_tokens": [
286
+ "na"
287
+ ],
288
+ "parse_format": null,
289
+ "impute_strategy": "median",
290
+ "profile_stats": {
291
+ "missing_rate": 0.011382,
292
+ "unique_count": 20000,
293
+ "unique_ratio": 0.332734,
294
+ "example_values": [
295
+ "54",
296
+ "853922",
297
+ "7546",
298
+ "701688",
299
+ "79236"
300
+ ]
301
+ }
302
+ },
303
+ {
304
+ "name": "ag_006",
305
+ "role": "feature",
306
+ "semantic_type": "numeric",
307
+ "nullable": true,
308
+ "missing_tokens": [
309
+ "na"
310
+ ],
311
+ "parse_format": null,
312
+ "impute_strategy": "median",
313
+ "profile_stats": {
314
+ "missing_rate": 0.011382,
315
+ "unique_count": 20000,
316
+ "unique_ratio": 0.332734,
317
+ "example_values": [
318
+ "90380",
319
+ "4077182",
320
+ "2252",
321
+ "1212560",
322
+ "1555662"
323
+ ]
324
+ }
325
+ },
326
+ {
327
+ "name": "ag_007",
328
+ "role": "feature",
329
+ "semantic_type": "numeric",
330
+ "nullable": true,
331
+ "missing_tokens": [
332
+ "na"
333
+ ],
334
+ "parse_format": null,
335
+ "impute_strategy": "median",
336
+ "profile_stats": {
337
+ "missing_rate": 0.011382,
338
+ "unique_count": 20000,
339
+ "unique_ratio": 0.332734,
340
+ "example_values": [
341
+ "7952",
342
+ "940762",
343
+ "0",
344
+ "330356",
345
+ "939740"
346
+ ]
347
+ }
348
+ },
349
+ {
350
+ "name": "ag_008",
351
+ "role": "feature",
352
+ "semantic_type": "numeric",
353
+ "nullable": true,
354
+ "missing_tokens": [
355
+ "na"
356
+ ],
357
+ "parse_format": null,
358
+ "impute_strategy": "median",
359
+ "profile_stats": {
360
+ "missing_rate": 0.011382,
361
+ "unique_count": 19086,
362
+ "unique_ratio": 0.317528,
363
+ "example_values": [
364
+ "0",
365
+ "19120",
366
+ "8670",
367
+ "44210",
368
+ "23162"
369
+ ]
370
+ }
371
+ },
372
+ {
373
+ "name": "ag_009",
374
+ "role": "feature",
375
+ "semantic_type": "numeric",
376
+ "nullable": true,
377
+ "missing_tokens": [
378
+ "na"
379
+ ],
380
+ "parse_format": null,
381
+ "impute_strategy": "median",
382
+ "profile_stats": {
383
+ "missing_rate": 0.011382,
384
+ "unique_count": 5398,
385
+ "unique_ratio": 0.089805,
386
+ "example_values": [
387
+ "0",
388
+ "316",
389
+ "1758",
390
+ "576",
391
+ "552"
392
+ ]
393
+ }
394
+ },
395
+ {
396
+ "name": "ah_000",
397
+ "role": "feature",
398
+ "semantic_type": "numeric",
399
+ "nullable": true,
400
+ "missing_tokens": [
401
+ "na"
402
+ ],
403
+ "parse_format": null,
404
+ "impute_strategy": "median",
405
+ "profile_stats": {
406
+ "missing_rate": 0.010559,
407
+ "unique_count": 20000,
408
+ "unique_ratio": 0.332458,
409
+ "example_values": [
410
+ "36080",
411
+ "3165022",
412
+ "10518",
413
+ "1060220",
414
+ "1167164"
415
+ ]
416
+ }
417
+ },
418
+ {
419
+ "name": "ai_000",
420
+ "role": "feature",
421
+ "semantic_type": "numeric",
422
+ "nullable": true,
423
+ "missing_tokens": [
424
+ "na"
425
+ ],
426
+ "parse_format": null,
427
+ "impute_strategy": "median",
428
+ "profile_stats": {
429
+ "missing_rate": 0.01023,
430
+ "unique_count": 4180,
431
+ "unique_ratio": 0.069461,
432
+ "example_values": [
433
+ "0",
434
+ "918",
435
+ "3658",
436
+ "10814",
437
+ "2628"
438
+ ]
439
+ }
440
+ },
441
+ {
442
+ "name": "aj_000",
443
+ "role": "feature",
444
+ "semantic_type": "numeric",
445
+ "nullable": true,
446
+ "missing_tokens": [
447
+ "na"
448
+ ],
449
+ "parse_format": null,
450
+ "impute_strategy": "median",
451
+ "profile_stats": {
452
+ "missing_rate": 0.01023,
453
+ "unique_count": 913,
454
+ "unique_ratio": 0.015172,
455
+ "example_values": [
456
+ "0",
457
+ "114",
458
+ "146",
459
+ "58",
460
+ "70"
461
+ ]
462
+ }
463
+ },
464
+ {
465
+ "name": "ak_000",
466
+ "role": "feature",
467
+ "semantic_type": "boolean",
468
+ "nullable": true,
469
+ "missing_tokens": [
470
+ "na"
471
+ ],
472
+ "parse_format": null,
473
+ "impute_strategy": "mode",
474
+ "profile_stats": {
475
+ "missing_rate": 0.072632,
476
+ "unique_count": 169,
477
+ "unique_ratio": 0.002997,
478
+ "example_values": [
479
+ "0",
480
+ "1840",
481
+ "142646",
482
+ "1124",
483
+ "2130"
484
+ ]
485
+ }
486
+ },
487
+ {
488
+ "name": "al_000",
489
+ "role": "feature",
490
+ "semantic_type": "numeric",
491
+ "nullable": true,
492
+ "missing_tokens": [
493
+ "na"
494
+ ],
495
+ "parse_format": null,
496
+ "impute_strategy": "median",
497
+ "profile_stats": {
498
+ "missing_rate": 0.010526,
499
+ "unique_count": 9127,
500
+ "unique_ratio": 0.151712,
501
+ "example_values": [
502
+ "0",
503
+ "5610",
504
+ "2",
505
+ "5636",
506
+ "2068"
507
+ ]
508
+ }
509
+ },
510
+ {
511
+ "name": "am_0",
512
+ "role": "feature",
513
+ "semantic_type": "numeric",
514
+ "nullable": true,
515
+ "missing_tokens": [
516
+ "na"
517
+ ],
518
+ "parse_format": null,
519
+ "impute_strategy": "median",
520
+ "profile_stats": {
521
+ "missing_rate": 0.01023,
522
+ "unique_count": 10700,
523
+ "unique_ratio": 0.177806,
524
+ "example_values": [
525
+ "0",
526
+ "10568",
527
+ "112",
528
+ "8558",
529
+ "3108"
530
+ ]
531
+ }
532
+ },
533
+ {
534
+ "name": "an_000",
535
+ "role": "feature",
536
+ "semantic_type": "numeric",
537
+ "nullable": true,
538
+ "missing_tokens": [
539
+ "na"
540
+ ],
541
+ "parse_format": null,
542
+ "impute_strategy": "median",
543
+ "profile_stats": {
544
+ "missing_rate": 0.010526,
545
+ "unique_count": 20000,
546
+ "unique_ratio": 0.332447,
547
+ "example_values": [
548
+ "89692",
549
+ "5651638",
550
+ "27644",
551
+ "2094250",
552
+ "2398938"
553
+ ]
554
+ }
555
+ },
556
+ {
557
+ "name": "ao_000",
558
+ "role": "feature",
559
+ "semantic_type": "numeric",
560
+ "nullable": true,
561
+ "missing_tokens": [
562
+ "na"
563
+ ],
564
+ "parse_format": null,
565
+ "impute_strategy": "median",
566
+ "profile_stats": {
567
+ "missing_rate": 0.009622,
568
+ "unique_count": 20000,
569
+ "unique_ratio": 0.332143,
570
+ "example_values": [
571
+ "79230",
572
+ "5400370",
573
+ "22286",
574
+ "1841978",
575
+ "2056840"
576
+ ]
577
+ }
578
+ },
579
+ {
580
+ "name": "ap_000",
581
+ "role": "feature",
582
+ "semantic_type": "numeric",
583
+ "nullable": true,
584
+ "missing_tokens": [
585
+ "na"
586
+ ],
587
+ "parse_format": null,
588
+ "impute_strategy": "median",
589
+ "profile_stats": {
590
+ "missing_rate": 0.010526,
591
+ "unique_count": 20000,
592
+ "unique_ratio": 0.332447,
593
+ "example_values": [
594
+ "15174",
595
+ "401448",
596
+ "28834",
597
+ "827808",
598
+ "632288"
599
+ ]
600
+ }
601
+ },
602
+ {
603
+ "name": "aq_000",
604
+ "role": "feature",
605
+ "semantic_type": "numeric",
606
+ "nullable": true,
607
+ "missing_tokens": [
608
+ "na"
609
+ ],
610
+ "parse_format": null,
611
+ "impute_strategy": "median",
612
+ "profile_stats": {
613
+ "missing_rate": 0.009622,
614
+ "unique_count": 20000,
615
+ "unique_ratio": 0.332143,
616
+ "example_values": [
617
+ "7856",
618
+ "174492",
619
+ "4192",
620
+ "211098",
621
+ "281914"
622
+ ]
623
+ }
624
+ },
625
+ {
626
+ "name": "ar_000",
627
+ "role": "feature",
628
+ "semantic_type": "numeric",
629
+ "nullable": true,
630
+ "missing_tokens": [
631
+ "na"
632
+ ],
633
+ "parse_format": null,
634
+ "impute_strategy": "median",
635
+ "profile_stats": {
636
+ "missing_rate": 0.045691,
637
+ "unique_count": 66,
638
+ "unique_ratio": 0.001137,
639
+ "example_values": [
640
+ "0",
641
+ "6",
642
+ "4",
643
+ "2",
644
+ "8"
645
+ ]
646
+ }
647
+ },
648
+ {
649
+ "name": "as_000",
650
+ "role": "feature",
651
+ "semantic_type": "boolean",
652
+ "nullable": true,
653
+ "missing_tokens": [
654
+ "na"
655
+ ],
656
+ "parse_format": null,
657
+ "impute_strategy": "mode",
658
+ "profile_stats": {
659
+ "missing_rate": 0.01023,
660
+ "unique_count": 23,
661
+ "unique_ratio": 0.000382,
662
+ "example_values": [
663
+ "0",
664
+ "1150508",
665
+ "357260",
666
+ "1246190",
667
+ "13752"
668
+ ]
669
+ }
670
+ },
671
+ {
672
+ "name": "at_000",
673
+ "role": "feature",
674
+ "semantic_type": "numeric",
675
+ "nullable": true,
676
+ "missing_tokens": [
677
+ "na"
678
+ ],
679
+ "parse_format": null,
680
+ "impute_strategy": "median",
681
+ "profile_stats": {
682
+ "missing_rate": 0.01023,
683
+ "unique_count": 3514,
684
+ "unique_ratio": 0.058393,
685
+ "example_values": [
686
+ "0",
687
+ "2202",
688
+ "26602",
689
+ "2968",
690
+ "2656"
691
+ ]
692
+ }
693
+ },
694
+ {
695
+ "name": "au_000",
696
+ "role": "feature",
697
+ "semantic_type": "boolean",
698
+ "nullable": true,
699
+ "missing_tokens": [
700
+ "na"
701
+ ],
702
+ "parse_format": null,
703
+ "impute_strategy": "mode",
704
+ "profile_stats": {
705
+ "missing_rate": 0.01023,
706
+ "unique_count": 55,
707
+ "unique_ratio": 0.000914,
708
+ "example_values": [
709
+ "0",
710
+ "748658",
711
+ "729144",
712
+ "588396",
713
+ "1248"
714
+ ]
715
+ }
716
+ },
717
+ {
718
+ "name": "av_000",
719
+ "role": "feature",
720
+ "semantic_type": "numeric",
721
+ "nullable": true,
722
+ "missing_tokens": [
723
+ "na"
724
+ ],
725
+ "parse_format": null,
726
+ "impute_strategy": "median",
727
+ "profile_stats": {
728
+ "missing_rate": 0.041727,
729
+ "unique_count": 3875,
730
+ "unique_ratio": 0.066509,
731
+ "example_values": [
732
+ "234",
733
+ "0",
734
+ "130",
735
+ "456",
736
+ "5754"
737
+ ]
738
+ }
739
+ },
740
+ {
741
+ "name": "ax_000",
742
+ "role": "feature",
743
+ "semantic_type": "numeric",
744
+ "nullable": true,
745
+ "missing_tokens": [
746
+ "na"
747
+ ],
748
+ "parse_format": null,
749
+ "impute_strategy": "median",
750
+ "profile_stats": {
751
+ "missing_rate": 0.041743,
752
+ "unique_count": 2244,
753
+ "unique_ratio": 0.038516,
754
+ "example_values": [
755
+ "66",
756
+ "0",
757
+ "138",
758
+ "1918",
759
+ "896"
760
+ ]
761
+ }
762
+ },
763
+ {
764
+ "name": "ay_000",
765
+ "role": "feature",
766
+ "semantic_type": "boolean",
767
+ "nullable": true,
768
+ "missing_tokens": [
769
+ "na"
770
+ ],
771
+ "parse_format": null,
772
+ "impute_strategy": "mode",
773
+ "profile_stats": {
774
+ "missing_rate": 0.011431,
775
+ "unique_count": 475,
776
+ "unique_ratio": 0.007903,
777
+ "example_values": [
778
+ "0",
779
+ "40584",
780
+ "38258",
781
+ "24630",
782
+ "32330"
783
+ ]
784
+ }
785
+ },
786
+ {
787
+ "name": "ay_001",
788
+ "role": "feature",
789
+ "semantic_type": "boolean",
790
+ "nullable": true,
791
+ "missing_tokens": [
792
+ "na"
793
+ ],
794
+ "parse_format": null,
795
+ "impute_strategy": "mode",
796
+ "profile_stats": {
797
+ "missing_rate": 0.011431,
798
+ "unique_count": 925,
799
+ "unique_ratio": 0.01539,
800
+ "example_values": [
801
+ "0",
802
+ "958",
803
+ "4894",
804
+ "17568",
805
+ "18570"
806
+ ]
807
+ }
808
+ },
809
+ {
810
+ "name": "ay_002",
811
+ "role": "feature",
812
+ "semantic_type": "boolean",
813
+ "nullable": true,
814
+ "missing_tokens": [
815
+ "na"
816
+ ],
817
+ "parse_format": null,
818
+ "impute_strategy": "mode",
819
+ "profile_stats": {
820
+ "missing_rate": 0.011431,
821
+ "unique_count": 995,
822
+ "unique_ratio": 0.016554,
823
+ "example_values": [
824
+ "0",
825
+ "4798",
826
+ "8256",
827
+ "15402",
828
+ "11316"
829
+ ]
830
+ }
831
+ },
832
+ {
833
+ "name": "ay_003",
834
+ "role": "feature",
835
+ "semantic_type": "numeric",
836
+ "nullable": true,
837
+ "missing_tokens": [
838
+ "na"
839
+ ],
840
+ "parse_format": null,
841
+ "impute_strategy": "median",
842
+ "profile_stats": {
843
+ "missing_rate": 0.011431,
844
+ "unique_count": 1038,
845
+ "unique_ratio": 0.01727,
846
+ "example_values": [
847
+ "0",
848
+ "5084",
849
+ "5736",
850
+ "7764",
851
+ "22594"
852
+ ]
853
+ }
854
+ },
855
+ {
856
+ "name": "ay_004",
857
+ "role": "feature",
858
+ "semantic_type": "numeric",
859
+ "nullable": true,
860
+ "missing_tokens": [
861
+ "na"
862
+ ],
863
+ "parse_format": null,
864
+ "impute_strategy": "median",
865
+ "profile_stats": {
866
+ "missing_rate": 0.011431,
867
+ "unique_count": 1770,
868
+ "unique_ratio": 0.029448,
869
+ "example_values": [
870
+ "0",
871
+ "10492",
872
+ "13892",
873
+ "1230",
874
+ "8894"
875
+ ]
876
+ }
877
+ },
878
+ {
879
+ "name": "ay_005",
880
+ "role": "feature",
881
+ "semantic_type": "numeric",
882
+ "nullable": true,
883
+ "missing_tokens": [
884
+ "na"
885
+ ],
886
+ "parse_format": null,
887
+ "impute_strategy": "median",
888
+ "profile_stats": {
889
+ "missing_rate": 0.011431,
890
+ "unique_count": 19817,
891
+ "unique_ratio": 0.329706,
892
+ "example_values": [
893
+ "0",
894
+ "60878",
895
+ "51752",
896
+ "40934",
897
+ "32600"
898
+ ]
899
+ }
900
+ },
901
+ {
902
+ "name": "ay_006",
903
+ "role": "feature",
904
+ "semantic_type": "numeric",
905
+ "nullable": true,
906
+ "missing_tokens": [
907
+ "na"
908
+ ],
909
+ "parse_format": null,
910
+ "impute_strategy": "median",
911
+ "profile_stats": {
912
+ "missing_rate": 0.011431,
913
+ "unique_count": 20000,
914
+ "unique_ratio": 0.332751,
915
+ "example_values": [
916
+ "83150",
917
+ "2211302",
918
+ "0",
919
+ "936702",
920
+ "450836"
921
+ ]
922
+ }
923
+ },
924
+ {
925
+ "name": "ay_007",
926
+ "role": "feature",
927
+ "semantic_type": "numeric",
928
+ "nullable": true,
929
+ "missing_tokens": [
930
+ "na"
931
+ ],
932
+ "parse_format": null,
933
+ "impute_strategy": "median",
934
+ "profile_stats": {
935
+ "missing_rate": 0.011431,
936
+ "unique_count": 20000,
937
+ "unique_ratio": 0.332751,
938
+ "example_values": [
939
+ "15332",
940
+ "3607098",
941
+ "5444",
942
+ "614794",
943
+ "1811692"
944
+ ]
945
+ }
946
+ },
947
+ {
948
+ "name": "ay_008",
949
+ "role": "feature",
950
+ "semantic_type": "numeric",
951
+ "nullable": true,
952
+ "missing_tokens": [
953
+ "na"
954
+ ],
955
+ "parse_format": null,
956
+ "impute_strategy": "median",
957
+ "profile_stats": {
958
+ "missing_rate": 0.011431,
959
+ "unique_count": 20000,
960
+ "unique_ratio": 0.332751,
961
+ "example_values": [
962
+ "2",
963
+ "14054",
964
+ "29552",
965
+ "664808",
966
+ "315906"
967
+ ]
968
+ }
969
+ },
970
+ {
971
+ "name": "ay_009",
972
+ "role": "feature",
973
+ "semantic_type": "boolean",
974
+ "nullable": true,
975
+ "missing_tokens": [
976
+ "na"
977
+ ],
978
+ "parse_format": null,
979
+ "impute_strategy": "mode",
980
+ "profile_stats": {
981
+ "missing_rate": 0.011431,
982
+ "unique_count": 457,
983
+ "unique_ratio": 0.007603,
984
+ "example_values": [
985
+ "0",
986
+ "118",
987
+ "1272",
988
+ "36954",
989
+ "5292"
990
+ ]
991
+ }
992
+ },
993
+ {
994
+ "name": "az_000",
995
+ "role": "feature",
996
+ "semantic_type": "numeric",
997
+ "nullable": true,
998
+ "missing_tokens": [
999
+ "na"
1000
+ ],
1001
+ "parse_format": null,
1002
+ "impute_strategy": "median",
1003
+ "profile_stats": {
1004
+ "missing_rate": 0.011431,
1005
+ "unique_count": 9275,
1006
+ "unique_ratio": 0.154313,
1007
+ "example_values": [
1008
+ "110",
1009
+ "16710",
1010
+ "240",
1011
+ "1184",
1012
+ "2258"
1013
+ ]
1014
+ }
1015
+ },
1016
+ {
1017
+ "name": "az_001",
1018
+ "role": "feature",
1019
+ "semantic_type": "numeric",
1020
+ "nullable": true,
1021
+ "missing_tokens": [
1022
+ "na"
1023
+ ],
1024
+ "parse_format": null,
1025
+ "impute_strategy": "median",
1026
+ "profile_stats": {
1027
+ "missing_rate": 0.011431,
1028
+ "unique_count": 7402,
1029
+ "unique_ratio": 0.123151,
1030
+ "example_values": [
1031
+ "48",
1032
+ "890",
1033
+ "18",
1034
+ "450",
1035
+ "1596"
1036
+ ]
1037
+ }
1038
+ },
1039
+ {
1040
+ "name": "az_002",
1041
+ "role": "feature",
1042
+ "semantic_type": "numeric",
1043
+ "nullable": true,
1044
+ "missing_tokens": [
1045
+ "na"
1046
+ ],
1047
+ "parse_format": null,
1048
+ "impute_strategy": "median",
1049
+ "profile_stats": {
1050
+ "missing_rate": 0.011431,
1051
+ "unique_count": 9145,
1052
+ "unique_ratio": 0.15215,
1053
+ "example_values": [
1054
+ "46",
1055
+ "1344",
1056
+ "26",
1057
+ "1590",
1058
+ "1638"
1059
+ ]
1060
+ }
1061
+ },
1062
+ {
1063
+ "name": "az_003",
1064
+ "role": "feature",
1065
+ "semantic_type": "numeric",
1066
+ "nullable": true,
1067
+ "missing_tokens": [
1068
+ "na"
1069
+ ],
1070
+ "parse_format": null,
1071
+ "impute_strategy": "median",
1072
+ "profile_stats": {
1073
+ "missing_rate": 0.011431,
1074
+ "unique_count": 20000,
1075
+ "unique_ratio": 0.332751,
1076
+ "example_values": [
1077
+ "150",
1078
+ "3706",
1079
+ "1484",
1080
+ "143218",
1081
+ "2218"
1082
+ ]
1083
+ }
1084
+ },
1085
+ {
1086
+ "name": "az_004",
1087
+ "role": "feature",
1088
+ "semantic_type": "numeric",
1089
+ "nullable": true,
1090
+ "missing_tokens": [
1091
+ "na"
1092
+ ],
1093
+ "parse_format": null,
1094
+ "impute_strategy": "median",
1095
+ "profile_stats": {
1096
+ "missing_rate": 0.011431,
1097
+ "unique_count": 20000,
1098
+ "unique_ratio": 0.332751,
1099
+ "example_values": [
1100
+ "68536",
1101
+ "2497690",
1102
+ "576",
1103
+ "1839284",
1104
+ "109860"
1105
+ ]
1106
+ }
1107
+ },
1108
+ {
1109
+ "name": "az_005",
1110
+ "role": "feature",
1111
+ "semantic_type": "numeric",
1112
+ "nullable": true,
1113
+ "missing_tokens": [
1114
+ "na"
1115
+ ],
1116
+ "parse_format": null,
1117
+ "impute_strategy": "median",
1118
+ "profile_stats": {
1119
+ "missing_rate": 0.011431,
1120
+ "unique_count": 20000,
1121
+ "unique_ratio": 0.332751,
1122
+ "example_values": [
1123
+ "29594",
1124
+ "3371368",
1125
+ "4110",
1126
+ "282298",
1127
+ "2499914"
1128
+ ]
1129
+ }
1130
+ },
1131
+ {
1132
+ "name": "az_006",
1133
+ "role": "feature",
1134
+ "semantic_type": "numeric",
1135
+ "nullable": true,
1136
+ "missing_tokens": [
1137
+ "na"
1138
+ ],
1139
+ "parse_format": null,
1140
+ "impute_strategy": "median",
1141
+ "profile_stats": {
1142
+ "missing_rate": 0.011431,
1143
+ "unique_count": 12398,
1144
+ "unique_ratio": 0.206272,
1145
+ "example_values": [
1146
+ "0",
1147
+ "1624",
1148
+ "16918",
1149
+ "32",
1150
+ "1884"
1151
+ ]
1152
+ }
1153
+ },
1154
+ {
1155
+ "name": "az_007",
1156
+ "role": "feature",
1157
+ "semantic_type": "numeric",
1158
+ "nullable": true,
1159
+ "missing_tokens": [
1160
+ "na"
1161
+ ],
1162
+ "parse_format": null,
1163
+ "impute_strategy": "median",
1164
+ "profile_stats": {
1165
+ "missing_rate": 0.011431,
1166
+ "unique_count": 3863,
1167
+ "unique_ratio": 0.064271,
1168
+ "example_values": [
1169
+ "0",
1170
+ "11492",
1171
+ "4",
1172
+ "10",
1173
+ "1760"
1174
+ ]
1175
+ }
1176
+ },
1177
+ {
1178
+ "name": "az_008",
1179
+ "role": "feature",
1180
+ "semantic_type": "numeric",
1181
+ "nullable": true,
1182
+ "missing_tokens": [
1183
+ "na"
1184
+ ],
1185
+ "parse_format": null,
1186
+ "impute_strategy": "median",
1187
+ "profile_stats": {
1188
+ "missing_rate": 0.011431,
1189
+ "unique_count": 1257,
1190
+ "unique_ratio": 0.020913,
1191
+ "example_values": [
1192
+ "0",
1193
+ "132",
1194
+ "5064",
1195
+ "2998",
1196
+ "2"
1197
+ ]
1198
+ }
1199
+ },
1200
+ {
1201
+ "name": "az_009",
1202
+ "role": "feature",
1203
+ "semantic_type": "numeric",
1204
+ "nullable": true,
1205
+ "missing_tokens": [
1206
+ "na"
1207
+ ],
1208
+ "parse_format": null,
1209
+ "impute_strategy": "median",
1210
+ "profile_stats": {
1211
+ "missing_rate": 0.011431,
1212
+ "unique_count": 342,
1213
+ "unique_ratio": 0.00569,
1214
+ "example_values": [
1215
+ "0",
1216
+ "2",
1217
+ "12",
1218
+ "5240",
1219
+ "1208"
1220
+ ]
1221
+ }
1222
+ },
1223
+ {
1224
+ "name": "ba_000",
1225
+ "role": "feature",
1226
+ "semantic_type": "numeric",
1227
+ "nullable": true,
1228
+ "missing_tokens": [
1229
+ "na"
1230
+ ],
1231
+ "parse_format": null,
1232
+ "impute_strategy": "median",
1233
+ "profile_stats": {
1234
+ "missing_rate": 0.011694,
1235
+ "unique_count": 20000,
1236
+ "unique_ratio": 0.33284,
1237
+ "example_values": [
1238
+ "43510",
1239
+ "1449660",
1240
+ "27420",
1241
+ "668112",
1242
+ "1052220"
1243
+ ]
1244
+ }
1245
+ },
1246
+ {
1247
+ "name": "ba_001",
1248
+ "role": "feature",
1249
+ "semantic_type": "numeric",
1250
+ "nullable": true,
1251
+ "missing_tokens": [
1252
+ "na"
1253
+ ],
1254
+ "parse_format": null,
1255
+ "impute_strategy": "median",
1256
+ "profile_stats": {
1257
+ "missing_rate": 0.011694,
1258
+ "unique_count": 20000,
1259
+ "unique_ratio": 0.33284,
1260
+ "example_values": [
1261
+ "35882",
1262
+ "1098754",
1263
+ "3950",
1264
+ "612642",
1265
+ "641214"
1266
+ ]
1267
+ }
1268
+ },
1269
+ {
1270
+ "name": "ba_002",
1271
+ "role": "feature",
1272
+ "semantic_type": "numeric",
1273
+ "nullable": true,
1274
+ "missing_tokens": [
1275
+ "na"
1276
+ ],
1277
+ "parse_format": null,
1278
+ "impute_strategy": "median",
1279
+ "profile_stats": {
1280
+ "missing_rate": 0.011694,
1281
+ "unique_count": 20000,
1282
+ "unique_ratio": 0.33284,
1283
+ "example_values": [
1284
+ "11484",
1285
+ "583624",
1286
+ "902",
1287
+ "323232",
1288
+ "234314"
1289
+ ]
1290
+ }
1291
+ },
1292
+ {
1293
+ "name": "ba_003",
1294
+ "role": "feature",
1295
+ "semantic_type": "numeric",
1296
+ "nullable": true,
1297
+ "missing_tokens": [
1298
+ "na"
1299
+ ],
1300
+ "parse_format": null,
1301
+ "impute_strategy": "median",
1302
+ "profile_stats": {
1303
+ "missing_rate": 0.011694,
1304
+ "unique_count": 20000,
1305
+ "unique_ratio": 0.33284,
1306
+ "example_values": [
1307
+ "4784",
1308
+ "500568",
1309
+ "594",
1310
+ "220220",
1311
+ "156236"
1312
+ ]
1313
+ }
1314
+ },
1315
+ {
1316
+ "name": "ba_004",
1317
+ "role": "feature",
1318
+ "semantic_type": "numeric",
1319
+ "nullable": true,
1320
+ "missing_tokens": [
1321
+ "na"
1322
+ ],
1323
+ "parse_format": null,
1324
+ "impute_strategy": "median",
1325
+ "profile_stats": {
1326
+ "missing_rate": 0.011694,
1327
+ "unique_count": 20000,
1328
+ "unique_ratio": 0.33284,
1329
+ "example_values": [
1330
+ "1550",
1331
+ "445980",
1332
+ "524",
1333
+ "166770",
1334
+ "107440"
1335
+ ]
1336
+ }
1337
+ },
1338
+ {
1339
+ "name": "ba_005",
1340
+ "role": "feature",
1341
+ "semantic_type": "numeric",
1342
+ "nullable": true,
1343
+ "missing_tokens": [
1344
+ "na"
1345
+ ],
1346
+ "parse_format": null,
1347
+ "impute_strategy": "median",
1348
+ "profile_stats": {
1349
+ "missing_rate": 0.011694,
1350
+ "unique_count": 20000,
1351
+ "unique_ratio": 0.33284,
1352
+ "example_values": [
1353
+ "678",
1354
+ "394140",
1355
+ "308",
1356
+ "159564",
1357
+ "80012"
1358
+ ]
1359
+ }
1360
+ },
1361
+ {
1362
+ "name": "ba_006",
1363
+ "role": "feature",
1364
+ "semantic_type": "numeric",
1365
+ "nullable": true,
1366
+ "missing_tokens": [
1367
+ "na"
1368
+ ],
1369
+ "parse_format": null,
1370
+ "impute_strategy": "median",
1371
+ "profile_stats": {
1372
+ "missing_rate": 0.011694,
1373
+ "unique_count": 20000,
1374
+ "unique_ratio": 0.33284,
1375
+ "example_values": [
1376
+ "372",
1377
+ "424290",
1378
+ "1100",
1379
+ "117506",
1380
+ "90270"
1381
+ ]
1382
+ }
1383
+ },
1384
+ {
1385
+ "name": "ba_007",
1386
+ "role": "feature",
1387
+ "semantic_type": "numeric",
1388
+ "nullable": true,
1389
+ "missing_tokens": [
1390
+ "na"
1391
+ ],
1392
+ "parse_format": null,
1393
+ "impute_strategy": "median",
1394
+ "profile_stats": {
1395
+ "missing_rate": 0.011694,
1396
+ "unique_count": 20000,
1397
+ "unique_ratio": 0.33284,
1398
+ "example_values": [
1399
+ "224",
1400
+ "801640",
1401
+ "166",
1402
+ "10",
1403
+ "257660"
1404
+ ]
1405
+ }
1406
+ },
1407
+ {
1408
+ "name": "ba_008",
1409
+ "role": "feature",
1410
+ "semantic_type": "numeric",
1411
+ "nullable": true,
1412
+ "missing_tokens": [
1413
+ "na"
1414
+ ],
1415
+ "parse_format": null,
1416
+ "impute_strategy": "median",
1417
+ "profile_stats": {
1418
+ "missing_rate": 0.011694,
1419
+ "unique_count": 11894,
1420
+ "unique_ratio": 0.19794,
1421
+ "example_values": [
1422
+ "0",
1423
+ "194672",
1424
+ "26",
1425
+ "2",
1426
+ "38636"
1427
+ ]
1428
+ }
1429
+ },
1430
+ {
1431
+ "name": "ba_009",
1432
+ "role": "feature",
1433
+ "semantic_type": "numeric",
1434
+ "nullable": true,
1435
+ "missing_tokens": [
1436
+ "na"
1437
+ ],
1438
+ "parse_format": null,
1439
+ "impute_strategy": "median",
1440
+ "profile_stats": {
1441
+ "missing_rate": 0.011694,
1442
+ "unique_count": 6840,
1443
+ "unique_ratio": 0.113831,
1444
+ "example_values": [
1445
+ "0",
1446
+ "4",
1447
+ "6",
1448
+ "3288",
1449
+ "830"
1450
+ ]
1451
+ }
1452
+ },
1453
+ {
1454
+ "name": "bb_000",
1455
+ "role": "feature",
1456
+ "semantic_type": "numeric",
1457
+ "nullable": true,
1458
+ "missing_tokens": [
1459
+ "na"
1460
+ ],
1461
+ "parse_format": null,
1462
+ "impute_strategy": "median",
1463
+ "profile_stats": {
1464
+ "missing_rate": 0.010559,
1465
+ "unique_count": 20000,
1466
+ "unique_ratio": 0.332458,
1467
+ "example_values": [
1468
+ "104890",
1469
+ "6053972",
1470
+ "62144",
1471
+ "2922442",
1472
+ "3031738"
1473
+ ]
1474
+ }
1475
+ },
1476
+ {
1477
+ "name": "bc_000",
1478
+ "role": "feature",
1479
+ "semantic_type": "numeric",
1480
+ "nullable": true,
1481
+ "missing_tokens": [
1482
+ "na"
1483
+ ],
1484
+ "parse_format": null,
1485
+ "impute_strategy": "median",
1486
+ "profile_stats": {
1487
+ "missing_rate": 0.045691,
1488
+ "unique_count": 2853,
1489
+ "unique_ratio": 0.049171,
1490
+ "example_values": [
1491
+ "4",
1492
+ "0",
1493
+ "296",
1494
+ "96",
1495
+ "22"
1496
+ ]
1497
+ }
1498
+ },
1499
+ {
1500
+ "name": "bd_000",
1501
+ "role": "feature",
1502
+ "semantic_type": "numeric",
1503
+ "nullable": true,
1504
+ "missing_tokens": [
1505
+ "na"
1506
+ ],
1507
+ "parse_format": null,
1508
+ "impute_strategy": "median",
1509
+ "profile_stats": {
1510
+ "missing_rate": 0.045724,
1511
+ "unique_count": 3604,
1512
+ "unique_ratio": 0.062117,
1513
+ "example_values": [
1514
+ "6",
1515
+ "16",
1516
+ "8",
1517
+ "876",
1518
+ "1052"
1519
+ ]
1520
+ }
1521
+ },
1522
+ {
1523
+ "name": "be_000",
1524
+ "role": "feature",
1525
+ "semantic_type": "numeric",
1526
+ "nullable": true,
1527
+ "missing_tokens": [
1528
+ "na"
1529
+ ],
1530
+ "parse_format": null,
1531
+ "impute_strategy": "median",
1532
+ "profile_stats": {
1533
+ "missing_rate": 0.04176,
1534
+ "unique_count": 4000,
1535
+ "unique_ratio": 0.068657,
1536
+ "example_values": [
1537
+ "106",
1538
+ "260",
1539
+ "8",
1540
+ "266",
1541
+ "150"
1542
+ ]
1543
+ }
1544
+ },
1545
+ {
1546
+ "name": "bf_000",
1547
+ "role": "feature",
1548
+ "semantic_type": "numeric",
1549
+ "nullable": true,
1550
+ "missing_tokens": [
1551
+ "na"
1552
+ ],
1553
+ "parse_format": null,
1554
+ "impute_strategy": "median",
1555
+ "profile_stats": {
1556
+ "missing_rate": 0.041727,
1557
+ "unique_count": 1122,
1558
+ "unique_ratio": 0.019258,
1559
+ "example_values": [
1560
+ "0",
1561
+ "190",
1562
+ "42",
1563
+ "58",
1564
+ "36"
1565
+ ]
1566
+ }
1567
+ },
1568
+ {
1569
+ "name": "bg_000",
1570
+ "role": "feature",
1571
+ "semantic_type": "numeric",
1572
+ "nullable": true,
1573
+ "missing_tokens": [
1574
+ "na"
1575
+ ],
1576
+ "parse_format": null,
1577
+ "impute_strategy": "median",
1578
+ "profile_stats": {
1579
+ "missing_rate": 0.010526,
1580
+ "unique_count": 20000,
1581
+ "unique_ratio": 0.332447,
1582
+ "example_values": [
1583
+ "36080",
1584
+ "3165022",
1585
+ "10518",
1586
+ "1060220",
1587
+ "1167164"
1588
+ ]
1589
+ }
1590
+ },
1591
+ {
1592
+ "name": "bh_000",
1593
+ "role": "feature",
1594
+ "semantic_type": "numeric",
1595
+ "nullable": true,
1596
+ "missing_tokens": [
1597
+ "na"
1598
+ ],
1599
+ "parse_format": null,
1600
+ "impute_strategy": "median",
1601
+ "profile_stats": {
1602
+ "missing_rate": 0.010526,
1603
+ "unique_count": 20000,
1604
+ "unique_ratio": 0.332447,
1605
+ "example_values": [
1606
+ "1188",
1607
+ "37482",
1608
+ "466",
1609
+ "29150",
1610
+ "40680"
1611
+ ]
1612
+ }
1613
+ },
1614
+ {
1615
+ "name": "bi_000",
1616
+ "role": "feature",
1617
+ "semantic_type": "numeric",
1618
+ "nullable": true,
1619
+ "missing_tokens": [
1620
+ "na"
1621
+ ],
1622
+ "parse_format": null,
1623
+ "impute_strategy": "median",
1624
+ "profile_stats": {
1625
+ "missing_rate": 0.009622,
1626
+ "unique_count": 20000,
1627
+ "unique_ratio": 0.332143,
1628
+ "example_values": [
1629
+ "5890",
1630
+ "168126",
1631
+ "16940",
1632
+ "693886",
1633
+ "362196"
1634
+ ]
1635
+ }
1636
+ },
1637
+ {
1638
+ "name": "bj_000",
1639
+ "role": "feature",
1640
+ "semantic_type": "numeric",
1641
+ "nullable": true,
1642
+ "missing_tokens": [
1643
+ "na"
1644
+ ],
1645
+ "parse_format": null,
1646
+ "impute_strategy": "median",
1647
+ "profile_stats": {
1648
+ "missing_rate": 0.009622,
1649
+ "unique_count": 20000,
1650
+ "unique_ratio": 0.332143,
1651
+ "example_values": [
1652
+ "9244",
1653
+ "232192",
1654
+ "11536",
1655
+ "132634",
1656
+ "268290"
1657
+ ]
1658
+ }
1659
+ },
1660
+ {
1661
+ "name": "bk_000",
1662
+ "role": "feature",
1663
+ "semantic_type": "numeric",
1664
+ "nullable": true,
1665
+ "missing_tokens": [
1666
+ "na"
1667
+ ],
1668
+ "parse_format": null,
1669
+ "impute_strategy": "median",
1670
+ "profile_stats": {
1671
+ "missing_rate": 0.384737,
1672
+ "unique_count": 13038,
1673
+ "unique_ratio": 0.348535,
1674
+ "example_values": [
1675
+ "76900",
1676
+ "285120",
1677
+ "224680",
1678
+ "132180",
1679
+ "238240"
1680
+ ]
1681
+ }
1682
+ },
1683
+ {
1684
+ "name": "bl_000",
1685
+ "role": "feature",
1686
+ "semantic_type": "numeric",
1687
+ "nullable": true,
1688
+ "missing_tokens": [
1689
+ "na"
1690
+ ],
1691
+ "parse_format": null,
1692
+ "impute_strategy": "median",
1693
+ "profile_stats": {
1694
+ "missing_rate": 0.455609,
1695
+ "unique_count": 12055,
1696
+ "unique_ratio": 0.36421,
1697
+ "example_values": [
1698
+ "59240",
1699
+ "343500",
1700
+ "255560",
1701
+ "1310700",
1702
+ "188560"
1703
+ ]
1704
+ }
1705
+ },
1706
+ {
1707
+ "name": "bm_000",
1708
+ "role": "feature",
1709
+ "semantic_type": "numeric",
1710
+ "nullable": true,
1711
+ "missing_tokens": [
1712
+ "na"
1713
+ ],
1714
+ "parse_format": null,
1715
+ "impute_strategy": "median",
1716
+ "profile_stats": {
1717
+ "missing_rate": 0.661135,
1718
+ "unique_count": 9160,
1719
+ "unique_ratio": 0.444595,
1720
+ "example_values": [
1721
+ "71160",
1722
+ "1310700",
1723
+ "237300",
1724
+ "298620",
1725
+ "200400"
1726
+ ]
1727
+ }
1728
+ },
1729
+ {
1730
+ "name": "bn_000",
1731
+ "role": "feature",
1732
+ "semantic_type": "numeric",
1733
+ "nullable": true,
1734
+ "missing_tokens": [
1735
+ "na"
1736
+ ],
1737
+ "parse_format": null,
1738
+ "impute_strategy": "median",
1739
+ "profile_stats": {
1740
+ "missing_rate": 0.734095,
1741
+ "unique_count": 7196,
1742
+ "unique_ratio": 0.445104,
1743
+ "example_values": [
1744
+ "115600",
1745
+ "1310700",
1746
+ "221260",
1747
+ "0",
1748
+ "254060"
1749
+ ]
1750
+ }
1751
+ },
1752
+ {
1753
+ "name": "bo_000",
1754
+ "role": "feature",
1755
+ "semantic_type": "numeric",
1756
+ "nullable": true,
1757
+ "missing_tokens": [
1758
+ "na"
1759
+ ],
1760
+ "parse_format": null,
1761
+ "impute_strategy": "median",
1762
+ "profile_stats": {
1763
+ "missing_rate": 0.773405,
1764
+ "unique_count": 5932,
1765
+ "unique_ratio": 0.430573,
1766
+ "example_values": [
1767
+ "1310700",
1768
+ "248360",
1769
+ "0",
1770
+ "226380",
1771
+ "166140"
1772
+ ]
1773
+ }
1774
+ },
1775
+ {
1776
+ "name": "bp_000",
1777
+ "role": "feature",
1778
+ "semantic_type": "numeric",
1779
+ "nullable": true,
1780
+ "missing_tokens": [
1781
+ "na"
1782
+ ],
1783
+ "parse_format": null,
1784
+ "impute_strategy": "median",
1785
+ "profile_stats": {
1786
+ "missing_rate": 0.796118,
1787
+ "unique_count": 5059,
1788
+ "unique_ratio": 0.408116,
1789
+ "example_values": [
1790
+ "1310700",
1791
+ "0",
1792
+ "174400",
1793
+ "389060",
1794
+ "227500"
1795
+ ]
1796
+ }
1797
+ },
1798
+ {
1799
+ "name": "bq_000",
1800
+ "role": "feature",
1801
+ "semantic_type": "numeric",
1802
+ "nullable": true,
1803
+ "missing_tokens": [
1804
+ "na"
1805
+ ],
1806
+ "parse_format": null,
1807
+ "impute_strategy": "median",
1808
+ "profile_stats": {
1809
+ "missing_rate": 0.812632,
1810
+ "unique_count": 4349,
1811
+ "unique_ratio": 0.381759,
1812
+ "example_values": [
1813
+ "1310700",
1814
+ "0",
1815
+ "177920",
1816
+ "433740",
1817
+ "279280"
1818
+ ]
1819
+ }
1820
+ },
1821
+ {
1822
+ "name": "br_000",
1823
+ "role": "feature",
1824
+ "semantic_type": "numeric",
1825
+ "nullable": true,
1826
+ "missing_tokens": [
1827
+ "na"
1828
+ ],
1829
+ "parse_format": null,
1830
+ "impute_strategy": "median",
1831
+ "profile_stats": {
1832
+ "missing_rate": 0.821743,
1833
+ "unique_count": 3929,
1834
+ "unique_ratio": 0.362521,
1835
+ "example_values": [
1836
+ "1310700",
1837
+ "0",
1838
+ "158980",
1839
+ "404300",
1840
+ "232280"
1841
+ ]
1842
+ }
1843
+ },
1844
+ {
1845
+ "name": "bs_000",
1846
+ "role": "feature",
1847
+ "semantic_type": "numeric",
1848
+ "nullable": true,
1849
+ "missing_tokens": [
1850
+ "na"
1851
+ ],
1852
+ "parse_format": null,
1853
+ "impute_strategy": "median",
1854
+ "profile_stats": {
1855
+ "missing_rate": 0.011974,
1856
+ "unique_count": 12890,
1857
+ "unique_ratio": 0.214576,
1858
+ "example_values": [
1859
+ "14900",
1860
+ "69400",
1861
+ "28200",
1862
+ "195000",
1863
+ "146640"
1864
+ ]
1865
+ }
1866
+ },
1867
+ {
1868
+ "name": "bt_000",
1869
+ "role": "feature",
1870
+ "semantic_type": "numeric",
1871
+ "nullable": true,
1872
+ "missing_tokens": [
1873
+ "na"
1874
+ ],
1875
+ "parse_format": null,
1876
+ "impute_strategy": "median",
1877
+ "profile_stats": {
1878
+ "missing_rate": 0.002549,
1879
+ "unique_count": 20000,
1880
+ "unique_ratio": 0.329788,
1881
+ "example_values": [
1882
+ "1655.66",
1883
+ "118600.27",
1884
+ "129.51",
1885
+ "37015.76",
1886
+ "32929.03"
1887
+ ]
1888
+ }
1889
+ },
1890
+ {
1891
+ "name": "bu_000",
1892
+ "role": "feature",
1893
+ "semantic_type": "numeric",
1894
+ "nullable": true,
1895
+ "missing_tokens": [
1896
+ "na"
1897
+ ],
1898
+ "parse_format": null,
1899
+ "impute_strategy": "median",
1900
+ "profile_stats": {
1901
+ "missing_rate": 0.011365,
1902
+ "unique_count": 20000,
1903
+ "unique_ratio": 0.332729,
1904
+ "example_values": [
1905
+ "104890",
1906
+ "6053972",
1907
+ "62144",
1908
+ "2922442",
1909
+ "3031738"
1910
+ ]
1911
+ }
1912
+ },
1913
+ {
1914
+ "name": "bv_000",
1915
+ "role": "feature",
1916
+ "semantic_type": "numeric",
1917
+ "nullable": true,
1918
+ "missing_tokens": [
1919
+ "na"
1920
+ ],
1921
+ "parse_format": null,
1922
+ "impute_strategy": "median",
1923
+ "profile_stats": {
1924
+ "missing_rate": 0.011365,
1925
+ "unique_count": 20000,
1926
+ "unique_ratio": 0.332729,
1927
+ "example_values": [
1928
+ "104890",
1929
+ "6053972",
1930
+ "62144",
1931
+ "2922442",
1932
+ "3031738"
1933
+ ]
1934
+ }
1935
+ },
1936
+ {
1937
+ "name": "bx_000",
1938
+ "role": "feature",
1939
+ "semantic_type": "numeric",
1940
+ "nullable": true,
1941
+ "missing_tokens": [
1942
+ "na"
1943
+ ],
1944
+ "parse_format": null,
1945
+ "impute_strategy": "median",
1946
+ "profile_stats": {
1947
+ "missing_rate": 0.052845,
1948
+ "unique_count": 20000,
1949
+ "unique_ratio": 0.347301,
1950
+ "example_values": [
1951
+ "106798",
1952
+ "6017402",
1953
+ "63248",
1954
+ "2922030",
1955
+ "3026214"
1956
+ ]
1957
+ }
1958
+ },
1959
+ {
1960
+ "name": "by_000",
1961
+ "role": "feature",
1962
+ "semantic_type": "numeric",
1963
+ "nullable": true,
1964
+ "missing_tokens": [
1965
+ "na"
1966
+ ],
1967
+ "parse_format": null,
1968
+ "impute_strategy": "median",
1969
+ "profile_stats": {
1970
+ "missing_rate": 0.00778,
1971
+ "unique_count": 20000,
1972
+ "unique_ratio": 0.331527,
1973
+ "example_values": [
1974
+ "392",
1975
+ "35561.0",
1976
+ "120",
1977
+ "13359.0",
1978
+ "15622"
1979
+ ]
1980
+ }
1981
+ },
1982
+ {
1983
+ "name": "bz_000",
1984
+ "role": "feature",
1985
+ "semantic_type": "numeric",
1986
+ "nullable": true,
1987
+ "missing_tokens": [
1988
+ "na"
1989
+ ],
1990
+ "parse_format": null,
1991
+ "impute_strategy": "median",
1992
+ "profile_stats": {
1993
+ "missing_rate": 0.045674,
1994
+ "unique_count": 16718,
1995
+ "unique_ratio": 0.288127,
1996
+ "example_values": [
1997
+ "0",
1998
+ "1820080",
1999
+ "2350",
2000
+ "119886",
2001
+ "138476"
2002
+ ]
2003
+ }
2004
+ },
2005
+ {
2006
+ "name": "ca_000",
2007
+ "role": "feature",
2008
+ "semantic_type": "numeric",
2009
+ "nullable": true,
2010
+ "missing_tokens": [
2011
+ "na"
2012
+ ],
2013
+ "parse_format": null,
2014
+ "impute_strategy": "median",
2015
+ "profile_stats": {
2016
+ "missing_rate": 0.072105,
2017
+ "unique_count": 20000,
2018
+ "unique_ratio": 0.354509,
2019
+ "example_values": [
2020
+ "10292",
2021
+ "115788",
2022
+ "5744",
2023
+ "47768",
2024
+ "57472"
2025
+ ]
2026
+ }
2027
+ },
2028
+ {
2029
+ "name": "cb_000",
2030
+ "role": "feature",
2031
+ "semantic_type": "numeric",
2032
+ "nullable": true,
2033
+ "missing_tokens": [
2034
+ "na"
2035
+ ],
2036
+ "parse_format": null,
2037
+ "impute_strategy": "median",
2038
+ "profile_stats": {
2039
+ "missing_rate": 0.011974,
2040
+ "unique_count": 20000,
2041
+ "unique_ratio": 0.332934,
2042
+ "example_values": [
2043
+ "104580",
2044
+ "1205680",
2045
+ "61420",
2046
+ "498440",
2047
+ "606660"
2048
+ ]
2049
+ }
2050
+ },
2051
+ {
2052
+ "name": "cc_000",
2053
+ "role": "feature",
2054
+ "semantic_type": "numeric",
2055
+ "nullable": true,
2056
+ "missing_tokens": [
2057
+ "na"
2058
+ ],
2059
+ "parse_format": null,
2060
+ "impute_strategy": "median",
2061
+ "profile_stats": {
2062
+ "missing_rate": 0.052796,
2063
+ "unique_count": 20000,
2064
+ "unique_ratio": 0.347283,
2065
+ "example_values": [
2066
+ "98484",
2067
+ "5893332",
2068
+ "35116",
2069
+ "2268056",
2070
+ "2619368"
2071
+ ]
2072
+ }
2073
+ },
2074
+ {
2075
+ "name": "cd_000",
2076
+ "role": "feature",
2077
+ "semantic_type": "numeric",
2078
+ "nullable": true,
2079
+ "missing_tokens": [
2080
+ "na"
2081
+ ],
2082
+ "parse_format": null,
2083
+ "impute_strategy": "median",
2084
+ "profile_stats": {
2085
+ "missing_rate": 0.011217,
2086
+ "unique_count": 1,
2087
+ "unique_ratio": 1.7e-05,
2088
+ "example_values": [
2089
+ "1209600"
2090
+ ]
2091
+ }
2092
+ },
2093
+ {
2094
+ "name": "ce_000",
2095
+ "role": "feature",
2096
+ "semantic_type": "numeric",
2097
+ "nullable": true,
2098
+ "missing_tokens": [
2099
+ "na"
2100
+ ],
2101
+ "parse_format": null,
2102
+ "impute_strategy": "median",
2103
+ "profile_stats": {
2104
+ "missing_rate": 0.04176,
2105
+ "unique_count": 20000,
2106
+ "unique_ratio": 0.343283,
2107
+ "example_values": [
2108
+ "2436",
2109
+ "0",
2110
+ "1348",
2111
+ "64960",
2112
+ "99092"
2113
+ ]
2114
+ }
2115
+ },
2116
+ {
2117
+ "name": "cf_000",
2118
+ "role": "feature",
2119
+ "semantic_type": "numeric",
2120
+ "nullable": true,
2121
+ "missing_tokens": [
2122
+ "na"
2123
+ ],
2124
+ "parse_format": null,
2125
+ "impute_strategy": "median",
2126
+ "profile_stats": {
2127
+ "missing_rate": 0.246727,
2128
+ "unique_count": 528,
2129
+ "unique_ratio": 0.011529,
2130
+ "example_values": [
2131
+ "2",
2132
+ "8",
2133
+ "0",
2134
+ "4",
2135
+ "190"
2136
+ ]
2137
+ }
2138
+ },
2139
+ {
2140
+ "name": "cg_000",
2141
+ "role": "feature",
2142
+ "semantic_type": "numeric",
2143
+ "nullable": true,
2144
+ "missing_tokens": [
2145
+ "na"
2146
+ ],
2147
+ "parse_format": null,
2148
+ "impute_strategy": "median",
2149
+ "profile_stats": {
2150
+ "missing_rate": 0.246727,
2151
+ "unique_count": 666,
2152
+ "unique_ratio": 0.014542,
2153
+ "example_values": [
2154
+ "10",
2155
+ "8",
2156
+ "46",
2157
+ "70",
2158
+ "6"
2159
+ ]
2160
+ }
2161
+ },
2162
+ {
2163
+ "name": "ch_000",
2164
+ "role": "feature",
2165
+ "semantic_type": "boolean",
2166
+ "nullable": true,
2167
+ "missing_tokens": [
2168
+ "na"
2169
+ ],
2170
+ "parse_format": null,
2171
+ "impute_strategy": "mode",
2172
+ "profile_stats": {
2173
+ "missing_rate": 0.246727,
2174
+ "unique_count": 2,
2175
+ "unique_ratio": 4.4e-05,
2176
+ "example_values": [
2177
+ "0",
2178
+ "2"
2179
+ ]
2180
+ }
2181
+ },
2182
+ {
2183
+ "name": "ci_000",
2184
+ "role": "feature",
2185
+ "semantic_type": "numeric",
2186
+ "nullable": true,
2187
+ "missing_tokens": [
2188
+ "na"
2189
+ ],
2190
+ "parse_format": null,
2191
+ "impute_strategy": "median",
2192
+ "profile_stats": {
2193
+ "missing_rate": 0.005559,
2194
+ "unique_count": 20000,
2195
+ "unique_ratio": 0.330786,
2196
+ "example_values": [
2197
+ "86199.36",
2198
+ "5383493.76",
2199
+ "12072",
2200
+ "2022616.32",
2201
+ "2018493.12"
2202
+ ]
2203
+ }
2204
+ },
2205
+ {
2206
+ "name": "cj_000",
2207
+ "role": "feature",
2208
+ "semantic_type": "numeric",
2209
+ "nullable": true,
2210
+ "missing_tokens": [
2211
+ "na"
2212
+ ],
2213
+ "parse_format": null,
2214
+ "impute_strategy": "median",
2215
+ "profile_stats": {
2216
+ "missing_rate": 0.005559,
2217
+ "unique_count": 7685,
2218
+ "unique_ratio": 0.127105,
2219
+ "example_values": [
2220
+ "0",
2221
+ "2187817.92",
2222
+ "287.04",
2223
+ "36538.56",
2224
+ "7788.48"
2225
+ ]
2226
+ }
2227
+ },
2228
+ {
2229
+ "name": "ck_000",
2230
+ "role": "feature",
2231
+ "semantic_type": "numeric",
2232
+ "nullable": true,
2233
+ "missing_tokens": [
2234
+ "na"
2235
+ ],
2236
+ "parse_format": null,
2237
+ "impute_strategy": "median",
2238
+ "profile_stats": {
2239
+ "missing_rate": 0.005559,
2240
+ "unique_count": 20000,
2241
+ "unique_ratio": 0.330786,
2242
+ "example_values": [
2243
+ "12177.6",
2244
+ "489533.76",
2245
+ "20935.68",
2246
+ "244064.64",
2247
+ "598942.08"
2248
+ ]
2249
+ }
2250
+ },
2251
+ {
2252
+ "name": "cl_000",
2253
+ "role": "feature",
2254
+ "semantic_type": "numeric",
2255
+ "nullable": true,
2256
+ "missing_tokens": [
2257
+ "na"
2258
+ ],
2259
+ "parse_format": null,
2260
+ "impute_strategy": "median",
2261
+ "profile_stats": {
2262
+ "missing_rate": 0.156793,
2263
+ "unique_count": 989,
2264
+ "unique_ratio": 0.019291,
2265
+ "example_values": [
2266
+ "0",
2267
+ "2",
2268
+ "1800",
2269
+ "6",
2270
+ "10"
2271
+ ]
2272
+ }
2273
+ },
2274
+ {
2275
+ "name": "cm_000",
2276
+ "role": "feature",
2277
+ "semantic_type": "numeric",
2278
+ "nullable": true,
2279
+ "missing_tokens": [
2280
+ "na"
2281
+ ],
2282
+ "parse_format": null,
2283
+ "impute_strategy": "median",
2284
+ "profile_stats": {
2285
+ "missing_rate": 0.162845,
2286
+ "unique_count": 2141,
2287
+ "unique_ratio": 0.042064,
2288
+ "example_values": [
2289
+ "0",
2290
+ "32",
2291
+ "1006",
2292
+ "6",
2293
+ "652"
2294
+ ]
2295
+ }
2296
+ },
2297
+ {
2298
+ "name": "cn_000",
2299
+ "role": "feature",
2300
+ "semantic_type": "numeric",
2301
+ "nullable": true,
2302
+ "missing_tokens": [
2303
+ "na"
2304
+ ],
2305
+ "parse_format": null,
2306
+ "impute_strategy": "median",
2307
+ "profile_stats": {
2308
+ "missing_rate": 0.011694,
2309
+ "unique_count": 1570,
2310
+ "unique_ratio": 0.026128,
2311
+ "example_values": [
2312
+ "0",
2313
+ "3646",
2314
+ "364",
2315
+ "38904",
2316
+ "36044"
2317
+ ]
2318
+ }
2319
+ },
2320
+ {
2321
+ "name": "cn_001",
2322
+ "role": "feature",
2323
+ "semantic_type": "numeric",
2324
+ "nullable": true,
2325
+ "missing_tokens": [
2326
+ "na"
2327
+ ],
2328
+ "parse_format": null,
2329
+ "impute_strategy": "median",
2330
+ "profile_stats": {
2331
+ "missing_rate": 0.011694,
2332
+ "unique_count": 5489,
2333
+ "unique_ratio": 0.091348,
2334
+ "example_values": [
2335
+ "0",
2336
+ "6696",
2337
+ "538",
2338
+ "578",
2339
+ "3568"
2340
+ ]
2341
+ }
2342
+ },
2343
+ {
2344
+ "name": "cn_002",
2345
+ "role": "feature",
2346
+ "semantic_type": "numeric",
2347
+ "nullable": true,
2348
+ "missing_tokens": [
2349
+ "na"
2350
+ ],
2351
+ "parse_format": null,
2352
+ "impute_strategy": "median",
2353
+ "profile_stats": {
2354
+ "missing_rate": 0.011694,
2355
+ "unique_count": 14897,
2356
+ "unique_ratio": 0.247916,
2357
+ "example_values": [
2358
+ "0",
2359
+ "15704",
2360
+ "6506",
2361
+ "390",
2362
+ "63466"
2363
+ ]
2364
+ }
2365
+ },
2366
+ {
2367
+ "name": "cn_003",
2368
+ "role": "feature",
2369
+ "semantic_type": "numeric",
2370
+ "nullable": true,
2371
+ "missing_tokens": [
2372
+ "na"
2373
+ ],
2374
+ "parse_format": null,
2375
+ "impute_strategy": "median",
2376
+ "profile_stats": {
2377
+ "missing_rate": 0.011694,
2378
+ "unique_count": 20000,
2379
+ "unique_ratio": 0.33284,
2380
+ "example_values": [
2381
+ "0",
2382
+ "71316",
2383
+ "9292",
2384
+ "246136",
2385
+ "22938"
2386
+ ]
2387
+ }
2388
+ },
2389
+ {
2390
+ "name": "cn_004",
2391
+ "role": "feature",
2392
+ "semantic_type": "numeric",
2393
+ "nullable": true,
2394
+ "missing_tokens": [
2395
+ "na"
2396
+ ],
2397
+ "parse_format": null,
2398
+ "impute_strategy": "median",
2399
+ "profile_stats": {
2400
+ "missing_rate": 0.011694,
2401
+ "unique_count": 20000,
2402
+ "unique_ratio": 0.33284,
2403
+ "example_values": [
2404
+ "53668",
2405
+ "2416614",
2406
+ "1288",
2407
+ "896600",
2408
+ "364342"
2409
+ ]
2410
+ }
2411
+ },
2412
+ {
2413
+ "name": "cn_005",
2414
+ "role": "feature",
2415
+ "semantic_type": "numeric",
2416
+ "nullable": true,
2417
+ "missing_tokens": [
2418
+ "na"
2419
+ ],
2420
+ "parse_format": null,
2421
+ "impute_strategy": "median",
2422
+ "profile_stats": {
2423
+ "missing_rate": 0.011694,
2424
+ "unique_count": 20000,
2425
+ "unique_ratio": 0.33284,
2426
+ "example_values": [
2427
+ "43094",
2428
+ "2933718",
2429
+ "1724",
2430
+ "798980",
2431
+ "1485336"
2432
+ ]
2433
+ }
2434
+ },
2435
+ {
2436
+ "name": "cn_006",
2437
+ "role": "feature",
2438
+ "semantic_type": "numeric",
2439
+ "nullable": true,
2440
+ "missing_tokens": [
2441
+ "na"
2442
+ ],
2443
+ "parse_format": null,
2444
+ "impute_strategy": "median",
2445
+ "profile_stats": {
2446
+ "missing_rate": 0.011694,
2447
+ "unique_count": 20000,
2448
+ "unique_ratio": 0.33284,
2449
+ "example_values": [
2450
+ "1432",
2451
+ "420450",
2452
+ "292",
2453
+ "304872",
2454
+ "706156"
2455
+ ]
2456
+ }
2457
+ },
2458
+ {
2459
+ "name": "cn_007",
2460
+ "role": "feature",
2461
+ "semantic_type": "numeric",
2462
+ "nullable": true,
2463
+ "missing_tokens": [
2464
+ "na"
2465
+ ],
2466
+ "parse_format": null,
2467
+ "impute_strategy": "median",
2468
+ "profile_stats": {
2469
+ "missing_rate": 0.011694,
2470
+ "unique_count": 20000,
2471
+ "unique_ratio": 0.33284,
2472
+ "example_values": [
2473
+ "238",
2474
+ "43048",
2475
+ "0",
2476
+ "12792",
2477
+ "34492"
2478
+ ]
2479
+ }
2480
+ },
2481
+ {
2482
+ "name": "cn_008",
2483
+ "role": "feature",
2484
+ "semantic_type": "numeric",
2485
+ "nullable": true,
2486
+ "missing_tokens": [
2487
+ "na"
2488
+ ],
2489
+ "parse_format": null,
2490
+ "impute_strategy": "median",
2491
+ "profile_stats": {
2492
+ "missing_rate": 0.011694,
2493
+ "unique_count": 10126,
2494
+ "unique_ratio": 0.168517,
2495
+ "example_values": [
2496
+ "52",
2497
+ "7932",
2498
+ "0",
2499
+ "1966",
2500
+ "5644"
2501
+ ]
2502
+ }
2503
+ },
2504
+ {
2505
+ "name": "cn_009",
2506
+ "role": "feature",
2507
+ "semantic_type": "numeric",
2508
+ "nullable": true,
2509
+ "missing_tokens": [
2510
+ "na"
2511
+ ],
2512
+ "parse_format": null,
2513
+ "impute_strategy": "median",
2514
+ "profile_stats": {
2515
+ "missing_rate": 0.011694,
2516
+ "unique_count": 3064,
2517
+ "unique_ratio": 0.050991,
2518
+ "example_values": [
2519
+ "0",
2520
+ "254",
2521
+ "204",
2522
+ "460",
2523
+ "12"
2524
+ ]
2525
+ }
2526
+ },
2527
+ {
2528
+ "name": "co_000",
2529
+ "role": "feature",
2530
+ "semantic_type": "numeric",
2531
+ "nullable": true,
2532
+ "missing_tokens": [
2533
+ "na"
2534
+ ],
2535
+ "parse_format": null,
2536
+ "impute_strategy": "median",
2537
+ "profile_stats": {
2538
+ "missing_rate": 0.246727,
2539
+ "unique_count": 1873,
2540
+ "unique_ratio": 0.040896,
2541
+ "example_values": [
2542
+ "2",
2543
+ "100",
2544
+ "2522",
2545
+ "8",
2546
+ "882"
2547
+ ]
2548
+ }
2549
+ },
2550
+ {
2551
+ "name": "cp_000",
2552
+ "role": "feature",
2553
+ "semantic_type": "numeric",
2554
+ "nullable": true,
2555
+ "missing_tokens": [
2556
+ "na"
2557
+ ],
2558
+ "parse_format": null,
2559
+ "impute_strategy": "median",
2560
+ "profile_stats": {
2561
+ "missing_rate": 0.045691,
2562
+ "unique_count": 2328,
2563
+ "unique_ratio": 0.040123,
2564
+ "example_values": [
2565
+ "6",
2566
+ "0",
2567
+ "24",
2568
+ "230",
2569
+ "2534"
2570
+ ]
2571
+ }
2572
+ },
2573
+ {
2574
+ "name": "cq_000",
2575
+ "role": "feature",
2576
+ "semantic_type": "numeric",
2577
+ "nullable": true,
2578
+ "missing_tokens": [
2579
+ "na"
2580
+ ],
2581
+ "parse_format": null,
2582
+ "impute_strategy": "median",
2583
+ "profile_stats": {
2584
+ "missing_rate": 0.011365,
2585
+ "unique_count": 20000,
2586
+ "unique_ratio": 0.332729,
2587
+ "example_values": [
2588
+ "104890",
2589
+ "6053972",
2590
+ "62144",
2591
+ "2922442",
2592
+ "3031738"
2593
+ ]
2594
+ }
2595
+ },
2596
+ {
2597
+ "name": "cr_000",
2598
+ "role": "feature",
2599
+ "semantic_type": "boolean",
2600
+ "nullable": true,
2601
+ "missing_tokens": [
2602
+ "na"
2603
+ ],
2604
+ "parse_format": null,
2605
+ "impute_strategy": "mode",
2606
+ "profile_stats": {
2607
+ "missing_rate": 0.772253,
2608
+ "unique_count": 73,
2609
+ "unique_ratio": 0.005272,
2610
+ "example_values": [
2611
+ "0",
2612
+ "22",
2613
+ "8106",
2614
+ "30812",
2615
+ "2632"
2616
+ ]
2617
+ }
2618
+ },
2619
+ {
2620
+ "name": "cs_000",
2621
+ "role": "feature",
2622
+ "semantic_type": "numeric",
2623
+ "nullable": true,
2624
+ "missing_tokens": [
2625
+ "na"
2626
+ ],
2627
+ "parse_format": null,
2628
+ "impute_strategy": "median",
2629
+ "profile_stats": {
2630
+ "missing_rate": 0.011349,
2631
+ "unique_count": 9374,
2632
+ "unique_ratio": 0.155947,
2633
+ "example_values": [
2634
+ "210",
2635
+ "17408",
2636
+ "2228",
2637
+ "2586",
2638
+ "4430"
2639
+ ]
2640
+ }
2641
+ },
2642
+ {
2643
+ "name": "cs_001",
2644
+ "role": "feature",
2645
+ "semantic_type": "numeric",
2646
+ "nullable": true,
2647
+ "missing_tokens": [
2648
+ "na"
2649
+ ],
2650
+ "parse_format": null,
2651
+ "impute_strategy": "median",
2652
+ "profile_stats": {
2653
+ "missing_rate": 0.011349,
2654
+ "unique_count": 3405,
2655
+ "unique_ratio": 0.056646,
2656
+ "example_values": [
2657
+ "26",
2658
+ "724",
2659
+ "22",
2660
+ "322",
2661
+ "500"
2662
+ ]
2663
+ }
2664
+ },
2665
+ {
2666
+ "name": "cs_002",
2667
+ "role": "feature",
2668
+ "semantic_type": "numeric",
2669
+ "nullable": true,
2670
+ "missing_tokens": [
2671
+ "na"
2672
+ ],
2673
+ "parse_format": null,
2674
+ "impute_strategy": "median",
2675
+ "profile_stats": {
2676
+ "missing_rate": 0.011349,
2677
+ "unique_count": 20000,
2678
+ "unique_ratio": 0.332723,
2679
+ "example_values": [
2680
+ "7100",
2681
+ "2454",
2682
+ "50",
2683
+ "63980",
2684
+ "86580"
2685
+ ]
2686
+ }
2687
+ },
2688
+ {
2689
+ "name": "cs_003",
2690
+ "role": "feature",
2691
+ "semantic_type": "numeric",
2692
+ "nullable": true,
2693
+ "missing_tokens": [
2694
+ "na"
2695
+ ],
2696
+ "parse_format": null,
2697
+ "impute_strategy": "median",
2698
+ "profile_stats": {
2699
+ "missing_rate": 0.011349,
2700
+ "unique_count": 20000,
2701
+ "unique_ratio": 0.332723,
2702
+ "example_values": [
2703
+ "2268",
2704
+ "225796",
2705
+ "726",
2706
+ "102484",
2707
+ "241144"
2708
+ ]
2709
+ }
2710
+ },
2711
+ {
2712
+ "name": "cs_004",
2713
+ "role": "feature",
2714
+ "semantic_type": "numeric",
2715
+ "nullable": true,
2716
+ "missing_tokens": [
2717
+ "na"
2718
+ ],
2719
+ "parse_format": null,
2720
+ "impute_strategy": "median",
2721
+ "profile_stats": {
2722
+ "missing_rate": 0.011349,
2723
+ "unique_count": 20000,
2724
+ "unique_ratio": 0.332723,
2725
+ "example_values": [
2726
+ "1520",
2727
+ "196192",
2728
+ "3242",
2729
+ "102782",
2730
+ "137060"
2731
+ ]
2732
+ }
2733
+ },
2734
+ {
2735
+ "name": "cs_005",
2736
+ "role": "feature",
2737
+ "semantic_type": "numeric",
2738
+ "nullable": true,
2739
+ "missing_tokens": [
2740
+ "na"
2741
+ ],
2742
+ "parse_format": null,
2743
+ "impute_strategy": "median",
2744
+ "profile_stats": {
2745
+ "missing_rate": 0.011349,
2746
+ "unique_count": 20000,
2747
+ "unique_ratio": 0.332723,
2748
+ "example_values": [
2749
+ "41000",
2750
+ "1273478",
2751
+ "24804",
2752
+ "1712116",
2753
+ "1491190"
2754
+ ]
2755
+ }
2756
+ },
2757
+ {
2758
+ "name": "cs_006",
2759
+ "role": "feature",
2760
+ "semantic_type": "numeric",
2761
+ "nullable": true,
2762
+ "missing_tokens": [
2763
+ "na"
2764
+ ],
2765
+ "parse_format": null,
2766
+ "impute_strategy": "median",
2767
+ "profile_stats": {
2768
+ "missing_rate": 0.011349,
2769
+ "unique_count": 20000,
2770
+ "unique_ratio": 0.332723,
2771
+ "example_values": [
2772
+ "45554",
2773
+ "4141758",
2774
+ "3910",
2775
+ "266134",
2776
+ "639496"
2777
+ ]
2778
+ }
2779
+ },
2780
+ {
2781
+ "name": "cs_007",
2782
+ "role": "feature",
2783
+ "semantic_type": "numeric",
2784
+ "nullable": true,
2785
+ "missing_tokens": [
2786
+ "na"
2787
+ ],
2788
+ "parse_format": null,
2789
+ "impute_strategy": "median",
2790
+ "profile_stats": {
2791
+ "missing_rate": 0.011349,
2792
+ "unique_count": 17357,
2793
+ "unique_ratio": 0.288754,
2794
+ "example_values": [
2795
+ "796",
2796
+ "35486",
2797
+ "14",
2798
+ "17560",
2799
+ "18796"
2800
+ ]
2801
+ }
2802
+ },
2803
+ {
2804
+ "name": "cs_008",
2805
+ "role": "feature",
2806
+ "semantic_type": "numeric",
2807
+ "nullable": true,
2808
+ "missing_tokens": [
2809
+ "na"
2810
+ ],
2811
+ "parse_format": null,
2812
+ "impute_strategy": "median",
2813
+ "profile_stats": {
2814
+ "missing_rate": 0.011349,
2815
+ "unique_count": 777,
2816
+ "unique_ratio": 0.012926,
2817
+ "example_values": [
2818
+ "10",
2819
+ "36",
2820
+ "0",
2821
+ "92",
2822
+ "172"
2823
+ ]
2824
+ }
2825
+ },
2826
+ {
2827
+ "name": "cs_009",
2828
+ "role": "feature",
2829
+ "semantic_type": "numeric",
2830
+ "nullable": true,
2831
+ "missing_tokens": [
2832
+ "na"
2833
+ ],
2834
+ "parse_format": null,
2835
+ "impute_strategy": "median",
2836
+ "profile_stats": {
2837
+ "missing_rate": 0.011349,
2838
+ "unique_count": 62,
2839
+ "unique_ratio": 0.001031,
2840
+ "example_values": [
2841
+ "0",
2842
+ "6",
2843
+ "2",
2844
+ "4",
2845
+ "16"
2846
+ ]
2847
+ }
2848
+ },
2849
+ {
2850
+ "name": "ct_000",
2851
+ "role": "feature",
2852
+ "semantic_type": "numeric",
2853
+ "nullable": true,
2854
+ "missing_tokens": [
2855
+ "na"
2856
+ ],
2857
+ "parse_format": null,
2858
+ "impute_strategy": "median",
2859
+ "profile_stats": {
2860
+ "missing_rate": 0.23,
2861
+ "unique_count": 2629,
2862
+ "unique_ratio": 0.056156,
2863
+ "example_values": [
2864
+ "170",
2865
+ "64",
2866
+ "1086",
2867
+ "2314",
2868
+ "50"
2869
+ ]
2870
+ }
2871
+ },
2872
+ {
2873
+ "name": "cu_000",
2874
+ "role": "feature",
2875
+ "semantic_type": "numeric",
2876
+ "nullable": true,
2877
+ "missing_tokens": [
2878
+ "na"
2879
+ ],
2880
+ "parse_format": null,
2881
+ "impute_strategy": "median",
2882
+ "profile_stats": {
2883
+ "missing_rate": 0.23,
2884
+ "unique_count": 3510,
2885
+ "unique_ratio": 0.074974,
2886
+ "example_values": [
2887
+ "250",
2888
+ "204",
2889
+ "5802",
2890
+ "2174",
2891
+ "116"
2892
+ ]
2893
+ }
2894
+ },
2895
+ {
2896
+ "name": "cv_000",
2897
+ "role": "feature",
2898
+ "semantic_type": "numeric",
2899
+ "nullable": true,
2900
+ "missing_tokens": [
2901
+ "na"
2902
+ ],
2903
+ "parse_format": null,
2904
+ "impute_strategy": "median",
2905
+ "profile_stats": {
2906
+ "missing_rate": 0.23,
2907
+ "unique_count": 20000,
2908
+ "unique_ratio": 0.427204,
2909
+ "example_values": [
2910
+ "87446",
2911
+ "13252",
2912
+ "2020630",
2913
+ "1765100",
2914
+ "7728"
2915
+ ]
2916
+ }
2917
+ },
2918
+ {
2919
+ "name": "cx_000",
2920
+ "role": "feature",
2921
+ "semantic_type": "numeric",
2922
+ "nullable": true,
2923
+ "missing_tokens": [
2924
+ "na"
2925
+ ],
2926
+ "parse_format": null,
2927
+ "impute_strategy": "median",
2928
+ "profile_stats": {
2929
+ "missing_rate": 0.23,
2930
+ "unique_count": 20000,
2931
+ "unique_ratio": 0.427204,
2932
+ "example_values": [
2933
+ "35022",
2934
+ "408",
2935
+ "227550",
2936
+ "14782",
2937
+ "1044"
2938
+ ]
2939
+ }
2940
+ },
2941
+ {
2942
+ "name": "cy_000",
2943
+ "role": "feature",
2944
+ "semantic_type": "numeric",
2945
+ "nullable": true,
2946
+ "missing_tokens": [
2947
+ "na"
2948
+ ],
2949
+ "parse_format": null,
2950
+ "impute_strategy": "median",
2951
+ "profile_stats": {
2952
+ "missing_rate": 0.23,
2953
+ "unique_count": 743,
2954
+ "unique_ratio": 0.015871,
2955
+ "example_values": [
2956
+ "0",
2957
+ "384",
2958
+ "5030",
2959
+ "2930",
2960
+ "54"
2961
+ ]
2962
+ }
2963
+ },
2964
+ {
2965
+ "name": "cz_000",
2966
+ "role": "feature",
2967
+ "semantic_type": "numeric",
2968
+ "nullable": true,
2969
+ "missing_tokens": [
2970
+ "na"
2971
+ ],
2972
+ "parse_format": null,
2973
+ "impute_strategy": "median",
2974
+ "profile_stats": {
2975
+ "missing_rate": 0.23,
2976
+ "unique_count": 10768,
2977
+ "unique_ratio": 0.230007,
2978
+ "example_values": [
2979
+ "28",
2980
+ "2",
2981
+ "60784",
2982
+ "36524",
2983
+ "0"
2984
+ ]
2985
+ }
2986
+ },
2987
+ {
2988
+ "name": "da_000",
2989
+ "role": "feature",
2990
+ "semantic_type": "boolean",
2991
+ "nullable": true,
2992
+ "missing_tokens": [
2993
+ "na"
2994
+ ],
2995
+ "parse_format": null,
2996
+ "impute_strategy": "mode",
2997
+ "profile_stats": {
2998
+ "missing_rate": 0.23,
2999
+ "unique_count": 257,
3000
+ "unique_ratio": 0.00549,
3001
+ "example_values": [
3002
+ "0",
3003
+ "302",
3004
+ "308",
3005
+ "58",
3006
+ "272"
3007
+ ]
3008
+ }
3009
+ },
3010
+ {
3011
+ "name": "db_000",
3012
+ "role": "feature",
3013
+ "semantic_type": "numeric",
3014
+ "nullable": true,
3015
+ "missing_tokens": [
3016
+ "na"
3017
+ ],
3018
+ "parse_format": null,
3019
+ "impute_strategy": "median",
3020
+ "profile_stats": {
3021
+ "missing_rate": 0.23,
3022
+ "unique_count": 141,
3023
+ "unique_ratio": 0.003012,
3024
+ "example_values": [
3025
+ "18",
3026
+ "0",
3027
+ "20",
3028
+ "14",
3029
+ "34"
3030
+ ]
3031
+ }
3032
+ },
3033
+ {
3034
+ "name": "dc_000",
3035
+ "role": "feature",
3036
+ "semantic_type": "numeric",
3037
+ "nullable": true,
3038
+ "missing_tokens": [
3039
+ "na"
3040
+ ],
3041
+ "parse_format": null,
3042
+ "impute_strategy": "median",
3043
+ "profile_stats": {
3044
+ "missing_rate": 0.23,
3045
+ "unique_count": 20000,
3046
+ "unique_ratio": 0.427204,
3047
+ "example_values": [
3048
+ "87734",
3049
+ "13272",
3050
+ "2039720",
3051
+ "2079548",
3052
+ "8936"
3053
+ ]
3054
+ }
3055
+ },
3056
+ {
3057
+ "name": "dd_000",
3058
+ "role": "feature",
3059
+ "semantic_type": "numeric",
3060
+ "nullable": true,
3061
+ "missing_tokens": [
3062
+ "na"
3063
+ ],
3064
+ "parse_format": null,
3065
+ "impute_strategy": "median",
3066
+ "profile_stats": {
3067
+ "missing_rate": 0.041776,
3068
+ "unique_count": 6626,
3069
+ "unique_ratio": 0.113732,
3070
+ "example_values": [
3071
+ "128",
3072
+ "2812",
3073
+ "182",
3074
+ "1232",
3075
+ "2136"
3076
+ ]
3077
+ }
3078
+ },
3079
+ {
3080
+ "name": "de_000",
3081
+ "role": "feature",
3082
+ "semantic_type": "numeric",
3083
+ "nullable": true,
3084
+ "missing_tokens": [
3085
+ "na"
3086
+ ],
3087
+ "parse_format": null,
3088
+ "impute_strategy": "median",
3089
+ "profile_stats": {
3090
+ "missing_rate": 0.045691,
3091
+ "unique_count": 1935,
3092
+ "unique_ratio": 0.033349,
3093
+ "example_values": [
3094
+ "50",
3095
+ "270",
3096
+ "328",
3097
+ "116",
3098
+ "240"
3099
+ ]
3100
+ }
3101
+ },
3102
+ {
3103
+ "name": "df_000",
3104
+ "role": "feature",
3105
+ "semantic_type": "boolean",
3106
+ "nullable": true,
3107
+ "missing_tokens": [
3108
+ "na"
3109
+ ],
3110
+ "parse_format": null,
3111
+ "impute_strategy": "mode",
3112
+ "profile_stats": {
3113
+ "missing_rate": 0.066299,
3114
+ "unique_count": 404,
3115
+ "unique_ratio": 0.007117,
3116
+ "example_values": [
3117
+ "0",
3118
+ "40",
3119
+ "440",
3120
+ "1100",
3121
+ "2418750"
3122
+ ]
3123
+ }
3124
+ },
3125
+ {
3126
+ "name": "dg_000",
3127
+ "role": "feature",
3128
+ "semantic_type": "numeric",
3129
+ "nullable": true,
3130
+ "missing_tokens": [
3131
+ "na"
3132
+ ],
3133
+ "parse_format": null,
3134
+ "impute_strategy": "median",
3135
+ "profile_stats": {
3136
+ "missing_rate": 0.066283,
3137
+ "unique_count": 1333,
3138
+ "unique_ratio": 0.023481,
3139
+ "example_values": [
3140
+ "0",
3141
+ "1172",
3142
+ "17600",
3143
+ "10482",
3144
+ "4176232"
3145
+ ]
3146
+ }
3147
+ },
3148
+ {
3149
+ "name": "dh_000",
3150
+ "role": "feature",
3151
+ "semantic_type": "numeric",
3152
+ "nullable": true,
3153
+ "missing_tokens": [
3154
+ "na"
3155
+ ],
3156
+ "parse_format": null,
3157
+ "impute_strategy": "median",
3158
+ "profile_stats": {
3159
+ "missing_rate": 0.066299,
3160
+ "unique_count": 1059,
3161
+ "unique_ratio": 0.018655,
3162
+ "example_values": [
3163
+ "0",
3164
+ "80",
3165
+ "5510",
3166
+ "110",
3167
+ "160"
3168
+ ]
3169
+ }
3170
+ },
3171
+ {
3172
+ "name": "di_000",
3173
+ "role": "feature",
3174
+ "semantic_type": "numeric",
3175
+ "nullable": true,
3176
+ "missing_tokens": [
3177
+ "na"
3178
+ ],
3179
+ "parse_format": null,
3180
+ "impute_strategy": "median",
3181
+ "profile_stats": {
3182
+ "missing_rate": 0.066283,
3183
+ "unique_count": 5674,
3184
+ "unique_ratio": 0.099947,
3185
+ "example_values": [
3186
+ "0",
3187
+ "286",
3188
+ "36630",
3189
+ "7796",
3190
+ "66"
3191
+ ]
3192
+ }
3193
+ },
3194
+ {
3195
+ "name": "dj_000",
3196
+ "role": "feature",
3197
+ "semantic_type": "boolean",
3198
+ "nullable": true,
3199
+ "missing_tokens": [
3200
+ "na"
3201
+ ],
3202
+ "parse_format": null,
3203
+ "impute_strategy": "mode",
3204
+ "profile_stats": {
3205
+ "missing_rate": 0.066283,
3206
+ "unique_count": 72,
3207
+ "unique_ratio": 0.001268,
3208
+ "example_values": [
3209
+ "0",
3210
+ "40",
3211
+ "260",
3212
+ "10",
3213
+ "200"
3214
+ ]
3215
+ }
3216
+ },
3217
+ {
3218
+ "name": "dk_000",
3219
+ "role": "feature",
3220
+ "semantic_type": "boolean",
3221
+ "nullable": true,
3222
+ "missing_tokens": [
3223
+ "na"
3224
+ ],
3225
+ "parse_format": null,
3226
+ "impute_strategy": "mode",
3227
+ "profile_stats": {
3228
+ "missing_rate": 0.066283,
3229
+ "unique_count": 267,
3230
+ "unique_ratio": 0.004703,
3231
+ "example_values": [
3232
+ "0",
3233
+ "5646",
3234
+ "502",
3235
+ "54",
3236
+ "572"
3237
+ ]
3238
+ }
3239
+ },
3240
+ {
3241
+ "name": "dl_000",
3242
+ "role": "feature",
3243
+ "semantic_type": "boolean",
3244
+ "nullable": true,
3245
+ "missing_tokens": [
3246
+ "na"
3247
+ ],
3248
+ "parse_format": null,
3249
+ "impute_strategy": "mode",
3250
+ "profile_stats": {
3251
+ "missing_rate": 0.066299,
3252
+ "unique_count": 191,
3253
+ "unique_ratio": 0.003365,
3254
+ "example_values": [
3255
+ "0",
3256
+ "160",
3257
+ "1190",
3258
+ "25620",
3259
+ "1900"
3260
+ ]
3261
+ }
3262
+ },
3263
+ {
3264
+ "name": "dm_000",
3265
+ "role": "feature",
3266
+ "semantic_type": "boolean",
3267
+ "nullable": true,
3268
+ "missing_tokens": [
3269
+ "na"
3270
+ ],
3271
+ "parse_format": null,
3272
+ "impute_strategy": "mode",
3273
+ "profile_stats": {
3274
+ "missing_rate": 0.066299,
3275
+ "unique_count": 236,
3276
+ "unique_ratio": 0.004157,
3277
+ "example_values": [
3278
+ "0",
3279
+ "7842",
3280
+ "47464",
3281
+ "136746",
3282
+ "25864"
3283
+ ]
3284
+ }
3285
+ },
3286
+ {
3287
+ "name": "dn_000",
3288
+ "role": "feature",
3289
+ "semantic_type": "numeric",
3290
+ "nullable": true,
3291
+ "missing_tokens": [
3292
+ "na"
3293
+ ],
3294
+ "parse_format": null,
3295
+ "impute_strategy": "median",
3296
+ "profile_stats": {
3297
+ "missing_rate": 0.011365,
3298
+ "unique_count": 20000,
3299
+ "unique_ratio": 0.332729,
3300
+ "example_values": [
3301
+ "582",
3302
+ "18072",
3303
+ "676",
3304
+ "15162",
3305
+ "24566"
3306
+ ]
3307
+ }
3308
+ },
3309
+ {
3310
+ "name": "do_000",
3311
+ "role": "feature",
3312
+ "semantic_type": "numeric",
3313
+ "nullable": true,
3314
+ "missing_tokens": [
3315
+ "na"
3316
+ ],
3317
+ "parse_format": null,
3318
+ "impute_strategy": "median",
3319
+ "profile_stats": {
3320
+ "missing_rate": 0.045674,
3321
+ "unique_count": 20000,
3322
+ "unique_ratio": 0.344691,
3323
+ "example_values": [
3324
+ "676",
3325
+ "71612",
3326
+ "0",
3327
+ "27588",
3328
+ "27348"
3329
+ ]
3330
+ }
3331
+ },
3332
+ {
3333
+ "name": "dp_000",
3334
+ "role": "feature",
3335
+ "semantic_type": "numeric",
3336
+ "nullable": true,
3337
+ "missing_tokens": [
3338
+ "na"
3339
+ ],
3340
+ "parse_format": null,
3341
+ "impute_strategy": "median",
3342
+ "profile_stats": {
3343
+ "missing_rate": 0.045707,
3344
+ "unique_count": 11680,
3345
+ "unique_ratio": 0.201306,
3346
+ "example_values": [
3347
+ "274",
3348
+ "14700",
3349
+ "0",
3350
+ "6920",
3351
+ "9376"
3352
+ ]
3353
+ }
3354
+ },
3355
+ {
3356
+ "name": "dq_000",
3357
+ "role": "feature",
3358
+ "semantic_type": "numeric",
3359
+ "nullable": true,
3360
+ "missing_tokens": [
3361
+ "na"
3362
+ ],
3363
+ "parse_format": null,
3364
+ "impute_strategy": "median",
3365
+ "profile_stats": {
3366
+ "missing_rate": 0.045707,
3367
+ "unique_count": 8172,
3368
+ "unique_ratio": 0.140846,
3369
+ "example_values": [
3370
+ "0",
3371
+ "5916",
3372
+ "80",
3373
+ "46424",
3374
+ "1634"
3375
+ ]
3376
+ }
3377
+ },
3378
+ {
3379
+ "name": "dr_000",
3380
+ "role": "feature",
3381
+ "semantic_type": "numeric",
3382
+ "nullable": true,
3383
+ "missing_tokens": [
3384
+ "na"
3385
+ ],
3386
+ "parse_format": null,
3387
+ "impute_strategy": "median",
3388
+ "profile_stats": {
3389
+ "missing_rate": 0.045707,
3390
+ "unique_count": 6718,
3391
+ "unique_ratio": 0.115786,
3392
+ "example_values": [
3393
+ "0",
3394
+ "1822",
3395
+ "20",
3396
+ "22158",
3397
+ "462"
3398
+ ]
3399
+ }
3400
+ },
3401
+ {
3402
+ "name": "ds_000",
3403
+ "role": "feature",
3404
+ "semantic_type": "numeric",
3405
+ "nullable": true,
3406
+ "missing_tokens": [
3407
+ "na"
3408
+ ],
3409
+ "parse_format": null,
3410
+ "impute_strategy": "median",
3411
+ "profile_stats": {
3412
+ "missing_rate": 0.045724,
3413
+ "unique_count": 20000,
3414
+ "unique_ratio": 0.344709,
3415
+ "example_values": [
3416
+ "1818",
3417
+ "195476",
3418
+ "382",
3419
+ "67782",
3420
+ "81362"
3421
+ ]
3422
+ }
3423
+ },
3424
+ {
3425
+ "name": "dt_000",
3426
+ "role": "feature",
3427
+ "semantic_type": "numeric",
3428
+ "nullable": true,
3429
+ "missing_tokens": [
3430
+ "na"
3431
+ ],
3432
+ "parse_format": null,
3433
+ "impute_strategy": "median",
3434
+ "profile_stats": {
3435
+ "missing_rate": 0.045724,
3436
+ "unique_count": 15973,
3437
+ "unique_ratio": 0.275302,
3438
+ "example_values": [
3439
+ "366",
3440
+ "45576",
3441
+ "118",
3442
+ "9494",
3443
+ "14780"
3444
+ ]
3445
+ }
3446
+ },
3447
+ {
3448
+ "name": "du_000",
3449
+ "role": "feature",
3450
+ "semantic_type": "numeric",
3451
+ "nullable": true,
3452
+ "missing_tokens": [
3453
+ "na"
3454
+ ],
3455
+ "parse_format": null,
3456
+ "impute_strategy": "median",
3457
+ "profile_stats": {
3458
+ "missing_rate": 0.045707,
3459
+ "unique_count": 20000,
3460
+ "unique_ratio": 0.344703,
3461
+ "example_values": [
3462
+ "172440",
3463
+ "4797440",
3464
+ "44360",
3465
+ "50580",
3466
+ "7797080"
3467
+ ]
3468
+ }
3469
+ },
3470
+ {
3471
+ "name": "dv_000",
3472
+ "role": "feature",
3473
+ "semantic_type": "numeric",
3474
+ "nullable": true,
3475
+ "missing_tokens": [
3476
+ "na"
3477
+ ],
3478
+ "parse_format": null,
3479
+ "impute_strategy": "median",
3480
+ "profile_stats": {
3481
+ "missing_rate": 0.045707,
3482
+ "unique_count": 20000,
3483
+ "unique_ratio": 0.344703,
3484
+ "example_values": [
3485
+ "17258",
3486
+ "2234018",
3487
+ "4450",
3488
+ "10454",
3489
+ "1354532"
3490
+ ]
3491
+ }
3492
+ },
3493
+ {
3494
+ "name": "dx_000",
3495
+ "role": "feature",
3496
+ "semantic_type": "numeric",
3497
+ "nullable": true,
3498
+ "missing_tokens": [
3499
+ "na"
3500
+ ],
3501
+ "parse_format": null,
3502
+ "impute_strategy": "median",
3503
+ "profile_stats": {
3504
+ "missing_rate": 0.045691,
3505
+ "unique_count": 14891,
3506
+ "unique_ratio": 0.256644,
3507
+ "example_values": [
3508
+ "28760",
3509
+ "0",
3510
+ "9742",
3511
+ "9654",
3512
+ "54468"
3513
+ ]
3514
+ }
3515
+ },
3516
+ {
3517
+ "name": "dy_000",
3518
+ "role": "feature",
3519
+ "semantic_type": "numeric",
3520
+ "nullable": true,
3521
+ "missing_tokens": [
3522
+ "na"
3523
+ ],
3524
+ "parse_format": null,
3525
+ "impute_strategy": "median",
3526
+ "profile_stats": {
3527
+ "missing_rate": 0.045707,
3528
+ "unique_count": 6366,
3529
+ "unique_ratio": 0.109719,
3530
+ "example_values": [
3531
+ "96",
3532
+ "0",
3533
+ "12",
3534
+ "26",
3535
+ "76"
3536
+ ]
3537
+ }
3538
+ },
3539
+ {
3540
+ "name": "dz_000",
3541
+ "role": "feature",
3542
+ "semantic_type": "boolean",
3543
+ "nullable": true,
3544
+ "missing_tokens": [
3545
+ "na"
3546
+ ],
3547
+ "parse_format": null,
3548
+ "impute_strategy": "mode",
3549
+ "profile_stats": {
3550
+ "missing_rate": 0.045674,
3551
+ "unique_count": 45,
3552
+ "unique_ratio": 0.000776,
3553
+ "example_values": [
3554
+ "0",
3555
+ "2",
3556
+ "6",
3557
+ "12",
3558
+ "4"
3559
+ ]
3560
+ }
3561
+ },
3562
+ {
3563
+ "name": "ea_000",
3564
+ "role": "feature",
3565
+ "semantic_type": "boolean",
3566
+ "nullable": true,
3567
+ "missing_tokens": [
3568
+ "na"
3569
+ ],
3570
+ "parse_format": null,
3571
+ "impute_strategy": "mode",
3572
+ "profile_stats": {
3573
+ "missing_rate": 0.045674,
3574
+ "unique_count": 131,
3575
+ "unique_ratio": 0.002258,
3576
+ "example_values": [
3577
+ "0",
3578
+ "2",
3579
+ "8",
3580
+ "10",
3581
+ "18"
3582
+ ]
3583
+ }
3584
+ },
3585
+ {
3586
+ "name": "eb_000",
3587
+ "role": "feature",
3588
+ "semantic_type": "numeric",
3589
+ "nullable": true,
3590
+ "missing_tokens": [
3591
+ "na"
3592
+ ],
3593
+ "parse_format": null,
3594
+ "impute_strategy": "median",
3595
+ "profile_stats": {
3596
+ "missing_rate": 0.066283,
3597
+ "unique_count": 20000,
3598
+ "unique_ratio": 0.352299,
3599
+ "example_values": [
3600
+ "655720",
3601
+ "1186300",
3602
+ "0",
3603
+ "1304800",
3604
+ "2929070"
3605
+ ]
3606
+ }
3607
+ },
3608
+ {
3609
+ "name": "ec_00",
3610
+ "role": "feature",
3611
+ "semantic_type": "numeric",
3612
+ "nullable": true,
3613
+ "missing_tokens": [
3614
+ "na"
3615
+ ],
3616
+ "parse_format": null,
3617
+ "impute_strategy": "median",
3618
+ "profile_stats": {
3619
+ "missing_rate": 0.167862,
3620
+ "unique_count": 20000,
3621
+ "unique_ratio": 0.395304,
3622
+ "example_values": [
3623
+ "65.78",
3624
+ "277.6",
3625
+ "687.2",
3626
+ "1133.78",
3627
+ "127.84"
3628
+ ]
3629
+ }
3630
+ },
3631
+ {
3632
+ "name": "ed_000",
3633
+ "role": "feature",
3634
+ "semantic_type": "numeric",
3635
+ "nullable": true,
3636
+ "missing_tokens": [
3637
+ "na"
3638
+ ],
3639
+ "parse_format": null,
3640
+ "impute_strategy": "median",
3641
+ "profile_stats": {
3642
+ "missing_rate": 0.156793,
3643
+ "unique_count": 3976,
3644
+ "unique_ratio": 0.077555,
3645
+ "example_values": [
3646
+ "68",
3647
+ "130",
3648
+ "756",
3649
+ "1192",
3650
+ "70"
3651
+ ]
3652
+ }
3653
+ },
3654
+ {
3655
+ "name": "ee_000",
3656
+ "role": "feature",
3657
+ "semantic_type": "numeric",
3658
+ "nullable": true,
3659
+ "missing_tokens": [
3660
+ "na"
3661
+ ],
3662
+ "parse_format": null,
3663
+ "impute_strategy": "median",
3664
+ "profile_stats": {
3665
+ "missing_rate": 0.011431,
3666
+ "unique_count": 20000,
3667
+ "unique_ratio": 0.332751,
3668
+ "example_values": [
3669
+ "13308",
3670
+ "536366",
3671
+ "23816",
3672
+ "258900",
3673
+ "622930"
3674
+ ]
3675
+ }
3676
+ },
3677
+ {
3678
+ "name": "ee_001",
3679
+ "role": "feature",
3680
+ "semantic_type": "numeric",
3681
+ "nullable": true,
3682
+ "missing_tokens": [
3683
+ "na"
3684
+ ],
3685
+ "parse_format": null,
3686
+ "impute_strategy": "median",
3687
+ "profile_stats": {
3688
+ "missing_rate": 0.011431,
3689
+ "unique_count": 20000,
3690
+ "unique_ratio": 0.332751,
3691
+ "example_values": [
3692
+ "12120",
3693
+ "707172",
3694
+ "6194",
3695
+ "312464",
3696
+ "546652"
3697
+ ]
3698
+ }
3699
+ },
3700
+ {
3701
+ "name": "ee_002",
3702
+ "role": "feature",
3703
+ "semantic_type": "numeric",
3704
+ "nullable": true,
3705
+ "missing_tokens": [
3706
+ "na"
3707
+ ],
3708
+ "parse_format": null,
3709
+ "impute_strategy": "median",
3710
+ "profile_stats": {
3711
+ "missing_rate": 0.011431,
3712
+ "unique_count": 20000,
3713
+ "unique_ratio": 0.332751,
3714
+ "example_values": [
3715
+ "5308",
3716
+ "421568",
3717
+ "1256",
3718
+ "262268",
3719
+ "319658"
3720
+ ]
3721
+ }
3722
+ },
3723
+ {
3724
+ "name": "ee_003",
3725
+ "role": "feature",
3726
+ "semantic_type": "numeric",
3727
+ "nullable": true,
3728
+ "missing_tokens": [
3729
+ "na"
3730
+ ],
3731
+ "parse_format": null,
3732
+ "impute_strategy": "median",
3733
+ "profile_stats": {
3734
+ "missing_rate": 0.011431,
3735
+ "unique_count": 20000,
3736
+ "unique_ratio": 0.332751,
3737
+ "example_values": [
3738
+ "3258",
3739
+ "212454",
3740
+ "542",
3741
+ "152306",
3742
+ "144106"
3743
+ ]
3744
+ }
3745
+ },
3746
+ {
3747
+ "name": "ee_004",
3748
+ "role": "feature",
3749
+ "semantic_type": "numeric",
3750
+ "nullable": true,
3751
+ "missing_tokens": [
3752
+ "na"
3753
+ ],
3754
+ "parse_format": null,
3755
+ "impute_strategy": "median",
3756
+ "profile_stats": {
3757
+ "missing_rate": 0.011431,
3758
+ "unique_count": 20000,
3759
+ "unique_ratio": 0.332751,
3760
+ "example_values": [
3761
+ "8582",
3762
+ "446284",
3763
+ "1046",
3764
+ "325008",
3765
+ "283446"
3766
+ ]
3767
+ }
3768
+ },
3769
+ {
3770
+ "name": "ee_005",
3771
+ "role": "feature",
3772
+ "semantic_type": "numeric",
3773
+ "nullable": true,
3774
+ "missing_tokens": [
3775
+ "na"
3776
+ ],
3777
+ "parse_format": null,
3778
+ "impute_strategy": "median",
3779
+ "profile_stats": {
3780
+ "missing_rate": 0.011431,
3781
+ "unique_count": 20000,
3782
+ "unique_ratio": 0.332751,
3783
+ "example_values": [
3784
+ "43912",
3785
+ "460602",
3786
+ "350",
3787
+ "446416",
3788
+ "260842"
3789
+ ]
3790
+ }
3791
+ },
3792
+ {
3793
+ "name": "ee_006",
3794
+ "role": "feature",
3795
+ "semantic_type": "numeric",
3796
+ "nullable": true,
3797
+ "missing_tokens": [
3798
+ "na"
3799
+ ],
3800
+ "parse_format": null,
3801
+ "impute_strategy": "median",
3802
+ "profile_stats": {
3803
+ "missing_rate": 0.011431,
3804
+ "unique_count": 20000,
3805
+ "unique_ratio": 0.332751,
3806
+ "example_values": [
3807
+ "6370",
3808
+ "374400",
3809
+ "680",
3810
+ "377770",
3811
+ "168748"
3812
+ ]
3813
+ }
3814
+ },
3815
+ {
3816
+ "name": "ee_007",
3817
+ "role": "feature",
3818
+ "semantic_type": "numeric",
3819
+ "nullable": true,
3820
+ "missing_tokens": [
3821
+ "na"
3822
+ ],
3823
+ "parse_format": null,
3824
+ "impute_strategy": "median",
3825
+ "profile_stats": {
3826
+ "missing_rate": 0.011431,
3827
+ "unique_count": 20000,
3828
+ "unique_ratio": 0.332751,
3829
+ "example_values": [
3830
+ "2886",
3831
+ "371258",
3832
+ "1112",
3833
+ "76752",
3834
+ "108786"
3835
+ ]
3836
+ }
3837
+ },
3838
+ {
3839
+ "name": "ee_008",
3840
+ "role": "feature",
3841
+ "semantic_type": "numeric",
3842
+ "nullable": true,
3843
+ "missing_tokens": [
3844
+ "na"
3845
+ ],
3846
+ "parse_format": null,
3847
+ "impute_strategy": "median",
3848
+ "profile_stats": {
3849
+ "missing_rate": 0.011431,
3850
+ "unique_count": 20000,
3851
+ "unique_ratio": 0.332751,
3852
+ "example_values": [
3853
+ "2584",
3854
+ "2041592",
3855
+ "0",
3856
+ "55228",
3857
+ "151796"
3858
+ ]
3859
+ }
3860
+ },
3861
+ {
3862
+ "name": "ee_009",
3863
+ "role": "feature",
3864
+ "semantic_type": "numeric",
3865
+ "nullable": true,
3866
+ "missing_tokens": [
3867
+ "na"
3868
+ ],
3869
+ "parse_format": null,
3870
+ "impute_strategy": "median",
3871
+ "profile_stats": {
3872
+ "missing_rate": 0.011431,
3873
+ "unique_count": 9722,
3874
+ "unique_ratio": 0.16175,
3875
+ "example_values": [
3876
+ "156",
3877
+ "321636",
3878
+ "0",
3879
+ "944",
3880
+ "12404"
3881
+ ]
3882
+ }
3883
+ },
3884
+ {
3885
+ "name": "ef_000",
3886
+ "role": "feature",
3887
+ "semantic_type": "boolean",
3888
+ "nullable": true,
3889
+ "missing_tokens": [
3890
+ "na"
3891
+ ],
3892
+ "parse_format": null,
3893
+ "impute_strategy": "mode",
3894
+ "profile_stats": {
3895
+ "missing_rate": 0.045691,
3896
+ "unique_count": 27,
3897
+ "unique_ratio": 0.000465,
3898
+ "example_values": [
3899
+ "0",
3900
+ "2",
3901
+ "8",
3902
+ "4",
3903
+ "362"
3904
+ ]
3905
+ }
3906
+ },
3907
+ {
3908
+ "name": "eg_000",
3909
+ "role": "feature",
3910
+ "semantic_type": "boolean",
3911
+ "nullable": true,
3912
+ "missing_tokens": [
3913
+ "na"
3914
+ ],
3915
+ "parse_format": null,
3916
+ "impute_strategy": "mode",
3917
+ "profile_stats": {
3918
+ "missing_rate": 0.045674,
3919
+ "unique_count": 49,
3920
+ "unique_ratio": 0.000844,
3921
+ "example_values": [
3922
+ "0",
3923
+ "2",
3924
+ "6",
3925
+ "8",
3926
+ "20"
3927
+ ]
3928
+ }
3929
+ }
3930
+ ]
3931
+ }
syntheticFail/n18/tabddpm/tabddpm-n18-20260510_215518/run_config.json ADDED
@@ -0,0 +1,45 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "schema_version": 1,
3
+ "recorded_at": "2026-05-10T21:55:25",
4
+ "dataset_id": "n18",
5
+ "model": "tabddpm",
6
+ "work_dir": "/data/jialinzhang/SynthesizePipeline-server/output-Benchmark-trainonly-v1/n18/tabddpm/tabddpm-n18-20260510_215518",
7
+ "dataset_source_requested": "new",
8
+ "dataset_source_resolved": "new",
9
+ "cli_args": {
10
+ "model": "tabddpm",
11
+ "dataset": "n18",
12
+ "dataset_source": "new",
13
+ "train": true,
14
+ "generate": true,
15
+ "num_rows": 0,
16
+ "epochs": null,
17
+ "output_dir": null,
18
+ "model_dir": null,
19
+ "work_dir": null,
20
+ "resume": false,
21
+ "no_stats": false
22
+ },
23
+ "resolved": {
24
+ "num_rows": 60800,
25
+ "model_path": null,
26
+ "output_csv": null
27
+ },
28
+ "input_artifacts": {
29
+ "public_gate_report": "/data/jialinzhang/SynthesizePipeline-server/output-Benchmark-trainonly-v1/n18/tabddpm/tabddpm-n18-20260510_215518/public_gate/public_gate_report.json",
30
+ "public_manifest": "/data/jialinzhang/SynthesizePipeline-server/output-Benchmark-trainonly-v1/n18/tabddpm/tabddpm-n18-20260510_215518/public_gate/staged_input_manifest.json",
31
+ "model_manifest": "/data/jialinzhang/SynthesizePipeline-server/output-Benchmark-trainonly-v1/n18/tabddpm/tabddpm-n18-20260510_215518/staged/tabddpm/model_input_manifest.json",
32
+ "train_csv": "/data/jialinzhang/SynthesizePipeline-server/output-Benchmark-trainonly-v1/n18/tabddpm/tabddpm-n18-20260510_215518/staged/public/train.csv",
33
+ "features_json": "/data/jialinzhang/SynthesizePipeline-server/output-Benchmark-trainonly-v1/n18/tabddpm/tabddpm-n18-20260510_215518/staged/public/staged_features.json",
34
+ "target_column": "class",
35
+ "task_type": "classification"
36
+ },
37
+ "env_overrides": {
38
+ "BENCHMARK_TABDDPM_GPUS": "device=3",
39
+ "TABDDPM_NUM_TIMESTEPS": "200",
40
+ "TABDDPM_SAMPLE_BATCH_SIZE": "256",
41
+ "TABDDPM_STEPS_PER_EPOCH": "40",
42
+ "TABDDPM_TRAIN_BATCH_SIZE": "256",
43
+ "TABDDPM_TRAIN_LR": "0.001"
44
+ }
45
+ }
syntheticFail/n18/tabddpm/tabddpm-n18-20260510_215518/runtime_result.json ADDED
@@ -0,0 +1,24 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "dataset_id": "n18",
3
+ "model": "tabddpm",
4
+ "run_id": "tabddpm-n18-20260510_215518",
5
+ "public_gate_status": "pass",
6
+ "adapter_ready_status": "pass",
7
+ "train_status": "fail",
8
+ "generate_status": "skipped",
9
+ "reason_code": "adapter_runtime_error",
10
+ "reason_detail": "Command '['docker', 'run', '--rm', '--init', '--user', '1005:1005', '-e', 'HOME=/work/.home', '--cidfile', '/tmp/bench_docker_tabddpm_7anhsmtv/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/n18/tabddpm/tabddpm-n18-20260510_215518/_tabddpm_train.py']' returned non-zero exit status 1.",
11
+ "artifacts": {},
12
+ "timings": {
13
+ "train": {
14
+ "started_at": "2026-05-10T21:55:26",
15
+ "ended_at": "2026-05-10T21:55:29",
16
+ "duration_sec": 3.063
17
+ },
18
+ "generate": {
19
+ "started_at": null,
20
+ "ended_at": null,
21
+ "duration_sec": null
22
+ }
23
+ }
24
+ }
syntheticFail/n18/tabddpm/tabddpm-n18-20260510_215518/staged/public/staged_features.json ADDED
@@ -0,0 +1,857 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ [
2
+ {
3
+ "feature_name": "class",
4
+ "data_type": "categorical",
5
+ "is_target": true
6
+ },
7
+ {
8
+ "feature_name": "aa_000",
9
+ "data_type": "continuous",
10
+ "is_target": false
11
+ },
12
+ {
13
+ "feature_name": "ab_000",
14
+ "data_type": "continuous",
15
+ "is_target": false
16
+ },
17
+ {
18
+ "feature_name": "ac_000",
19
+ "data_type": "continuous",
20
+ "is_target": false
21
+ },
22
+ {
23
+ "feature_name": "ad_000",
24
+ "data_type": "continuous",
25
+ "is_target": false
26
+ },
27
+ {
28
+ "feature_name": "ae_000",
29
+ "data_type": "continuous",
30
+ "is_target": false
31
+ },
32
+ {
33
+ "feature_name": "af_000",
34
+ "data_type": "continuous",
35
+ "is_target": false
36
+ },
37
+ {
38
+ "feature_name": "ag_000",
39
+ "data_type": "binary",
40
+ "is_target": false
41
+ },
42
+ {
43
+ "feature_name": "ag_001",
44
+ "data_type": "binary",
45
+ "is_target": false
46
+ },
47
+ {
48
+ "feature_name": "ag_002",
49
+ "data_type": "continuous",
50
+ "is_target": false
51
+ },
52
+ {
53
+ "feature_name": "ag_003",
54
+ "data_type": "continuous",
55
+ "is_target": false
56
+ },
57
+ {
58
+ "feature_name": "ag_004",
59
+ "data_type": "continuous",
60
+ "is_target": false
61
+ },
62
+ {
63
+ "feature_name": "ag_005",
64
+ "data_type": "continuous",
65
+ "is_target": false
66
+ },
67
+ {
68
+ "feature_name": "ag_006",
69
+ "data_type": "continuous",
70
+ "is_target": false
71
+ },
72
+ {
73
+ "feature_name": "ag_007",
74
+ "data_type": "continuous",
75
+ "is_target": false
76
+ },
77
+ {
78
+ "feature_name": "ag_008",
79
+ "data_type": "continuous",
80
+ "is_target": false
81
+ },
82
+ {
83
+ "feature_name": "ag_009",
84
+ "data_type": "continuous",
85
+ "is_target": false
86
+ },
87
+ {
88
+ "feature_name": "ah_000",
89
+ "data_type": "continuous",
90
+ "is_target": false
91
+ },
92
+ {
93
+ "feature_name": "ai_000",
94
+ "data_type": "continuous",
95
+ "is_target": false
96
+ },
97
+ {
98
+ "feature_name": "aj_000",
99
+ "data_type": "continuous",
100
+ "is_target": false
101
+ },
102
+ {
103
+ "feature_name": "ak_000",
104
+ "data_type": "binary",
105
+ "is_target": false
106
+ },
107
+ {
108
+ "feature_name": "al_000",
109
+ "data_type": "continuous",
110
+ "is_target": false
111
+ },
112
+ {
113
+ "feature_name": "am_0",
114
+ "data_type": "continuous",
115
+ "is_target": false
116
+ },
117
+ {
118
+ "feature_name": "an_000",
119
+ "data_type": "continuous",
120
+ "is_target": false
121
+ },
122
+ {
123
+ "feature_name": "ao_000",
124
+ "data_type": "continuous",
125
+ "is_target": false
126
+ },
127
+ {
128
+ "feature_name": "ap_000",
129
+ "data_type": "continuous",
130
+ "is_target": false
131
+ },
132
+ {
133
+ "feature_name": "aq_000",
134
+ "data_type": "continuous",
135
+ "is_target": false
136
+ },
137
+ {
138
+ "feature_name": "ar_000",
139
+ "data_type": "continuous",
140
+ "is_target": false
141
+ },
142
+ {
143
+ "feature_name": "as_000",
144
+ "data_type": "binary",
145
+ "is_target": false
146
+ },
147
+ {
148
+ "feature_name": "at_000",
149
+ "data_type": "continuous",
150
+ "is_target": false
151
+ },
152
+ {
153
+ "feature_name": "au_000",
154
+ "data_type": "binary",
155
+ "is_target": false
156
+ },
157
+ {
158
+ "feature_name": "av_000",
159
+ "data_type": "continuous",
160
+ "is_target": false
161
+ },
162
+ {
163
+ "feature_name": "ax_000",
164
+ "data_type": "continuous",
165
+ "is_target": false
166
+ },
167
+ {
168
+ "feature_name": "ay_000",
169
+ "data_type": "binary",
170
+ "is_target": false
171
+ },
172
+ {
173
+ "feature_name": "ay_001",
174
+ "data_type": "binary",
175
+ "is_target": false
176
+ },
177
+ {
178
+ "feature_name": "ay_002",
179
+ "data_type": "binary",
180
+ "is_target": false
181
+ },
182
+ {
183
+ "feature_name": "ay_003",
184
+ "data_type": "continuous",
185
+ "is_target": false
186
+ },
187
+ {
188
+ "feature_name": "ay_004",
189
+ "data_type": "continuous",
190
+ "is_target": false
191
+ },
192
+ {
193
+ "feature_name": "ay_005",
194
+ "data_type": "continuous",
195
+ "is_target": false
196
+ },
197
+ {
198
+ "feature_name": "ay_006",
199
+ "data_type": "continuous",
200
+ "is_target": false
201
+ },
202
+ {
203
+ "feature_name": "ay_007",
204
+ "data_type": "continuous",
205
+ "is_target": false
206
+ },
207
+ {
208
+ "feature_name": "ay_008",
209
+ "data_type": "continuous",
210
+ "is_target": false
211
+ },
212
+ {
213
+ "feature_name": "ay_009",
214
+ "data_type": "binary",
215
+ "is_target": false
216
+ },
217
+ {
218
+ "feature_name": "az_000",
219
+ "data_type": "continuous",
220
+ "is_target": false
221
+ },
222
+ {
223
+ "feature_name": "az_001",
224
+ "data_type": "continuous",
225
+ "is_target": false
226
+ },
227
+ {
228
+ "feature_name": "az_002",
229
+ "data_type": "continuous",
230
+ "is_target": false
231
+ },
232
+ {
233
+ "feature_name": "az_003",
234
+ "data_type": "continuous",
235
+ "is_target": false
236
+ },
237
+ {
238
+ "feature_name": "az_004",
239
+ "data_type": "continuous",
240
+ "is_target": false
241
+ },
242
+ {
243
+ "feature_name": "az_005",
244
+ "data_type": "continuous",
245
+ "is_target": false
246
+ },
247
+ {
248
+ "feature_name": "az_006",
249
+ "data_type": "continuous",
250
+ "is_target": false
251
+ },
252
+ {
253
+ "feature_name": "az_007",
254
+ "data_type": "continuous",
255
+ "is_target": false
256
+ },
257
+ {
258
+ "feature_name": "az_008",
259
+ "data_type": "continuous",
260
+ "is_target": false
261
+ },
262
+ {
263
+ "feature_name": "az_009",
264
+ "data_type": "continuous",
265
+ "is_target": false
266
+ },
267
+ {
268
+ "feature_name": "ba_000",
269
+ "data_type": "continuous",
270
+ "is_target": false
271
+ },
272
+ {
273
+ "feature_name": "ba_001",
274
+ "data_type": "continuous",
275
+ "is_target": false
276
+ },
277
+ {
278
+ "feature_name": "ba_002",
279
+ "data_type": "continuous",
280
+ "is_target": false
281
+ },
282
+ {
283
+ "feature_name": "ba_003",
284
+ "data_type": "continuous",
285
+ "is_target": false
286
+ },
287
+ {
288
+ "feature_name": "ba_004",
289
+ "data_type": "continuous",
290
+ "is_target": false
291
+ },
292
+ {
293
+ "feature_name": "ba_005",
294
+ "data_type": "continuous",
295
+ "is_target": false
296
+ },
297
+ {
298
+ "feature_name": "ba_006",
299
+ "data_type": "continuous",
300
+ "is_target": false
301
+ },
302
+ {
303
+ "feature_name": "ba_007",
304
+ "data_type": "continuous",
305
+ "is_target": false
306
+ },
307
+ {
308
+ "feature_name": "ba_008",
309
+ "data_type": "continuous",
310
+ "is_target": false
311
+ },
312
+ {
313
+ "feature_name": "ba_009",
314
+ "data_type": "continuous",
315
+ "is_target": false
316
+ },
317
+ {
318
+ "feature_name": "bb_000",
319
+ "data_type": "continuous",
320
+ "is_target": false
321
+ },
322
+ {
323
+ "feature_name": "bc_000",
324
+ "data_type": "continuous",
325
+ "is_target": false
326
+ },
327
+ {
328
+ "feature_name": "bd_000",
329
+ "data_type": "continuous",
330
+ "is_target": false
331
+ },
332
+ {
333
+ "feature_name": "be_000",
334
+ "data_type": "continuous",
335
+ "is_target": false
336
+ },
337
+ {
338
+ "feature_name": "bf_000",
339
+ "data_type": "continuous",
340
+ "is_target": false
341
+ },
342
+ {
343
+ "feature_name": "bg_000",
344
+ "data_type": "continuous",
345
+ "is_target": false
346
+ },
347
+ {
348
+ "feature_name": "bh_000",
349
+ "data_type": "continuous",
350
+ "is_target": false
351
+ },
352
+ {
353
+ "feature_name": "bi_000",
354
+ "data_type": "continuous",
355
+ "is_target": false
356
+ },
357
+ {
358
+ "feature_name": "bj_000",
359
+ "data_type": "continuous",
360
+ "is_target": false
361
+ },
362
+ {
363
+ "feature_name": "bk_000",
364
+ "data_type": "continuous",
365
+ "is_target": false
366
+ },
367
+ {
368
+ "feature_name": "bl_000",
369
+ "data_type": "continuous",
370
+ "is_target": false
371
+ },
372
+ {
373
+ "feature_name": "bm_000",
374
+ "data_type": "continuous",
375
+ "is_target": false
376
+ },
377
+ {
378
+ "feature_name": "bn_000",
379
+ "data_type": "continuous",
380
+ "is_target": false
381
+ },
382
+ {
383
+ "feature_name": "bo_000",
384
+ "data_type": "continuous",
385
+ "is_target": false
386
+ },
387
+ {
388
+ "feature_name": "bp_000",
389
+ "data_type": "continuous",
390
+ "is_target": false
391
+ },
392
+ {
393
+ "feature_name": "bq_000",
394
+ "data_type": "continuous",
395
+ "is_target": false
396
+ },
397
+ {
398
+ "feature_name": "br_000",
399
+ "data_type": "continuous",
400
+ "is_target": false
401
+ },
402
+ {
403
+ "feature_name": "bs_000",
404
+ "data_type": "continuous",
405
+ "is_target": false
406
+ },
407
+ {
408
+ "feature_name": "bt_000",
409
+ "data_type": "continuous",
410
+ "is_target": false
411
+ },
412
+ {
413
+ "feature_name": "bu_000",
414
+ "data_type": "continuous",
415
+ "is_target": false
416
+ },
417
+ {
418
+ "feature_name": "bv_000",
419
+ "data_type": "continuous",
420
+ "is_target": false
421
+ },
422
+ {
423
+ "feature_name": "bx_000",
424
+ "data_type": "continuous",
425
+ "is_target": false
426
+ },
427
+ {
428
+ "feature_name": "by_000",
429
+ "data_type": "continuous",
430
+ "is_target": false
431
+ },
432
+ {
433
+ "feature_name": "bz_000",
434
+ "data_type": "continuous",
435
+ "is_target": false
436
+ },
437
+ {
438
+ "feature_name": "ca_000",
439
+ "data_type": "continuous",
440
+ "is_target": false
441
+ },
442
+ {
443
+ "feature_name": "cb_000",
444
+ "data_type": "continuous",
445
+ "is_target": false
446
+ },
447
+ {
448
+ "feature_name": "cc_000",
449
+ "data_type": "continuous",
450
+ "is_target": false
451
+ },
452
+ {
453
+ "feature_name": "cd_000",
454
+ "data_type": "continuous",
455
+ "is_target": false
456
+ },
457
+ {
458
+ "feature_name": "ce_000",
459
+ "data_type": "continuous",
460
+ "is_target": false
461
+ },
462
+ {
463
+ "feature_name": "cf_000",
464
+ "data_type": "continuous",
465
+ "is_target": false
466
+ },
467
+ {
468
+ "feature_name": "cg_000",
469
+ "data_type": "continuous",
470
+ "is_target": false
471
+ },
472
+ {
473
+ "feature_name": "ch_000",
474
+ "data_type": "binary",
475
+ "is_target": false
476
+ },
477
+ {
478
+ "feature_name": "ci_000",
479
+ "data_type": "continuous",
480
+ "is_target": false
481
+ },
482
+ {
483
+ "feature_name": "cj_000",
484
+ "data_type": "continuous",
485
+ "is_target": false
486
+ },
487
+ {
488
+ "feature_name": "ck_000",
489
+ "data_type": "continuous",
490
+ "is_target": false
491
+ },
492
+ {
493
+ "feature_name": "cl_000",
494
+ "data_type": "continuous",
495
+ "is_target": false
496
+ },
497
+ {
498
+ "feature_name": "cm_000",
499
+ "data_type": "continuous",
500
+ "is_target": false
501
+ },
502
+ {
503
+ "feature_name": "cn_000",
504
+ "data_type": "continuous",
505
+ "is_target": false
506
+ },
507
+ {
508
+ "feature_name": "cn_001",
509
+ "data_type": "continuous",
510
+ "is_target": false
511
+ },
512
+ {
513
+ "feature_name": "cn_002",
514
+ "data_type": "continuous",
515
+ "is_target": false
516
+ },
517
+ {
518
+ "feature_name": "cn_003",
519
+ "data_type": "continuous",
520
+ "is_target": false
521
+ },
522
+ {
523
+ "feature_name": "cn_004",
524
+ "data_type": "continuous",
525
+ "is_target": false
526
+ },
527
+ {
528
+ "feature_name": "cn_005",
529
+ "data_type": "continuous",
530
+ "is_target": false
531
+ },
532
+ {
533
+ "feature_name": "cn_006",
534
+ "data_type": "continuous",
535
+ "is_target": false
536
+ },
537
+ {
538
+ "feature_name": "cn_007",
539
+ "data_type": "continuous",
540
+ "is_target": false
541
+ },
542
+ {
543
+ "feature_name": "cn_008",
544
+ "data_type": "continuous",
545
+ "is_target": false
546
+ },
547
+ {
548
+ "feature_name": "cn_009",
549
+ "data_type": "continuous",
550
+ "is_target": false
551
+ },
552
+ {
553
+ "feature_name": "co_000",
554
+ "data_type": "continuous",
555
+ "is_target": false
556
+ },
557
+ {
558
+ "feature_name": "cp_000",
559
+ "data_type": "continuous",
560
+ "is_target": false
561
+ },
562
+ {
563
+ "feature_name": "cq_000",
564
+ "data_type": "continuous",
565
+ "is_target": false
566
+ },
567
+ {
568
+ "feature_name": "cr_000",
569
+ "data_type": "binary",
570
+ "is_target": false
571
+ },
572
+ {
573
+ "feature_name": "cs_000",
574
+ "data_type": "continuous",
575
+ "is_target": false
576
+ },
577
+ {
578
+ "feature_name": "cs_001",
579
+ "data_type": "continuous",
580
+ "is_target": false
581
+ },
582
+ {
583
+ "feature_name": "cs_002",
584
+ "data_type": "continuous",
585
+ "is_target": false
586
+ },
587
+ {
588
+ "feature_name": "cs_003",
589
+ "data_type": "continuous",
590
+ "is_target": false
591
+ },
592
+ {
593
+ "feature_name": "cs_004",
594
+ "data_type": "continuous",
595
+ "is_target": false
596
+ },
597
+ {
598
+ "feature_name": "cs_005",
599
+ "data_type": "continuous",
600
+ "is_target": false
601
+ },
602
+ {
603
+ "feature_name": "cs_006",
604
+ "data_type": "continuous",
605
+ "is_target": false
606
+ },
607
+ {
608
+ "feature_name": "cs_007",
609
+ "data_type": "continuous",
610
+ "is_target": false
611
+ },
612
+ {
613
+ "feature_name": "cs_008",
614
+ "data_type": "continuous",
615
+ "is_target": false
616
+ },
617
+ {
618
+ "feature_name": "cs_009",
619
+ "data_type": "continuous",
620
+ "is_target": false
621
+ },
622
+ {
623
+ "feature_name": "ct_000",
624
+ "data_type": "continuous",
625
+ "is_target": false
626
+ },
627
+ {
628
+ "feature_name": "cu_000",
629
+ "data_type": "continuous",
630
+ "is_target": false
631
+ },
632
+ {
633
+ "feature_name": "cv_000",
634
+ "data_type": "continuous",
635
+ "is_target": false
636
+ },
637
+ {
638
+ "feature_name": "cx_000",
639
+ "data_type": "continuous",
640
+ "is_target": false
641
+ },
642
+ {
643
+ "feature_name": "cy_000",
644
+ "data_type": "continuous",
645
+ "is_target": false
646
+ },
647
+ {
648
+ "feature_name": "cz_000",
649
+ "data_type": "continuous",
650
+ "is_target": false
651
+ },
652
+ {
653
+ "feature_name": "da_000",
654
+ "data_type": "binary",
655
+ "is_target": false
656
+ },
657
+ {
658
+ "feature_name": "db_000",
659
+ "data_type": "continuous",
660
+ "is_target": false
661
+ },
662
+ {
663
+ "feature_name": "dc_000",
664
+ "data_type": "continuous",
665
+ "is_target": false
666
+ },
667
+ {
668
+ "feature_name": "dd_000",
669
+ "data_type": "continuous",
670
+ "is_target": false
671
+ },
672
+ {
673
+ "feature_name": "de_000",
674
+ "data_type": "continuous",
675
+ "is_target": false
676
+ },
677
+ {
678
+ "feature_name": "df_000",
679
+ "data_type": "binary",
680
+ "is_target": false
681
+ },
682
+ {
683
+ "feature_name": "dg_000",
684
+ "data_type": "continuous",
685
+ "is_target": false
686
+ },
687
+ {
688
+ "feature_name": "dh_000",
689
+ "data_type": "continuous",
690
+ "is_target": false
691
+ },
692
+ {
693
+ "feature_name": "di_000",
694
+ "data_type": "continuous",
695
+ "is_target": false
696
+ },
697
+ {
698
+ "feature_name": "dj_000",
699
+ "data_type": "binary",
700
+ "is_target": false
701
+ },
702
+ {
703
+ "feature_name": "dk_000",
704
+ "data_type": "binary",
705
+ "is_target": false
706
+ },
707
+ {
708
+ "feature_name": "dl_000",
709
+ "data_type": "binary",
710
+ "is_target": false
711
+ },
712
+ {
713
+ "feature_name": "dm_000",
714
+ "data_type": "binary",
715
+ "is_target": false
716
+ },
717
+ {
718
+ "feature_name": "dn_000",
719
+ "data_type": "continuous",
720
+ "is_target": false
721
+ },
722
+ {
723
+ "feature_name": "do_000",
724
+ "data_type": "continuous",
725
+ "is_target": false
726
+ },
727
+ {
728
+ "feature_name": "dp_000",
729
+ "data_type": "continuous",
730
+ "is_target": false
731
+ },
732
+ {
733
+ "feature_name": "dq_000",
734
+ "data_type": "continuous",
735
+ "is_target": false
736
+ },
737
+ {
738
+ "feature_name": "dr_000",
739
+ "data_type": "continuous",
740
+ "is_target": false
741
+ },
742
+ {
743
+ "feature_name": "ds_000",
744
+ "data_type": "continuous",
745
+ "is_target": false
746
+ },
747
+ {
748
+ "feature_name": "dt_000",
749
+ "data_type": "continuous",
750
+ "is_target": false
751
+ },
752
+ {
753
+ "feature_name": "du_000",
754
+ "data_type": "continuous",
755
+ "is_target": false
756
+ },
757
+ {
758
+ "feature_name": "dv_000",
759
+ "data_type": "continuous",
760
+ "is_target": false
761
+ },
762
+ {
763
+ "feature_name": "dx_000",
764
+ "data_type": "continuous",
765
+ "is_target": false
766
+ },
767
+ {
768
+ "feature_name": "dy_000",
769
+ "data_type": "continuous",
770
+ "is_target": false
771
+ },
772
+ {
773
+ "feature_name": "dz_000",
774
+ "data_type": "binary",
775
+ "is_target": false
776
+ },
777
+ {
778
+ "feature_name": "ea_000",
779
+ "data_type": "binary",
780
+ "is_target": false
781
+ },
782
+ {
783
+ "feature_name": "eb_000",
784
+ "data_type": "continuous",
785
+ "is_target": false
786
+ },
787
+ {
788
+ "feature_name": "ec_00",
789
+ "data_type": "continuous",
790
+ "is_target": false
791
+ },
792
+ {
793
+ "feature_name": "ed_000",
794
+ "data_type": "continuous",
795
+ "is_target": false
796
+ },
797
+ {
798
+ "feature_name": "ee_000",
799
+ "data_type": "continuous",
800
+ "is_target": false
801
+ },
802
+ {
803
+ "feature_name": "ee_001",
804
+ "data_type": "continuous",
805
+ "is_target": false
806
+ },
807
+ {
808
+ "feature_name": "ee_002",
809
+ "data_type": "continuous",
810
+ "is_target": false
811
+ },
812
+ {
813
+ "feature_name": "ee_003",
814
+ "data_type": "continuous",
815
+ "is_target": false
816
+ },
817
+ {
818
+ "feature_name": "ee_004",
819
+ "data_type": "continuous",
820
+ "is_target": false
821
+ },
822
+ {
823
+ "feature_name": "ee_005",
824
+ "data_type": "continuous",
825
+ "is_target": false
826
+ },
827
+ {
828
+ "feature_name": "ee_006",
829
+ "data_type": "continuous",
830
+ "is_target": false
831
+ },
832
+ {
833
+ "feature_name": "ee_007",
834
+ "data_type": "continuous",
835
+ "is_target": false
836
+ },
837
+ {
838
+ "feature_name": "ee_008",
839
+ "data_type": "continuous",
840
+ "is_target": false
841
+ },
842
+ {
843
+ "feature_name": "ee_009",
844
+ "data_type": "continuous",
845
+ "is_target": false
846
+ },
847
+ {
848
+ "feature_name": "ef_000",
849
+ "data_type": "binary",
850
+ "is_target": false
851
+ },
852
+ {
853
+ "feature_name": "eg_000",
854
+ "data_type": "binary",
855
+ "is_target": false
856
+ }
857
+ ]
syntheticFail/n18/tabddpm/tabddpm-n18-20260510_215518/staged/public/test.csv ADDED
@@ -0,0 +1,3 @@
 
 
 
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:f3ab5b0f41b5a22ace2c4304bf3b9c8cb3f0ab8d352bdc33f8ff631429bc9c85
3
+ size 7731470
syntheticFail/n18/tabddpm/tabddpm-n18-20260510_215518/staged/public/train.csv ADDED
@@ -0,0 +1,3 @@
 
 
 
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:e4f62d3011246e39610effe2bc2bf195b676554e12e24ba0fb27a112349c1ba6
3
+ size 61780661
syntheticFail/n18/tabddpm/tabddpm-n18-20260510_215518/staged/public/val.csv ADDED
@@ -0,0 +1,3 @@
 
 
 
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:596e7f65c18adcf2980f5fd952efc2bb45f10d968c1dbb1348839699a52adcf5
3
+ size 7731240
syntheticFail/n18/tabddpm/tabddpm-n18-20260510_215518/staged/tabddpm/adapter_report.json ADDED
@@ -0,0 +1,7 @@
 
 
 
 
 
 
 
 
1
+ {
2
+ "adapter_ready_status": "pass",
3
+ "adapter_fail_reason_code": null,
4
+ "adapter_fail_detail": null,
5
+ "adapter_transforms_applied": [],
6
+ "model_input_manifest": "/data/jialinzhang/SynthesizePipeline-server/output-Benchmark-trainonly-v1/n18/tabddpm/tabddpm-n18-20260510_215518/staged/tabddpm/model_input_manifest.json"
7
+ }
syntheticFail/n18/tabddpm/tabddpm-n18-20260510_215518/staged/tabddpm/adapter_transforms_applied.json ADDED
@@ -0,0 +1 @@
 
 
1
+ []
syntheticFail/n18/tabddpm/tabddpm-n18-20260510_215518/staged/tabddpm/model_input_manifest.json ADDED
@@ -0,0 +1,3933 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "dataset_id": "n18",
3
+ "model": "tabddpm",
4
+ "target_column": "class",
5
+ "task_type": "classification",
6
+ "column_schema": [
7
+ {
8
+ "name": "class",
9
+ "role": "target",
10
+ "semantic_type": "categorical",
11
+ "nullable": false,
12
+ "missing_tokens": [],
13
+ "parse_format": null,
14
+ "impute_strategy": "mode",
15
+ "profile_stats": {
16
+ "missing_rate": 0.0,
17
+ "unique_count": 2,
18
+ "unique_ratio": 3.3e-05,
19
+ "example_values": [
20
+ "neg",
21
+ "pos"
22
+ ]
23
+ }
24
+ },
25
+ {
26
+ "name": "aa_000",
27
+ "role": "feature",
28
+ "semantic_type": "numeric",
29
+ "nullable": false,
30
+ "missing_tokens": [],
31
+ "parse_format": null,
32
+ "impute_strategy": "median",
33
+ "profile_stats": {
34
+ "missing_rate": 0.0,
35
+ "unique_count": 20000,
36
+ "unique_ratio": 0.328947,
37
+ "example_values": [
38
+ "1656",
39
+ "118600",
40
+ "130",
41
+ "37016",
42
+ "32930"
43
+ ]
44
+ }
45
+ },
46
+ {
47
+ "name": "ab_000",
48
+ "role": "feature",
49
+ "semantic_type": "numeric",
50
+ "nullable": true,
51
+ "missing_tokens": [
52
+ "na"
53
+ ],
54
+ "parse_format": null,
55
+ "impute_strategy": "median",
56
+ "profile_stats": {
57
+ "missing_rate": 0.772253,
58
+ "unique_count": 30,
59
+ "unique_ratio": 0.002167,
60
+ "example_values": [
61
+ "0",
62
+ "2",
63
+ "4",
64
+ "58",
65
+ "18"
66
+ ]
67
+ }
68
+ },
69
+ {
70
+ "name": "ac_000",
71
+ "role": "feature",
72
+ "semantic_type": "numeric",
73
+ "nullable": true,
74
+ "missing_tokens": [
75
+ "na"
76
+ ],
77
+ "parse_format": null,
78
+ "impute_strategy": "median",
79
+ "profile_stats": {
80
+ "missing_rate": 0.055691,
81
+ "unique_count": 2095,
82
+ "unique_ratio": 0.036489,
83
+ "example_values": [
84
+ "126",
85
+ "0",
86
+ "76",
87
+ "1204",
88
+ "2130706432"
89
+ ]
90
+ }
91
+ },
92
+ {
93
+ "name": "ad_000",
94
+ "role": "feature",
95
+ "semantic_type": "numeric",
96
+ "nullable": true,
97
+ "missing_tokens": [
98
+ "na"
99
+ ],
100
+ "parse_format": null,
101
+ "impute_strategy": "median",
102
+ "profile_stats": {
103
+ "missing_rate": 0.246727,
104
+ "unique_count": 1897,
105
+ "unique_ratio": 0.04142,
106
+ "example_values": [
107
+ "118",
108
+ "68",
109
+ "952",
110
+ "1484",
111
+ "24"
112
+ ]
113
+ }
114
+ },
115
+ {
116
+ "name": "ae_000",
117
+ "role": "feature",
118
+ "semantic_type": "numeric",
119
+ "nullable": true,
120
+ "missing_tokens": [
121
+ "na"
122
+ ],
123
+ "parse_format": null,
124
+ "impute_strategy": "median",
125
+ "profile_stats": {
126
+ "missing_rate": 0.041727,
127
+ "unique_count": 324,
128
+ "unique_ratio": 0.005561,
129
+ "example_values": [
130
+ "0",
131
+ "120",
132
+ "2",
133
+ "58",
134
+ "74"
135
+ ]
136
+ }
137
+ },
138
+ {
139
+ "name": "af_000",
140
+ "role": "feature",
141
+ "semantic_type": "numeric",
142
+ "nullable": true,
143
+ "missing_tokens": [
144
+ "na"
145
+ ],
146
+ "parse_format": null,
147
+ "impute_strategy": "median",
148
+ "profile_stats": {
149
+ "missing_rate": 0.041727,
150
+ "unique_count": 418,
151
+ "unique_ratio": 0.007174,
152
+ "example_values": [
153
+ "0",
154
+ "214",
155
+ "2",
156
+ "98",
157
+ "608"
158
+ ]
159
+ }
160
+ },
161
+ {
162
+ "name": "ag_000",
163
+ "role": "feature",
164
+ "semantic_type": "boolean",
165
+ "nullable": true,
166
+ "missing_tokens": [
167
+ "na"
168
+ ],
169
+ "parse_format": null,
170
+ "impute_strategy": "mode",
171
+ "profile_stats": {
172
+ "missing_rate": 0.011382,
173
+ "unique_count": 166,
174
+ "unique_ratio": 0.002762,
175
+ "example_values": [
176
+ "0",
177
+ "228",
178
+ "318",
179
+ "6554",
180
+ "10"
181
+ ]
182
+ }
183
+ },
184
+ {
185
+ "name": "ag_001",
186
+ "role": "feature",
187
+ "semantic_type": "boolean",
188
+ "nullable": true,
189
+ "missing_tokens": [
190
+ "na"
191
+ ],
192
+ "parse_format": null,
193
+ "impute_strategy": "mode",
194
+ "profile_stats": {
195
+ "missing_rate": 0.011382,
196
+ "unique_count": 659,
197
+ "unique_ratio": 0.010964,
198
+ "example_values": [
199
+ "0",
200
+ "2276",
201
+ "102",
202
+ "32",
203
+ "5128"
204
+ ]
205
+ }
206
+ },
207
+ {
208
+ "name": "ag_002",
209
+ "role": "feature",
210
+ "semantic_type": "numeric",
211
+ "nullable": true,
212
+ "missing_tokens": [
213
+ "na"
214
+ ],
215
+ "parse_format": null,
216
+ "impute_strategy": "median",
217
+ "profile_stats": {
218
+ "missing_rate": 0.011382,
219
+ "unique_count": 2456,
220
+ "unique_ratio": 0.04086,
221
+ "example_values": [
222
+ "0",
223
+ "108",
224
+ "38",
225
+ "5274",
226
+ "292"
227
+ ]
228
+ }
229
+ },
230
+ {
231
+ "name": "ag_003",
232
+ "role": "feature",
233
+ "semantic_type": "numeric",
234
+ "nullable": true,
235
+ "missing_tokens": [
236
+ "na"
237
+ ],
238
+ "parse_format": null,
239
+ "impute_strategy": "median",
240
+ "profile_stats": {
241
+ "missing_rate": 0.011382,
242
+ "unique_count": 7967,
243
+ "unique_ratio": 0.132545,
244
+ "example_values": [
245
+ "0",
246
+ "8608",
247
+ "4038",
248
+ "2450",
249
+ "548"
250
+ ]
251
+ }
252
+ },
253
+ {
254
+ "name": "ag_004",
255
+ "role": "feature",
256
+ "semantic_type": "numeric",
257
+ "nullable": true,
258
+ "missing_tokens": [
259
+ "na"
260
+ ],
261
+ "parse_format": null,
262
+ "impute_strategy": "median",
263
+ "profile_stats": {
264
+ "missing_rate": 0.011382,
265
+ "unique_count": 20000,
266
+ "unique_ratio": 0.332734,
267
+ "example_values": [
268
+ "98",
269
+ "2346",
270
+ "16590",
271
+ "14782",
272
+ "204"
273
+ ]
274
+ }
275
+ },
276
+ {
277
+ "name": "ag_005",
278
+ "role": "feature",
279
+ "semantic_type": "numeric",
280
+ "nullable": true,
281
+ "missing_tokens": [
282
+ "na"
283
+ ],
284
+ "parse_format": null,
285
+ "impute_strategy": "median",
286
+ "profile_stats": {
287
+ "missing_rate": 0.011382,
288
+ "unique_count": 20000,
289
+ "unique_ratio": 0.332734,
290
+ "example_values": [
291
+ "54",
292
+ "853922",
293
+ "7546",
294
+ "701688",
295
+ "79236"
296
+ ]
297
+ }
298
+ },
299
+ {
300
+ "name": "ag_006",
301
+ "role": "feature",
302
+ "semantic_type": "numeric",
303
+ "nullable": true,
304
+ "missing_tokens": [
305
+ "na"
306
+ ],
307
+ "parse_format": null,
308
+ "impute_strategy": "median",
309
+ "profile_stats": {
310
+ "missing_rate": 0.011382,
311
+ "unique_count": 20000,
312
+ "unique_ratio": 0.332734,
313
+ "example_values": [
314
+ "90380",
315
+ "4077182",
316
+ "2252",
317
+ "1212560",
318
+ "1555662"
319
+ ]
320
+ }
321
+ },
322
+ {
323
+ "name": "ag_007",
324
+ "role": "feature",
325
+ "semantic_type": "numeric",
326
+ "nullable": true,
327
+ "missing_tokens": [
328
+ "na"
329
+ ],
330
+ "parse_format": null,
331
+ "impute_strategy": "median",
332
+ "profile_stats": {
333
+ "missing_rate": 0.011382,
334
+ "unique_count": 20000,
335
+ "unique_ratio": 0.332734,
336
+ "example_values": [
337
+ "7952",
338
+ "940762",
339
+ "0",
340
+ "330356",
341
+ "939740"
342
+ ]
343
+ }
344
+ },
345
+ {
346
+ "name": "ag_008",
347
+ "role": "feature",
348
+ "semantic_type": "numeric",
349
+ "nullable": true,
350
+ "missing_tokens": [
351
+ "na"
352
+ ],
353
+ "parse_format": null,
354
+ "impute_strategy": "median",
355
+ "profile_stats": {
356
+ "missing_rate": 0.011382,
357
+ "unique_count": 19086,
358
+ "unique_ratio": 0.317528,
359
+ "example_values": [
360
+ "0",
361
+ "19120",
362
+ "8670",
363
+ "44210",
364
+ "23162"
365
+ ]
366
+ }
367
+ },
368
+ {
369
+ "name": "ag_009",
370
+ "role": "feature",
371
+ "semantic_type": "numeric",
372
+ "nullable": true,
373
+ "missing_tokens": [
374
+ "na"
375
+ ],
376
+ "parse_format": null,
377
+ "impute_strategy": "median",
378
+ "profile_stats": {
379
+ "missing_rate": 0.011382,
380
+ "unique_count": 5398,
381
+ "unique_ratio": 0.089805,
382
+ "example_values": [
383
+ "0",
384
+ "316",
385
+ "1758",
386
+ "576",
387
+ "552"
388
+ ]
389
+ }
390
+ },
391
+ {
392
+ "name": "ah_000",
393
+ "role": "feature",
394
+ "semantic_type": "numeric",
395
+ "nullable": true,
396
+ "missing_tokens": [
397
+ "na"
398
+ ],
399
+ "parse_format": null,
400
+ "impute_strategy": "median",
401
+ "profile_stats": {
402
+ "missing_rate": 0.010559,
403
+ "unique_count": 20000,
404
+ "unique_ratio": 0.332458,
405
+ "example_values": [
406
+ "36080",
407
+ "3165022",
408
+ "10518",
409
+ "1060220",
410
+ "1167164"
411
+ ]
412
+ }
413
+ },
414
+ {
415
+ "name": "ai_000",
416
+ "role": "feature",
417
+ "semantic_type": "numeric",
418
+ "nullable": true,
419
+ "missing_tokens": [
420
+ "na"
421
+ ],
422
+ "parse_format": null,
423
+ "impute_strategy": "median",
424
+ "profile_stats": {
425
+ "missing_rate": 0.01023,
426
+ "unique_count": 4180,
427
+ "unique_ratio": 0.069461,
428
+ "example_values": [
429
+ "0",
430
+ "918",
431
+ "3658",
432
+ "10814",
433
+ "2628"
434
+ ]
435
+ }
436
+ },
437
+ {
438
+ "name": "aj_000",
439
+ "role": "feature",
440
+ "semantic_type": "numeric",
441
+ "nullable": true,
442
+ "missing_tokens": [
443
+ "na"
444
+ ],
445
+ "parse_format": null,
446
+ "impute_strategy": "median",
447
+ "profile_stats": {
448
+ "missing_rate": 0.01023,
449
+ "unique_count": 913,
450
+ "unique_ratio": 0.015172,
451
+ "example_values": [
452
+ "0",
453
+ "114",
454
+ "146",
455
+ "58",
456
+ "70"
457
+ ]
458
+ }
459
+ },
460
+ {
461
+ "name": "ak_000",
462
+ "role": "feature",
463
+ "semantic_type": "boolean",
464
+ "nullable": true,
465
+ "missing_tokens": [
466
+ "na"
467
+ ],
468
+ "parse_format": null,
469
+ "impute_strategy": "mode",
470
+ "profile_stats": {
471
+ "missing_rate": 0.072632,
472
+ "unique_count": 169,
473
+ "unique_ratio": 0.002997,
474
+ "example_values": [
475
+ "0",
476
+ "1840",
477
+ "142646",
478
+ "1124",
479
+ "2130"
480
+ ]
481
+ }
482
+ },
483
+ {
484
+ "name": "al_000",
485
+ "role": "feature",
486
+ "semantic_type": "numeric",
487
+ "nullable": true,
488
+ "missing_tokens": [
489
+ "na"
490
+ ],
491
+ "parse_format": null,
492
+ "impute_strategy": "median",
493
+ "profile_stats": {
494
+ "missing_rate": 0.010526,
495
+ "unique_count": 9127,
496
+ "unique_ratio": 0.151712,
497
+ "example_values": [
498
+ "0",
499
+ "5610",
500
+ "2",
501
+ "5636",
502
+ "2068"
503
+ ]
504
+ }
505
+ },
506
+ {
507
+ "name": "am_0",
508
+ "role": "feature",
509
+ "semantic_type": "numeric",
510
+ "nullable": true,
511
+ "missing_tokens": [
512
+ "na"
513
+ ],
514
+ "parse_format": null,
515
+ "impute_strategy": "median",
516
+ "profile_stats": {
517
+ "missing_rate": 0.01023,
518
+ "unique_count": 10700,
519
+ "unique_ratio": 0.177806,
520
+ "example_values": [
521
+ "0",
522
+ "10568",
523
+ "112",
524
+ "8558",
525
+ "3108"
526
+ ]
527
+ }
528
+ },
529
+ {
530
+ "name": "an_000",
531
+ "role": "feature",
532
+ "semantic_type": "numeric",
533
+ "nullable": true,
534
+ "missing_tokens": [
535
+ "na"
536
+ ],
537
+ "parse_format": null,
538
+ "impute_strategy": "median",
539
+ "profile_stats": {
540
+ "missing_rate": 0.010526,
541
+ "unique_count": 20000,
542
+ "unique_ratio": 0.332447,
543
+ "example_values": [
544
+ "89692",
545
+ "5651638",
546
+ "27644",
547
+ "2094250",
548
+ "2398938"
549
+ ]
550
+ }
551
+ },
552
+ {
553
+ "name": "ao_000",
554
+ "role": "feature",
555
+ "semantic_type": "numeric",
556
+ "nullable": true,
557
+ "missing_tokens": [
558
+ "na"
559
+ ],
560
+ "parse_format": null,
561
+ "impute_strategy": "median",
562
+ "profile_stats": {
563
+ "missing_rate": 0.009622,
564
+ "unique_count": 20000,
565
+ "unique_ratio": 0.332143,
566
+ "example_values": [
567
+ "79230",
568
+ "5400370",
569
+ "22286",
570
+ "1841978",
571
+ "2056840"
572
+ ]
573
+ }
574
+ },
575
+ {
576
+ "name": "ap_000",
577
+ "role": "feature",
578
+ "semantic_type": "numeric",
579
+ "nullable": true,
580
+ "missing_tokens": [
581
+ "na"
582
+ ],
583
+ "parse_format": null,
584
+ "impute_strategy": "median",
585
+ "profile_stats": {
586
+ "missing_rate": 0.010526,
587
+ "unique_count": 20000,
588
+ "unique_ratio": 0.332447,
589
+ "example_values": [
590
+ "15174",
591
+ "401448",
592
+ "28834",
593
+ "827808",
594
+ "632288"
595
+ ]
596
+ }
597
+ },
598
+ {
599
+ "name": "aq_000",
600
+ "role": "feature",
601
+ "semantic_type": "numeric",
602
+ "nullable": true,
603
+ "missing_tokens": [
604
+ "na"
605
+ ],
606
+ "parse_format": null,
607
+ "impute_strategy": "median",
608
+ "profile_stats": {
609
+ "missing_rate": 0.009622,
610
+ "unique_count": 20000,
611
+ "unique_ratio": 0.332143,
612
+ "example_values": [
613
+ "7856",
614
+ "174492",
615
+ "4192",
616
+ "211098",
617
+ "281914"
618
+ ]
619
+ }
620
+ },
621
+ {
622
+ "name": "ar_000",
623
+ "role": "feature",
624
+ "semantic_type": "numeric",
625
+ "nullable": true,
626
+ "missing_tokens": [
627
+ "na"
628
+ ],
629
+ "parse_format": null,
630
+ "impute_strategy": "median",
631
+ "profile_stats": {
632
+ "missing_rate": 0.045691,
633
+ "unique_count": 66,
634
+ "unique_ratio": 0.001137,
635
+ "example_values": [
636
+ "0",
637
+ "6",
638
+ "4",
639
+ "2",
640
+ "8"
641
+ ]
642
+ }
643
+ },
644
+ {
645
+ "name": "as_000",
646
+ "role": "feature",
647
+ "semantic_type": "boolean",
648
+ "nullable": true,
649
+ "missing_tokens": [
650
+ "na"
651
+ ],
652
+ "parse_format": null,
653
+ "impute_strategy": "mode",
654
+ "profile_stats": {
655
+ "missing_rate": 0.01023,
656
+ "unique_count": 23,
657
+ "unique_ratio": 0.000382,
658
+ "example_values": [
659
+ "0",
660
+ "1150508",
661
+ "357260",
662
+ "1246190",
663
+ "13752"
664
+ ]
665
+ }
666
+ },
667
+ {
668
+ "name": "at_000",
669
+ "role": "feature",
670
+ "semantic_type": "numeric",
671
+ "nullable": true,
672
+ "missing_tokens": [
673
+ "na"
674
+ ],
675
+ "parse_format": null,
676
+ "impute_strategy": "median",
677
+ "profile_stats": {
678
+ "missing_rate": 0.01023,
679
+ "unique_count": 3514,
680
+ "unique_ratio": 0.058393,
681
+ "example_values": [
682
+ "0",
683
+ "2202",
684
+ "26602",
685
+ "2968",
686
+ "2656"
687
+ ]
688
+ }
689
+ },
690
+ {
691
+ "name": "au_000",
692
+ "role": "feature",
693
+ "semantic_type": "boolean",
694
+ "nullable": true,
695
+ "missing_tokens": [
696
+ "na"
697
+ ],
698
+ "parse_format": null,
699
+ "impute_strategy": "mode",
700
+ "profile_stats": {
701
+ "missing_rate": 0.01023,
702
+ "unique_count": 55,
703
+ "unique_ratio": 0.000914,
704
+ "example_values": [
705
+ "0",
706
+ "748658",
707
+ "729144",
708
+ "588396",
709
+ "1248"
710
+ ]
711
+ }
712
+ },
713
+ {
714
+ "name": "av_000",
715
+ "role": "feature",
716
+ "semantic_type": "numeric",
717
+ "nullable": true,
718
+ "missing_tokens": [
719
+ "na"
720
+ ],
721
+ "parse_format": null,
722
+ "impute_strategy": "median",
723
+ "profile_stats": {
724
+ "missing_rate": 0.041727,
725
+ "unique_count": 3875,
726
+ "unique_ratio": 0.066509,
727
+ "example_values": [
728
+ "234",
729
+ "0",
730
+ "130",
731
+ "456",
732
+ "5754"
733
+ ]
734
+ }
735
+ },
736
+ {
737
+ "name": "ax_000",
738
+ "role": "feature",
739
+ "semantic_type": "numeric",
740
+ "nullable": true,
741
+ "missing_tokens": [
742
+ "na"
743
+ ],
744
+ "parse_format": null,
745
+ "impute_strategy": "median",
746
+ "profile_stats": {
747
+ "missing_rate": 0.041743,
748
+ "unique_count": 2244,
749
+ "unique_ratio": 0.038516,
750
+ "example_values": [
751
+ "66",
752
+ "0",
753
+ "138",
754
+ "1918",
755
+ "896"
756
+ ]
757
+ }
758
+ },
759
+ {
760
+ "name": "ay_000",
761
+ "role": "feature",
762
+ "semantic_type": "boolean",
763
+ "nullable": true,
764
+ "missing_tokens": [
765
+ "na"
766
+ ],
767
+ "parse_format": null,
768
+ "impute_strategy": "mode",
769
+ "profile_stats": {
770
+ "missing_rate": 0.011431,
771
+ "unique_count": 475,
772
+ "unique_ratio": 0.007903,
773
+ "example_values": [
774
+ "0",
775
+ "40584",
776
+ "38258",
777
+ "24630",
778
+ "32330"
779
+ ]
780
+ }
781
+ },
782
+ {
783
+ "name": "ay_001",
784
+ "role": "feature",
785
+ "semantic_type": "boolean",
786
+ "nullable": true,
787
+ "missing_tokens": [
788
+ "na"
789
+ ],
790
+ "parse_format": null,
791
+ "impute_strategy": "mode",
792
+ "profile_stats": {
793
+ "missing_rate": 0.011431,
794
+ "unique_count": 925,
795
+ "unique_ratio": 0.01539,
796
+ "example_values": [
797
+ "0",
798
+ "958",
799
+ "4894",
800
+ "17568",
801
+ "18570"
802
+ ]
803
+ }
804
+ },
805
+ {
806
+ "name": "ay_002",
807
+ "role": "feature",
808
+ "semantic_type": "boolean",
809
+ "nullable": true,
810
+ "missing_tokens": [
811
+ "na"
812
+ ],
813
+ "parse_format": null,
814
+ "impute_strategy": "mode",
815
+ "profile_stats": {
816
+ "missing_rate": 0.011431,
817
+ "unique_count": 995,
818
+ "unique_ratio": 0.016554,
819
+ "example_values": [
820
+ "0",
821
+ "4798",
822
+ "8256",
823
+ "15402",
824
+ "11316"
825
+ ]
826
+ }
827
+ },
828
+ {
829
+ "name": "ay_003",
830
+ "role": "feature",
831
+ "semantic_type": "numeric",
832
+ "nullable": true,
833
+ "missing_tokens": [
834
+ "na"
835
+ ],
836
+ "parse_format": null,
837
+ "impute_strategy": "median",
838
+ "profile_stats": {
839
+ "missing_rate": 0.011431,
840
+ "unique_count": 1038,
841
+ "unique_ratio": 0.01727,
842
+ "example_values": [
843
+ "0",
844
+ "5084",
845
+ "5736",
846
+ "7764",
847
+ "22594"
848
+ ]
849
+ }
850
+ },
851
+ {
852
+ "name": "ay_004",
853
+ "role": "feature",
854
+ "semantic_type": "numeric",
855
+ "nullable": true,
856
+ "missing_tokens": [
857
+ "na"
858
+ ],
859
+ "parse_format": null,
860
+ "impute_strategy": "median",
861
+ "profile_stats": {
862
+ "missing_rate": 0.011431,
863
+ "unique_count": 1770,
864
+ "unique_ratio": 0.029448,
865
+ "example_values": [
866
+ "0",
867
+ "10492",
868
+ "13892",
869
+ "1230",
870
+ "8894"
871
+ ]
872
+ }
873
+ },
874
+ {
875
+ "name": "ay_005",
876
+ "role": "feature",
877
+ "semantic_type": "numeric",
878
+ "nullable": true,
879
+ "missing_tokens": [
880
+ "na"
881
+ ],
882
+ "parse_format": null,
883
+ "impute_strategy": "median",
884
+ "profile_stats": {
885
+ "missing_rate": 0.011431,
886
+ "unique_count": 19817,
887
+ "unique_ratio": 0.329706,
888
+ "example_values": [
889
+ "0",
890
+ "60878",
891
+ "51752",
892
+ "40934",
893
+ "32600"
894
+ ]
895
+ }
896
+ },
897
+ {
898
+ "name": "ay_006",
899
+ "role": "feature",
900
+ "semantic_type": "numeric",
901
+ "nullable": true,
902
+ "missing_tokens": [
903
+ "na"
904
+ ],
905
+ "parse_format": null,
906
+ "impute_strategy": "median",
907
+ "profile_stats": {
908
+ "missing_rate": 0.011431,
909
+ "unique_count": 20000,
910
+ "unique_ratio": 0.332751,
911
+ "example_values": [
912
+ "83150",
913
+ "2211302",
914
+ "0",
915
+ "936702",
916
+ "450836"
917
+ ]
918
+ }
919
+ },
920
+ {
921
+ "name": "ay_007",
922
+ "role": "feature",
923
+ "semantic_type": "numeric",
924
+ "nullable": true,
925
+ "missing_tokens": [
926
+ "na"
927
+ ],
928
+ "parse_format": null,
929
+ "impute_strategy": "median",
930
+ "profile_stats": {
931
+ "missing_rate": 0.011431,
932
+ "unique_count": 20000,
933
+ "unique_ratio": 0.332751,
934
+ "example_values": [
935
+ "15332",
936
+ "3607098",
937
+ "5444",
938
+ "614794",
939
+ "1811692"
940
+ ]
941
+ }
942
+ },
943
+ {
944
+ "name": "ay_008",
945
+ "role": "feature",
946
+ "semantic_type": "numeric",
947
+ "nullable": true,
948
+ "missing_tokens": [
949
+ "na"
950
+ ],
951
+ "parse_format": null,
952
+ "impute_strategy": "median",
953
+ "profile_stats": {
954
+ "missing_rate": 0.011431,
955
+ "unique_count": 20000,
956
+ "unique_ratio": 0.332751,
957
+ "example_values": [
958
+ "2",
959
+ "14054",
960
+ "29552",
961
+ "664808",
962
+ "315906"
963
+ ]
964
+ }
965
+ },
966
+ {
967
+ "name": "ay_009",
968
+ "role": "feature",
969
+ "semantic_type": "boolean",
970
+ "nullable": true,
971
+ "missing_tokens": [
972
+ "na"
973
+ ],
974
+ "parse_format": null,
975
+ "impute_strategy": "mode",
976
+ "profile_stats": {
977
+ "missing_rate": 0.011431,
978
+ "unique_count": 457,
979
+ "unique_ratio": 0.007603,
980
+ "example_values": [
981
+ "0",
982
+ "118",
983
+ "1272",
984
+ "36954",
985
+ "5292"
986
+ ]
987
+ }
988
+ },
989
+ {
990
+ "name": "az_000",
991
+ "role": "feature",
992
+ "semantic_type": "numeric",
993
+ "nullable": true,
994
+ "missing_tokens": [
995
+ "na"
996
+ ],
997
+ "parse_format": null,
998
+ "impute_strategy": "median",
999
+ "profile_stats": {
1000
+ "missing_rate": 0.011431,
1001
+ "unique_count": 9275,
1002
+ "unique_ratio": 0.154313,
1003
+ "example_values": [
1004
+ "110",
1005
+ "16710",
1006
+ "240",
1007
+ "1184",
1008
+ "2258"
1009
+ ]
1010
+ }
1011
+ },
1012
+ {
1013
+ "name": "az_001",
1014
+ "role": "feature",
1015
+ "semantic_type": "numeric",
1016
+ "nullable": true,
1017
+ "missing_tokens": [
1018
+ "na"
1019
+ ],
1020
+ "parse_format": null,
1021
+ "impute_strategy": "median",
1022
+ "profile_stats": {
1023
+ "missing_rate": 0.011431,
1024
+ "unique_count": 7402,
1025
+ "unique_ratio": 0.123151,
1026
+ "example_values": [
1027
+ "48",
1028
+ "890",
1029
+ "18",
1030
+ "450",
1031
+ "1596"
1032
+ ]
1033
+ }
1034
+ },
1035
+ {
1036
+ "name": "az_002",
1037
+ "role": "feature",
1038
+ "semantic_type": "numeric",
1039
+ "nullable": true,
1040
+ "missing_tokens": [
1041
+ "na"
1042
+ ],
1043
+ "parse_format": null,
1044
+ "impute_strategy": "median",
1045
+ "profile_stats": {
1046
+ "missing_rate": 0.011431,
1047
+ "unique_count": 9145,
1048
+ "unique_ratio": 0.15215,
1049
+ "example_values": [
1050
+ "46",
1051
+ "1344",
1052
+ "26",
1053
+ "1590",
1054
+ "1638"
1055
+ ]
1056
+ }
1057
+ },
1058
+ {
1059
+ "name": "az_003",
1060
+ "role": "feature",
1061
+ "semantic_type": "numeric",
1062
+ "nullable": true,
1063
+ "missing_tokens": [
1064
+ "na"
1065
+ ],
1066
+ "parse_format": null,
1067
+ "impute_strategy": "median",
1068
+ "profile_stats": {
1069
+ "missing_rate": 0.011431,
1070
+ "unique_count": 20000,
1071
+ "unique_ratio": 0.332751,
1072
+ "example_values": [
1073
+ "150",
1074
+ "3706",
1075
+ "1484",
1076
+ "143218",
1077
+ "2218"
1078
+ ]
1079
+ }
1080
+ },
1081
+ {
1082
+ "name": "az_004",
1083
+ "role": "feature",
1084
+ "semantic_type": "numeric",
1085
+ "nullable": true,
1086
+ "missing_tokens": [
1087
+ "na"
1088
+ ],
1089
+ "parse_format": null,
1090
+ "impute_strategy": "median",
1091
+ "profile_stats": {
1092
+ "missing_rate": 0.011431,
1093
+ "unique_count": 20000,
1094
+ "unique_ratio": 0.332751,
1095
+ "example_values": [
1096
+ "68536",
1097
+ "2497690",
1098
+ "576",
1099
+ "1839284",
1100
+ "109860"
1101
+ ]
1102
+ }
1103
+ },
1104
+ {
1105
+ "name": "az_005",
1106
+ "role": "feature",
1107
+ "semantic_type": "numeric",
1108
+ "nullable": true,
1109
+ "missing_tokens": [
1110
+ "na"
1111
+ ],
1112
+ "parse_format": null,
1113
+ "impute_strategy": "median",
1114
+ "profile_stats": {
1115
+ "missing_rate": 0.011431,
1116
+ "unique_count": 20000,
1117
+ "unique_ratio": 0.332751,
1118
+ "example_values": [
1119
+ "29594",
1120
+ "3371368",
1121
+ "4110",
1122
+ "282298",
1123
+ "2499914"
1124
+ ]
1125
+ }
1126
+ },
1127
+ {
1128
+ "name": "az_006",
1129
+ "role": "feature",
1130
+ "semantic_type": "numeric",
1131
+ "nullable": true,
1132
+ "missing_tokens": [
1133
+ "na"
1134
+ ],
1135
+ "parse_format": null,
1136
+ "impute_strategy": "median",
1137
+ "profile_stats": {
1138
+ "missing_rate": 0.011431,
1139
+ "unique_count": 12398,
1140
+ "unique_ratio": 0.206272,
1141
+ "example_values": [
1142
+ "0",
1143
+ "1624",
1144
+ "16918",
1145
+ "32",
1146
+ "1884"
1147
+ ]
1148
+ }
1149
+ },
1150
+ {
1151
+ "name": "az_007",
1152
+ "role": "feature",
1153
+ "semantic_type": "numeric",
1154
+ "nullable": true,
1155
+ "missing_tokens": [
1156
+ "na"
1157
+ ],
1158
+ "parse_format": null,
1159
+ "impute_strategy": "median",
1160
+ "profile_stats": {
1161
+ "missing_rate": 0.011431,
1162
+ "unique_count": 3863,
1163
+ "unique_ratio": 0.064271,
1164
+ "example_values": [
1165
+ "0",
1166
+ "11492",
1167
+ "4",
1168
+ "10",
1169
+ "1760"
1170
+ ]
1171
+ }
1172
+ },
1173
+ {
1174
+ "name": "az_008",
1175
+ "role": "feature",
1176
+ "semantic_type": "numeric",
1177
+ "nullable": true,
1178
+ "missing_tokens": [
1179
+ "na"
1180
+ ],
1181
+ "parse_format": null,
1182
+ "impute_strategy": "median",
1183
+ "profile_stats": {
1184
+ "missing_rate": 0.011431,
1185
+ "unique_count": 1257,
1186
+ "unique_ratio": 0.020913,
1187
+ "example_values": [
1188
+ "0",
1189
+ "132",
1190
+ "5064",
1191
+ "2998",
1192
+ "2"
1193
+ ]
1194
+ }
1195
+ },
1196
+ {
1197
+ "name": "az_009",
1198
+ "role": "feature",
1199
+ "semantic_type": "numeric",
1200
+ "nullable": true,
1201
+ "missing_tokens": [
1202
+ "na"
1203
+ ],
1204
+ "parse_format": null,
1205
+ "impute_strategy": "median",
1206
+ "profile_stats": {
1207
+ "missing_rate": 0.011431,
1208
+ "unique_count": 342,
1209
+ "unique_ratio": 0.00569,
1210
+ "example_values": [
1211
+ "0",
1212
+ "2",
1213
+ "12",
1214
+ "5240",
1215
+ "1208"
1216
+ ]
1217
+ }
1218
+ },
1219
+ {
1220
+ "name": "ba_000",
1221
+ "role": "feature",
1222
+ "semantic_type": "numeric",
1223
+ "nullable": true,
1224
+ "missing_tokens": [
1225
+ "na"
1226
+ ],
1227
+ "parse_format": null,
1228
+ "impute_strategy": "median",
1229
+ "profile_stats": {
1230
+ "missing_rate": 0.011694,
1231
+ "unique_count": 20000,
1232
+ "unique_ratio": 0.33284,
1233
+ "example_values": [
1234
+ "43510",
1235
+ "1449660",
1236
+ "27420",
1237
+ "668112",
1238
+ "1052220"
1239
+ ]
1240
+ }
1241
+ },
1242
+ {
1243
+ "name": "ba_001",
1244
+ "role": "feature",
1245
+ "semantic_type": "numeric",
1246
+ "nullable": true,
1247
+ "missing_tokens": [
1248
+ "na"
1249
+ ],
1250
+ "parse_format": null,
1251
+ "impute_strategy": "median",
1252
+ "profile_stats": {
1253
+ "missing_rate": 0.011694,
1254
+ "unique_count": 20000,
1255
+ "unique_ratio": 0.33284,
1256
+ "example_values": [
1257
+ "35882",
1258
+ "1098754",
1259
+ "3950",
1260
+ "612642",
1261
+ "641214"
1262
+ ]
1263
+ }
1264
+ },
1265
+ {
1266
+ "name": "ba_002",
1267
+ "role": "feature",
1268
+ "semantic_type": "numeric",
1269
+ "nullable": true,
1270
+ "missing_tokens": [
1271
+ "na"
1272
+ ],
1273
+ "parse_format": null,
1274
+ "impute_strategy": "median",
1275
+ "profile_stats": {
1276
+ "missing_rate": 0.011694,
1277
+ "unique_count": 20000,
1278
+ "unique_ratio": 0.33284,
1279
+ "example_values": [
1280
+ "11484",
1281
+ "583624",
1282
+ "902",
1283
+ "323232",
1284
+ "234314"
1285
+ ]
1286
+ }
1287
+ },
1288
+ {
1289
+ "name": "ba_003",
1290
+ "role": "feature",
1291
+ "semantic_type": "numeric",
1292
+ "nullable": true,
1293
+ "missing_tokens": [
1294
+ "na"
1295
+ ],
1296
+ "parse_format": null,
1297
+ "impute_strategy": "median",
1298
+ "profile_stats": {
1299
+ "missing_rate": 0.011694,
1300
+ "unique_count": 20000,
1301
+ "unique_ratio": 0.33284,
1302
+ "example_values": [
1303
+ "4784",
1304
+ "500568",
1305
+ "594",
1306
+ "220220",
1307
+ "156236"
1308
+ ]
1309
+ }
1310
+ },
1311
+ {
1312
+ "name": "ba_004",
1313
+ "role": "feature",
1314
+ "semantic_type": "numeric",
1315
+ "nullable": true,
1316
+ "missing_tokens": [
1317
+ "na"
1318
+ ],
1319
+ "parse_format": null,
1320
+ "impute_strategy": "median",
1321
+ "profile_stats": {
1322
+ "missing_rate": 0.011694,
1323
+ "unique_count": 20000,
1324
+ "unique_ratio": 0.33284,
1325
+ "example_values": [
1326
+ "1550",
1327
+ "445980",
1328
+ "524",
1329
+ "166770",
1330
+ "107440"
1331
+ ]
1332
+ }
1333
+ },
1334
+ {
1335
+ "name": "ba_005",
1336
+ "role": "feature",
1337
+ "semantic_type": "numeric",
1338
+ "nullable": true,
1339
+ "missing_tokens": [
1340
+ "na"
1341
+ ],
1342
+ "parse_format": null,
1343
+ "impute_strategy": "median",
1344
+ "profile_stats": {
1345
+ "missing_rate": 0.011694,
1346
+ "unique_count": 20000,
1347
+ "unique_ratio": 0.33284,
1348
+ "example_values": [
1349
+ "678",
1350
+ "394140",
1351
+ "308",
1352
+ "159564",
1353
+ "80012"
1354
+ ]
1355
+ }
1356
+ },
1357
+ {
1358
+ "name": "ba_006",
1359
+ "role": "feature",
1360
+ "semantic_type": "numeric",
1361
+ "nullable": true,
1362
+ "missing_tokens": [
1363
+ "na"
1364
+ ],
1365
+ "parse_format": null,
1366
+ "impute_strategy": "median",
1367
+ "profile_stats": {
1368
+ "missing_rate": 0.011694,
1369
+ "unique_count": 20000,
1370
+ "unique_ratio": 0.33284,
1371
+ "example_values": [
1372
+ "372",
1373
+ "424290",
1374
+ "1100",
1375
+ "117506",
1376
+ "90270"
1377
+ ]
1378
+ }
1379
+ },
1380
+ {
1381
+ "name": "ba_007",
1382
+ "role": "feature",
1383
+ "semantic_type": "numeric",
1384
+ "nullable": true,
1385
+ "missing_tokens": [
1386
+ "na"
1387
+ ],
1388
+ "parse_format": null,
1389
+ "impute_strategy": "median",
1390
+ "profile_stats": {
1391
+ "missing_rate": 0.011694,
1392
+ "unique_count": 20000,
1393
+ "unique_ratio": 0.33284,
1394
+ "example_values": [
1395
+ "224",
1396
+ "801640",
1397
+ "166",
1398
+ "10",
1399
+ "257660"
1400
+ ]
1401
+ }
1402
+ },
1403
+ {
1404
+ "name": "ba_008",
1405
+ "role": "feature",
1406
+ "semantic_type": "numeric",
1407
+ "nullable": true,
1408
+ "missing_tokens": [
1409
+ "na"
1410
+ ],
1411
+ "parse_format": null,
1412
+ "impute_strategy": "median",
1413
+ "profile_stats": {
1414
+ "missing_rate": 0.011694,
1415
+ "unique_count": 11894,
1416
+ "unique_ratio": 0.19794,
1417
+ "example_values": [
1418
+ "0",
1419
+ "194672",
1420
+ "26",
1421
+ "2",
1422
+ "38636"
1423
+ ]
1424
+ }
1425
+ },
1426
+ {
1427
+ "name": "ba_009",
1428
+ "role": "feature",
1429
+ "semantic_type": "numeric",
1430
+ "nullable": true,
1431
+ "missing_tokens": [
1432
+ "na"
1433
+ ],
1434
+ "parse_format": null,
1435
+ "impute_strategy": "median",
1436
+ "profile_stats": {
1437
+ "missing_rate": 0.011694,
1438
+ "unique_count": 6840,
1439
+ "unique_ratio": 0.113831,
1440
+ "example_values": [
1441
+ "0",
1442
+ "4",
1443
+ "6",
1444
+ "3288",
1445
+ "830"
1446
+ ]
1447
+ }
1448
+ },
1449
+ {
1450
+ "name": "bb_000",
1451
+ "role": "feature",
1452
+ "semantic_type": "numeric",
1453
+ "nullable": true,
1454
+ "missing_tokens": [
1455
+ "na"
1456
+ ],
1457
+ "parse_format": null,
1458
+ "impute_strategy": "median",
1459
+ "profile_stats": {
1460
+ "missing_rate": 0.010559,
1461
+ "unique_count": 20000,
1462
+ "unique_ratio": 0.332458,
1463
+ "example_values": [
1464
+ "104890",
1465
+ "6053972",
1466
+ "62144",
1467
+ "2922442",
1468
+ "3031738"
1469
+ ]
1470
+ }
1471
+ },
1472
+ {
1473
+ "name": "bc_000",
1474
+ "role": "feature",
1475
+ "semantic_type": "numeric",
1476
+ "nullable": true,
1477
+ "missing_tokens": [
1478
+ "na"
1479
+ ],
1480
+ "parse_format": null,
1481
+ "impute_strategy": "median",
1482
+ "profile_stats": {
1483
+ "missing_rate": 0.045691,
1484
+ "unique_count": 2853,
1485
+ "unique_ratio": 0.049171,
1486
+ "example_values": [
1487
+ "4",
1488
+ "0",
1489
+ "296",
1490
+ "96",
1491
+ "22"
1492
+ ]
1493
+ }
1494
+ },
1495
+ {
1496
+ "name": "bd_000",
1497
+ "role": "feature",
1498
+ "semantic_type": "numeric",
1499
+ "nullable": true,
1500
+ "missing_tokens": [
1501
+ "na"
1502
+ ],
1503
+ "parse_format": null,
1504
+ "impute_strategy": "median",
1505
+ "profile_stats": {
1506
+ "missing_rate": 0.045724,
1507
+ "unique_count": 3604,
1508
+ "unique_ratio": 0.062117,
1509
+ "example_values": [
1510
+ "6",
1511
+ "16",
1512
+ "8",
1513
+ "876",
1514
+ "1052"
1515
+ ]
1516
+ }
1517
+ },
1518
+ {
1519
+ "name": "be_000",
1520
+ "role": "feature",
1521
+ "semantic_type": "numeric",
1522
+ "nullable": true,
1523
+ "missing_tokens": [
1524
+ "na"
1525
+ ],
1526
+ "parse_format": null,
1527
+ "impute_strategy": "median",
1528
+ "profile_stats": {
1529
+ "missing_rate": 0.04176,
1530
+ "unique_count": 4000,
1531
+ "unique_ratio": 0.068657,
1532
+ "example_values": [
1533
+ "106",
1534
+ "260",
1535
+ "8",
1536
+ "266",
1537
+ "150"
1538
+ ]
1539
+ }
1540
+ },
1541
+ {
1542
+ "name": "bf_000",
1543
+ "role": "feature",
1544
+ "semantic_type": "numeric",
1545
+ "nullable": true,
1546
+ "missing_tokens": [
1547
+ "na"
1548
+ ],
1549
+ "parse_format": null,
1550
+ "impute_strategy": "median",
1551
+ "profile_stats": {
1552
+ "missing_rate": 0.041727,
1553
+ "unique_count": 1122,
1554
+ "unique_ratio": 0.019258,
1555
+ "example_values": [
1556
+ "0",
1557
+ "190",
1558
+ "42",
1559
+ "58",
1560
+ "36"
1561
+ ]
1562
+ }
1563
+ },
1564
+ {
1565
+ "name": "bg_000",
1566
+ "role": "feature",
1567
+ "semantic_type": "numeric",
1568
+ "nullable": true,
1569
+ "missing_tokens": [
1570
+ "na"
1571
+ ],
1572
+ "parse_format": null,
1573
+ "impute_strategy": "median",
1574
+ "profile_stats": {
1575
+ "missing_rate": 0.010526,
1576
+ "unique_count": 20000,
1577
+ "unique_ratio": 0.332447,
1578
+ "example_values": [
1579
+ "36080",
1580
+ "3165022",
1581
+ "10518",
1582
+ "1060220",
1583
+ "1167164"
1584
+ ]
1585
+ }
1586
+ },
1587
+ {
1588
+ "name": "bh_000",
1589
+ "role": "feature",
1590
+ "semantic_type": "numeric",
1591
+ "nullable": true,
1592
+ "missing_tokens": [
1593
+ "na"
1594
+ ],
1595
+ "parse_format": null,
1596
+ "impute_strategy": "median",
1597
+ "profile_stats": {
1598
+ "missing_rate": 0.010526,
1599
+ "unique_count": 20000,
1600
+ "unique_ratio": 0.332447,
1601
+ "example_values": [
1602
+ "1188",
1603
+ "37482",
1604
+ "466",
1605
+ "29150",
1606
+ "40680"
1607
+ ]
1608
+ }
1609
+ },
1610
+ {
1611
+ "name": "bi_000",
1612
+ "role": "feature",
1613
+ "semantic_type": "numeric",
1614
+ "nullable": true,
1615
+ "missing_tokens": [
1616
+ "na"
1617
+ ],
1618
+ "parse_format": null,
1619
+ "impute_strategy": "median",
1620
+ "profile_stats": {
1621
+ "missing_rate": 0.009622,
1622
+ "unique_count": 20000,
1623
+ "unique_ratio": 0.332143,
1624
+ "example_values": [
1625
+ "5890",
1626
+ "168126",
1627
+ "16940",
1628
+ "693886",
1629
+ "362196"
1630
+ ]
1631
+ }
1632
+ },
1633
+ {
1634
+ "name": "bj_000",
1635
+ "role": "feature",
1636
+ "semantic_type": "numeric",
1637
+ "nullable": true,
1638
+ "missing_tokens": [
1639
+ "na"
1640
+ ],
1641
+ "parse_format": null,
1642
+ "impute_strategy": "median",
1643
+ "profile_stats": {
1644
+ "missing_rate": 0.009622,
1645
+ "unique_count": 20000,
1646
+ "unique_ratio": 0.332143,
1647
+ "example_values": [
1648
+ "9244",
1649
+ "232192",
1650
+ "11536",
1651
+ "132634",
1652
+ "268290"
1653
+ ]
1654
+ }
1655
+ },
1656
+ {
1657
+ "name": "bk_000",
1658
+ "role": "feature",
1659
+ "semantic_type": "numeric",
1660
+ "nullable": true,
1661
+ "missing_tokens": [
1662
+ "na"
1663
+ ],
1664
+ "parse_format": null,
1665
+ "impute_strategy": "median",
1666
+ "profile_stats": {
1667
+ "missing_rate": 0.384737,
1668
+ "unique_count": 13038,
1669
+ "unique_ratio": 0.348535,
1670
+ "example_values": [
1671
+ "76900",
1672
+ "285120",
1673
+ "224680",
1674
+ "132180",
1675
+ "238240"
1676
+ ]
1677
+ }
1678
+ },
1679
+ {
1680
+ "name": "bl_000",
1681
+ "role": "feature",
1682
+ "semantic_type": "numeric",
1683
+ "nullable": true,
1684
+ "missing_tokens": [
1685
+ "na"
1686
+ ],
1687
+ "parse_format": null,
1688
+ "impute_strategy": "median",
1689
+ "profile_stats": {
1690
+ "missing_rate": 0.455609,
1691
+ "unique_count": 12055,
1692
+ "unique_ratio": 0.36421,
1693
+ "example_values": [
1694
+ "59240",
1695
+ "343500",
1696
+ "255560",
1697
+ "1310700",
1698
+ "188560"
1699
+ ]
1700
+ }
1701
+ },
1702
+ {
1703
+ "name": "bm_000",
1704
+ "role": "feature",
1705
+ "semantic_type": "numeric",
1706
+ "nullable": true,
1707
+ "missing_tokens": [
1708
+ "na"
1709
+ ],
1710
+ "parse_format": null,
1711
+ "impute_strategy": "median",
1712
+ "profile_stats": {
1713
+ "missing_rate": 0.661135,
1714
+ "unique_count": 9160,
1715
+ "unique_ratio": 0.444595,
1716
+ "example_values": [
1717
+ "71160",
1718
+ "1310700",
1719
+ "237300",
1720
+ "298620",
1721
+ "200400"
1722
+ ]
1723
+ }
1724
+ },
1725
+ {
1726
+ "name": "bn_000",
1727
+ "role": "feature",
1728
+ "semantic_type": "numeric",
1729
+ "nullable": true,
1730
+ "missing_tokens": [
1731
+ "na"
1732
+ ],
1733
+ "parse_format": null,
1734
+ "impute_strategy": "median",
1735
+ "profile_stats": {
1736
+ "missing_rate": 0.734095,
1737
+ "unique_count": 7196,
1738
+ "unique_ratio": 0.445104,
1739
+ "example_values": [
1740
+ "115600",
1741
+ "1310700",
1742
+ "221260",
1743
+ "0",
1744
+ "254060"
1745
+ ]
1746
+ }
1747
+ },
1748
+ {
1749
+ "name": "bo_000",
1750
+ "role": "feature",
1751
+ "semantic_type": "numeric",
1752
+ "nullable": true,
1753
+ "missing_tokens": [
1754
+ "na"
1755
+ ],
1756
+ "parse_format": null,
1757
+ "impute_strategy": "median",
1758
+ "profile_stats": {
1759
+ "missing_rate": 0.773405,
1760
+ "unique_count": 5932,
1761
+ "unique_ratio": 0.430573,
1762
+ "example_values": [
1763
+ "1310700",
1764
+ "248360",
1765
+ "0",
1766
+ "226380",
1767
+ "166140"
1768
+ ]
1769
+ }
1770
+ },
1771
+ {
1772
+ "name": "bp_000",
1773
+ "role": "feature",
1774
+ "semantic_type": "numeric",
1775
+ "nullable": true,
1776
+ "missing_tokens": [
1777
+ "na"
1778
+ ],
1779
+ "parse_format": null,
1780
+ "impute_strategy": "median",
1781
+ "profile_stats": {
1782
+ "missing_rate": 0.796118,
1783
+ "unique_count": 5059,
1784
+ "unique_ratio": 0.408116,
1785
+ "example_values": [
1786
+ "1310700",
1787
+ "0",
1788
+ "174400",
1789
+ "389060",
1790
+ "227500"
1791
+ ]
1792
+ }
1793
+ },
1794
+ {
1795
+ "name": "bq_000",
1796
+ "role": "feature",
1797
+ "semantic_type": "numeric",
1798
+ "nullable": true,
1799
+ "missing_tokens": [
1800
+ "na"
1801
+ ],
1802
+ "parse_format": null,
1803
+ "impute_strategy": "median",
1804
+ "profile_stats": {
1805
+ "missing_rate": 0.812632,
1806
+ "unique_count": 4349,
1807
+ "unique_ratio": 0.381759,
1808
+ "example_values": [
1809
+ "1310700",
1810
+ "0",
1811
+ "177920",
1812
+ "433740",
1813
+ "279280"
1814
+ ]
1815
+ }
1816
+ },
1817
+ {
1818
+ "name": "br_000",
1819
+ "role": "feature",
1820
+ "semantic_type": "numeric",
1821
+ "nullable": true,
1822
+ "missing_tokens": [
1823
+ "na"
1824
+ ],
1825
+ "parse_format": null,
1826
+ "impute_strategy": "median",
1827
+ "profile_stats": {
1828
+ "missing_rate": 0.821743,
1829
+ "unique_count": 3929,
1830
+ "unique_ratio": 0.362521,
1831
+ "example_values": [
1832
+ "1310700",
1833
+ "0",
1834
+ "158980",
1835
+ "404300",
1836
+ "232280"
1837
+ ]
1838
+ }
1839
+ },
1840
+ {
1841
+ "name": "bs_000",
1842
+ "role": "feature",
1843
+ "semantic_type": "numeric",
1844
+ "nullable": true,
1845
+ "missing_tokens": [
1846
+ "na"
1847
+ ],
1848
+ "parse_format": null,
1849
+ "impute_strategy": "median",
1850
+ "profile_stats": {
1851
+ "missing_rate": 0.011974,
1852
+ "unique_count": 12890,
1853
+ "unique_ratio": 0.214576,
1854
+ "example_values": [
1855
+ "14900",
1856
+ "69400",
1857
+ "28200",
1858
+ "195000",
1859
+ "146640"
1860
+ ]
1861
+ }
1862
+ },
1863
+ {
1864
+ "name": "bt_000",
1865
+ "role": "feature",
1866
+ "semantic_type": "numeric",
1867
+ "nullable": true,
1868
+ "missing_tokens": [
1869
+ "na"
1870
+ ],
1871
+ "parse_format": null,
1872
+ "impute_strategy": "median",
1873
+ "profile_stats": {
1874
+ "missing_rate": 0.002549,
1875
+ "unique_count": 20000,
1876
+ "unique_ratio": 0.329788,
1877
+ "example_values": [
1878
+ "1655.66",
1879
+ "118600.27",
1880
+ "129.51",
1881
+ "37015.76",
1882
+ "32929.03"
1883
+ ]
1884
+ }
1885
+ },
1886
+ {
1887
+ "name": "bu_000",
1888
+ "role": "feature",
1889
+ "semantic_type": "numeric",
1890
+ "nullable": true,
1891
+ "missing_tokens": [
1892
+ "na"
1893
+ ],
1894
+ "parse_format": null,
1895
+ "impute_strategy": "median",
1896
+ "profile_stats": {
1897
+ "missing_rate": 0.011365,
1898
+ "unique_count": 20000,
1899
+ "unique_ratio": 0.332729,
1900
+ "example_values": [
1901
+ "104890",
1902
+ "6053972",
1903
+ "62144",
1904
+ "2922442",
1905
+ "3031738"
1906
+ ]
1907
+ }
1908
+ },
1909
+ {
1910
+ "name": "bv_000",
1911
+ "role": "feature",
1912
+ "semantic_type": "numeric",
1913
+ "nullable": true,
1914
+ "missing_tokens": [
1915
+ "na"
1916
+ ],
1917
+ "parse_format": null,
1918
+ "impute_strategy": "median",
1919
+ "profile_stats": {
1920
+ "missing_rate": 0.011365,
1921
+ "unique_count": 20000,
1922
+ "unique_ratio": 0.332729,
1923
+ "example_values": [
1924
+ "104890",
1925
+ "6053972",
1926
+ "62144",
1927
+ "2922442",
1928
+ "3031738"
1929
+ ]
1930
+ }
1931
+ },
1932
+ {
1933
+ "name": "bx_000",
1934
+ "role": "feature",
1935
+ "semantic_type": "numeric",
1936
+ "nullable": true,
1937
+ "missing_tokens": [
1938
+ "na"
1939
+ ],
1940
+ "parse_format": null,
1941
+ "impute_strategy": "median",
1942
+ "profile_stats": {
1943
+ "missing_rate": 0.052845,
1944
+ "unique_count": 20000,
1945
+ "unique_ratio": 0.347301,
1946
+ "example_values": [
1947
+ "106798",
1948
+ "6017402",
1949
+ "63248",
1950
+ "2922030",
1951
+ "3026214"
1952
+ ]
1953
+ }
1954
+ },
1955
+ {
1956
+ "name": "by_000",
1957
+ "role": "feature",
1958
+ "semantic_type": "numeric",
1959
+ "nullable": true,
1960
+ "missing_tokens": [
1961
+ "na"
1962
+ ],
1963
+ "parse_format": null,
1964
+ "impute_strategy": "median",
1965
+ "profile_stats": {
1966
+ "missing_rate": 0.00778,
1967
+ "unique_count": 20000,
1968
+ "unique_ratio": 0.331527,
1969
+ "example_values": [
1970
+ "392",
1971
+ "35561.0",
1972
+ "120",
1973
+ "13359.0",
1974
+ "15622"
1975
+ ]
1976
+ }
1977
+ },
1978
+ {
1979
+ "name": "bz_000",
1980
+ "role": "feature",
1981
+ "semantic_type": "numeric",
1982
+ "nullable": true,
1983
+ "missing_tokens": [
1984
+ "na"
1985
+ ],
1986
+ "parse_format": null,
1987
+ "impute_strategy": "median",
1988
+ "profile_stats": {
1989
+ "missing_rate": 0.045674,
1990
+ "unique_count": 16718,
1991
+ "unique_ratio": 0.288127,
1992
+ "example_values": [
1993
+ "0",
1994
+ "1820080",
1995
+ "2350",
1996
+ "119886",
1997
+ "138476"
1998
+ ]
1999
+ }
2000
+ },
2001
+ {
2002
+ "name": "ca_000",
2003
+ "role": "feature",
2004
+ "semantic_type": "numeric",
2005
+ "nullable": true,
2006
+ "missing_tokens": [
2007
+ "na"
2008
+ ],
2009
+ "parse_format": null,
2010
+ "impute_strategy": "median",
2011
+ "profile_stats": {
2012
+ "missing_rate": 0.072105,
2013
+ "unique_count": 20000,
2014
+ "unique_ratio": 0.354509,
2015
+ "example_values": [
2016
+ "10292",
2017
+ "115788",
2018
+ "5744",
2019
+ "47768",
2020
+ "57472"
2021
+ ]
2022
+ }
2023
+ },
2024
+ {
2025
+ "name": "cb_000",
2026
+ "role": "feature",
2027
+ "semantic_type": "numeric",
2028
+ "nullable": true,
2029
+ "missing_tokens": [
2030
+ "na"
2031
+ ],
2032
+ "parse_format": null,
2033
+ "impute_strategy": "median",
2034
+ "profile_stats": {
2035
+ "missing_rate": 0.011974,
2036
+ "unique_count": 20000,
2037
+ "unique_ratio": 0.332934,
2038
+ "example_values": [
2039
+ "104580",
2040
+ "1205680",
2041
+ "61420",
2042
+ "498440",
2043
+ "606660"
2044
+ ]
2045
+ }
2046
+ },
2047
+ {
2048
+ "name": "cc_000",
2049
+ "role": "feature",
2050
+ "semantic_type": "numeric",
2051
+ "nullable": true,
2052
+ "missing_tokens": [
2053
+ "na"
2054
+ ],
2055
+ "parse_format": null,
2056
+ "impute_strategy": "median",
2057
+ "profile_stats": {
2058
+ "missing_rate": 0.052796,
2059
+ "unique_count": 20000,
2060
+ "unique_ratio": 0.347283,
2061
+ "example_values": [
2062
+ "98484",
2063
+ "5893332",
2064
+ "35116",
2065
+ "2268056",
2066
+ "2619368"
2067
+ ]
2068
+ }
2069
+ },
2070
+ {
2071
+ "name": "cd_000",
2072
+ "role": "feature",
2073
+ "semantic_type": "numeric",
2074
+ "nullable": true,
2075
+ "missing_tokens": [
2076
+ "na"
2077
+ ],
2078
+ "parse_format": null,
2079
+ "impute_strategy": "median",
2080
+ "profile_stats": {
2081
+ "missing_rate": 0.011217,
2082
+ "unique_count": 1,
2083
+ "unique_ratio": 1.7e-05,
2084
+ "example_values": [
2085
+ "1209600"
2086
+ ]
2087
+ }
2088
+ },
2089
+ {
2090
+ "name": "ce_000",
2091
+ "role": "feature",
2092
+ "semantic_type": "numeric",
2093
+ "nullable": true,
2094
+ "missing_tokens": [
2095
+ "na"
2096
+ ],
2097
+ "parse_format": null,
2098
+ "impute_strategy": "median",
2099
+ "profile_stats": {
2100
+ "missing_rate": 0.04176,
2101
+ "unique_count": 20000,
2102
+ "unique_ratio": 0.343283,
2103
+ "example_values": [
2104
+ "2436",
2105
+ "0",
2106
+ "1348",
2107
+ "64960",
2108
+ "99092"
2109
+ ]
2110
+ }
2111
+ },
2112
+ {
2113
+ "name": "cf_000",
2114
+ "role": "feature",
2115
+ "semantic_type": "numeric",
2116
+ "nullable": true,
2117
+ "missing_tokens": [
2118
+ "na"
2119
+ ],
2120
+ "parse_format": null,
2121
+ "impute_strategy": "median",
2122
+ "profile_stats": {
2123
+ "missing_rate": 0.246727,
2124
+ "unique_count": 528,
2125
+ "unique_ratio": 0.011529,
2126
+ "example_values": [
2127
+ "2",
2128
+ "8",
2129
+ "0",
2130
+ "4",
2131
+ "190"
2132
+ ]
2133
+ }
2134
+ },
2135
+ {
2136
+ "name": "cg_000",
2137
+ "role": "feature",
2138
+ "semantic_type": "numeric",
2139
+ "nullable": true,
2140
+ "missing_tokens": [
2141
+ "na"
2142
+ ],
2143
+ "parse_format": null,
2144
+ "impute_strategy": "median",
2145
+ "profile_stats": {
2146
+ "missing_rate": 0.246727,
2147
+ "unique_count": 666,
2148
+ "unique_ratio": 0.014542,
2149
+ "example_values": [
2150
+ "10",
2151
+ "8",
2152
+ "46",
2153
+ "70",
2154
+ "6"
2155
+ ]
2156
+ }
2157
+ },
2158
+ {
2159
+ "name": "ch_000",
2160
+ "role": "feature",
2161
+ "semantic_type": "boolean",
2162
+ "nullable": true,
2163
+ "missing_tokens": [
2164
+ "na"
2165
+ ],
2166
+ "parse_format": null,
2167
+ "impute_strategy": "mode",
2168
+ "profile_stats": {
2169
+ "missing_rate": 0.246727,
2170
+ "unique_count": 2,
2171
+ "unique_ratio": 4.4e-05,
2172
+ "example_values": [
2173
+ "0",
2174
+ "2"
2175
+ ]
2176
+ }
2177
+ },
2178
+ {
2179
+ "name": "ci_000",
2180
+ "role": "feature",
2181
+ "semantic_type": "numeric",
2182
+ "nullable": true,
2183
+ "missing_tokens": [
2184
+ "na"
2185
+ ],
2186
+ "parse_format": null,
2187
+ "impute_strategy": "median",
2188
+ "profile_stats": {
2189
+ "missing_rate": 0.005559,
2190
+ "unique_count": 20000,
2191
+ "unique_ratio": 0.330786,
2192
+ "example_values": [
2193
+ "86199.36",
2194
+ "5383493.76",
2195
+ "12072",
2196
+ "2022616.32",
2197
+ "2018493.12"
2198
+ ]
2199
+ }
2200
+ },
2201
+ {
2202
+ "name": "cj_000",
2203
+ "role": "feature",
2204
+ "semantic_type": "numeric",
2205
+ "nullable": true,
2206
+ "missing_tokens": [
2207
+ "na"
2208
+ ],
2209
+ "parse_format": null,
2210
+ "impute_strategy": "median",
2211
+ "profile_stats": {
2212
+ "missing_rate": 0.005559,
2213
+ "unique_count": 7685,
2214
+ "unique_ratio": 0.127105,
2215
+ "example_values": [
2216
+ "0",
2217
+ "2187817.92",
2218
+ "287.04",
2219
+ "36538.56",
2220
+ "7788.48"
2221
+ ]
2222
+ }
2223
+ },
2224
+ {
2225
+ "name": "ck_000",
2226
+ "role": "feature",
2227
+ "semantic_type": "numeric",
2228
+ "nullable": true,
2229
+ "missing_tokens": [
2230
+ "na"
2231
+ ],
2232
+ "parse_format": null,
2233
+ "impute_strategy": "median",
2234
+ "profile_stats": {
2235
+ "missing_rate": 0.005559,
2236
+ "unique_count": 20000,
2237
+ "unique_ratio": 0.330786,
2238
+ "example_values": [
2239
+ "12177.6",
2240
+ "489533.76",
2241
+ "20935.68",
2242
+ "244064.64",
2243
+ "598942.08"
2244
+ ]
2245
+ }
2246
+ },
2247
+ {
2248
+ "name": "cl_000",
2249
+ "role": "feature",
2250
+ "semantic_type": "numeric",
2251
+ "nullable": true,
2252
+ "missing_tokens": [
2253
+ "na"
2254
+ ],
2255
+ "parse_format": null,
2256
+ "impute_strategy": "median",
2257
+ "profile_stats": {
2258
+ "missing_rate": 0.156793,
2259
+ "unique_count": 989,
2260
+ "unique_ratio": 0.019291,
2261
+ "example_values": [
2262
+ "0",
2263
+ "2",
2264
+ "1800",
2265
+ "6",
2266
+ "10"
2267
+ ]
2268
+ }
2269
+ },
2270
+ {
2271
+ "name": "cm_000",
2272
+ "role": "feature",
2273
+ "semantic_type": "numeric",
2274
+ "nullable": true,
2275
+ "missing_tokens": [
2276
+ "na"
2277
+ ],
2278
+ "parse_format": null,
2279
+ "impute_strategy": "median",
2280
+ "profile_stats": {
2281
+ "missing_rate": 0.162845,
2282
+ "unique_count": 2141,
2283
+ "unique_ratio": 0.042064,
2284
+ "example_values": [
2285
+ "0",
2286
+ "32",
2287
+ "1006",
2288
+ "6",
2289
+ "652"
2290
+ ]
2291
+ }
2292
+ },
2293
+ {
2294
+ "name": "cn_000",
2295
+ "role": "feature",
2296
+ "semantic_type": "numeric",
2297
+ "nullable": true,
2298
+ "missing_tokens": [
2299
+ "na"
2300
+ ],
2301
+ "parse_format": null,
2302
+ "impute_strategy": "median",
2303
+ "profile_stats": {
2304
+ "missing_rate": 0.011694,
2305
+ "unique_count": 1570,
2306
+ "unique_ratio": 0.026128,
2307
+ "example_values": [
2308
+ "0",
2309
+ "3646",
2310
+ "364",
2311
+ "38904",
2312
+ "36044"
2313
+ ]
2314
+ }
2315
+ },
2316
+ {
2317
+ "name": "cn_001",
2318
+ "role": "feature",
2319
+ "semantic_type": "numeric",
2320
+ "nullable": true,
2321
+ "missing_tokens": [
2322
+ "na"
2323
+ ],
2324
+ "parse_format": null,
2325
+ "impute_strategy": "median",
2326
+ "profile_stats": {
2327
+ "missing_rate": 0.011694,
2328
+ "unique_count": 5489,
2329
+ "unique_ratio": 0.091348,
2330
+ "example_values": [
2331
+ "0",
2332
+ "6696",
2333
+ "538",
2334
+ "578",
2335
+ "3568"
2336
+ ]
2337
+ }
2338
+ },
2339
+ {
2340
+ "name": "cn_002",
2341
+ "role": "feature",
2342
+ "semantic_type": "numeric",
2343
+ "nullable": true,
2344
+ "missing_tokens": [
2345
+ "na"
2346
+ ],
2347
+ "parse_format": null,
2348
+ "impute_strategy": "median",
2349
+ "profile_stats": {
2350
+ "missing_rate": 0.011694,
2351
+ "unique_count": 14897,
2352
+ "unique_ratio": 0.247916,
2353
+ "example_values": [
2354
+ "0",
2355
+ "15704",
2356
+ "6506",
2357
+ "390",
2358
+ "63466"
2359
+ ]
2360
+ }
2361
+ },
2362
+ {
2363
+ "name": "cn_003",
2364
+ "role": "feature",
2365
+ "semantic_type": "numeric",
2366
+ "nullable": true,
2367
+ "missing_tokens": [
2368
+ "na"
2369
+ ],
2370
+ "parse_format": null,
2371
+ "impute_strategy": "median",
2372
+ "profile_stats": {
2373
+ "missing_rate": 0.011694,
2374
+ "unique_count": 20000,
2375
+ "unique_ratio": 0.33284,
2376
+ "example_values": [
2377
+ "0",
2378
+ "71316",
2379
+ "9292",
2380
+ "246136",
2381
+ "22938"
2382
+ ]
2383
+ }
2384
+ },
2385
+ {
2386
+ "name": "cn_004",
2387
+ "role": "feature",
2388
+ "semantic_type": "numeric",
2389
+ "nullable": true,
2390
+ "missing_tokens": [
2391
+ "na"
2392
+ ],
2393
+ "parse_format": null,
2394
+ "impute_strategy": "median",
2395
+ "profile_stats": {
2396
+ "missing_rate": 0.011694,
2397
+ "unique_count": 20000,
2398
+ "unique_ratio": 0.33284,
2399
+ "example_values": [
2400
+ "53668",
2401
+ "2416614",
2402
+ "1288",
2403
+ "896600",
2404
+ "364342"
2405
+ ]
2406
+ }
2407
+ },
2408
+ {
2409
+ "name": "cn_005",
2410
+ "role": "feature",
2411
+ "semantic_type": "numeric",
2412
+ "nullable": true,
2413
+ "missing_tokens": [
2414
+ "na"
2415
+ ],
2416
+ "parse_format": null,
2417
+ "impute_strategy": "median",
2418
+ "profile_stats": {
2419
+ "missing_rate": 0.011694,
2420
+ "unique_count": 20000,
2421
+ "unique_ratio": 0.33284,
2422
+ "example_values": [
2423
+ "43094",
2424
+ "2933718",
2425
+ "1724",
2426
+ "798980",
2427
+ "1485336"
2428
+ ]
2429
+ }
2430
+ },
2431
+ {
2432
+ "name": "cn_006",
2433
+ "role": "feature",
2434
+ "semantic_type": "numeric",
2435
+ "nullable": true,
2436
+ "missing_tokens": [
2437
+ "na"
2438
+ ],
2439
+ "parse_format": null,
2440
+ "impute_strategy": "median",
2441
+ "profile_stats": {
2442
+ "missing_rate": 0.011694,
2443
+ "unique_count": 20000,
2444
+ "unique_ratio": 0.33284,
2445
+ "example_values": [
2446
+ "1432",
2447
+ "420450",
2448
+ "292",
2449
+ "304872",
2450
+ "706156"
2451
+ ]
2452
+ }
2453
+ },
2454
+ {
2455
+ "name": "cn_007",
2456
+ "role": "feature",
2457
+ "semantic_type": "numeric",
2458
+ "nullable": true,
2459
+ "missing_tokens": [
2460
+ "na"
2461
+ ],
2462
+ "parse_format": null,
2463
+ "impute_strategy": "median",
2464
+ "profile_stats": {
2465
+ "missing_rate": 0.011694,
2466
+ "unique_count": 20000,
2467
+ "unique_ratio": 0.33284,
2468
+ "example_values": [
2469
+ "238",
2470
+ "43048",
2471
+ "0",
2472
+ "12792",
2473
+ "34492"
2474
+ ]
2475
+ }
2476
+ },
2477
+ {
2478
+ "name": "cn_008",
2479
+ "role": "feature",
2480
+ "semantic_type": "numeric",
2481
+ "nullable": true,
2482
+ "missing_tokens": [
2483
+ "na"
2484
+ ],
2485
+ "parse_format": null,
2486
+ "impute_strategy": "median",
2487
+ "profile_stats": {
2488
+ "missing_rate": 0.011694,
2489
+ "unique_count": 10126,
2490
+ "unique_ratio": 0.168517,
2491
+ "example_values": [
2492
+ "52",
2493
+ "7932",
2494
+ "0",
2495
+ "1966",
2496
+ "5644"
2497
+ ]
2498
+ }
2499
+ },
2500
+ {
2501
+ "name": "cn_009",
2502
+ "role": "feature",
2503
+ "semantic_type": "numeric",
2504
+ "nullable": true,
2505
+ "missing_tokens": [
2506
+ "na"
2507
+ ],
2508
+ "parse_format": null,
2509
+ "impute_strategy": "median",
2510
+ "profile_stats": {
2511
+ "missing_rate": 0.011694,
2512
+ "unique_count": 3064,
2513
+ "unique_ratio": 0.050991,
2514
+ "example_values": [
2515
+ "0",
2516
+ "254",
2517
+ "204",
2518
+ "460",
2519
+ "12"
2520
+ ]
2521
+ }
2522
+ },
2523
+ {
2524
+ "name": "co_000",
2525
+ "role": "feature",
2526
+ "semantic_type": "numeric",
2527
+ "nullable": true,
2528
+ "missing_tokens": [
2529
+ "na"
2530
+ ],
2531
+ "parse_format": null,
2532
+ "impute_strategy": "median",
2533
+ "profile_stats": {
2534
+ "missing_rate": 0.246727,
2535
+ "unique_count": 1873,
2536
+ "unique_ratio": 0.040896,
2537
+ "example_values": [
2538
+ "2",
2539
+ "100",
2540
+ "2522",
2541
+ "8",
2542
+ "882"
2543
+ ]
2544
+ }
2545
+ },
2546
+ {
2547
+ "name": "cp_000",
2548
+ "role": "feature",
2549
+ "semantic_type": "numeric",
2550
+ "nullable": true,
2551
+ "missing_tokens": [
2552
+ "na"
2553
+ ],
2554
+ "parse_format": null,
2555
+ "impute_strategy": "median",
2556
+ "profile_stats": {
2557
+ "missing_rate": 0.045691,
2558
+ "unique_count": 2328,
2559
+ "unique_ratio": 0.040123,
2560
+ "example_values": [
2561
+ "6",
2562
+ "0",
2563
+ "24",
2564
+ "230",
2565
+ "2534"
2566
+ ]
2567
+ }
2568
+ },
2569
+ {
2570
+ "name": "cq_000",
2571
+ "role": "feature",
2572
+ "semantic_type": "numeric",
2573
+ "nullable": true,
2574
+ "missing_tokens": [
2575
+ "na"
2576
+ ],
2577
+ "parse_format": null,
2578
+ "impute_strategy": "median",
2579
+ "profile_stats": {
2580
+ "missing_rate": 0.011365,
2581
+ "unique_count": 20000,
2582
+ "unique_ratio": 0.332729,
2583
+ "example_values": [
2584
+ "104890",
2585
+ "6053972",
2586
+ "62144",
2587
+ "2922442",
2588
+ "3031738"
2589
+ ]
2590
+ }
2591
+ },
2592
+ {
2593
+ "name": "cr_000",
2594
+ "role": "feature",
2595
+ "semantic_type": "boolean",
2596
+ "nullable": true,
2597
+ "missing_tokens": [
2598
+ "na"
2599
+ ],
2600
+ "parse_format": null,
2601
+ "impute_strategy": "mode",
2602
+ "profile_stats": {
2603
+ "missing_rate": 0.772253,
2604
+ "unique_count": 73,
2605
+ "unique_ratio": 0.005272,
2606
+ "example_values": [
2607
+ "0",
2608
+ "22",
2609
+ "8106",
2610
+ "30812",
2611
+ "2632"
2612
+ ]
2613
+ }
2614
+ },
2615
+ {
2616
+ "name": "cs_000",
2617
+ "role": "feature",
2618
+ "semantic_type": "numeric",
2619
+ "nullable": true,
2620
+ "missing_tokens": [
2621
+ "na"
2622
+ ],
2623
+ "parse_format": null,
2624
+ "impute_strategy": "median",
2625
+ "profile_stats": {
2626
+ "missing_rate": 0.011349,
2627
+ "unique_count": 9374,
2628
+ "unique_ratio": 0.155947,
2629
+ "example_values": [
2630
+ "210",
2631
+ "17408",
2632
+ "2228",
2633
+ "2586",
2634
+ "4430"
2635
+ ]
2636
+ }
2637
+ },
2638
+ {
2639
+ "name": "cs_001",
2640
+ "role": "feature",
2641
+ "semantic_type": "numeric",
2642
+ "nullable": true,
2643
+ "missing_tokens": [
2644
+ "na"
2645
+ ],
2646
+ "parse_format": null,
2647
+ "impute_strategy": "median",
2648
+ "profile_stats": {
2649
+ "missing_rate": 0.011349,
2650
+ "unique_count": 3405,
2651
+ "unique_ratio": 0.056646,
2652
+ "example_values": [
2653
+ "26",
2654
+ "724",
2655
+ "22",
2656
+ "322",
2657
+ "500"
2658
+ ]
2659
+ }
2660
+ },
2661
+ {
2662
+ "name": "cs_002",
2663
+ "role": "feature",
2664
+ "semantic_type": "numeric",
2665
+ "nullable": true,
2666
+ "missing_tokens": [
2667
+ "na"
2668
+ ],
2669
+ "parse_format": null,
2670
+ "impute_strategy": "median",
2671
+ "profile_stats": {
2672
+ "missing_rate": 0.011349,
2673
+ "unique_count": 20000,
2674
+ "unique_ratio": 0.332723,
2675
+ "example_values": [
2676
+ "7100",
2677
+ "2454",
2678
+ "50",
2679
+ "63980",
2680
+ "86580"
2681
+ ]
2682
+ }
2683
+ },
2684
+ {
2685
+ "name": "cs_003",
2686
+ "role": "feature",
2687
+ "semantic_type": "numeric",
2688
+ "nullable": true,
2689
+ "missing_tokens": [
2690
+ "na"
2691
+ ],
2692
+ "parse_format": null,
2693
+ "impute_strategy": "median",
2694
+ "profile_stats": {
2695
+ "missing_rate": 0.011349,
2696
+ "unique_count": 20000,
2697
+ "unique_ratio": 0.332723,
2698
+ "example_values": [
2699
+ "2268",
2700
+ "225796",
2701
+ "726",
2702
+ "102484",
2703
+ "241144"
2704
+ ]
2705
+ }
2706
+ },
2707
+ {
2708
+ "name": "cs_004",
2709
+ "role": "feature",
2710
+ "semantic_type": "numeric",
2711
+ "nullable": true,
2712
+ "missing_tokens": [
2713
+ "na"
2714
+ ],
2715
+ "parse_format": null,
2716
+ "impute_strategy": "median",
2717
+ "profile_stats": {
2718
+ "missing_rate": 0.011349,
2719
+ "unique_count": 20000,
2720
+ "unique_ratio": 0.332723,
2721
+ "example_values": [
2722
+ "1520",
2723
+ "196192",
2724
+ "3242",
2725
+ "102782",
2726
+ "137060"
2727
+ ]
2728
+ }
2729
+ },
2730
+ {
2731
+ "name": "cs_005",
2732
+ "role": "feature",
2733
+ "semantic_type": "numeric",
2734
+ "nullable": true,
2735
+ "missing_tokens": [
2736
+ "na"
2737
+ ],
2738
+ "parse_format": null,
2739
+ "impute_strategy": "median",
2740
+ "profile_stats": {
2741
+ "missing_rate": 0.011349,
2742
+ "unique_count": 20000,
2743
+ "unique_ratio": 0.332723,
2744
+ "example_values": [
2745
+ "41000",
2746
+ "1273478",
2747
+ "24804",
2748
+ "1712116",
2749
+ "1491190"
2750
+ ]
2751
+ }
2752
+ },
2753
+ {
2754
+ "name": "cs_006",
2755
+ "role": "feature",
2756
+ "semantic_type": "numeric",
2757
+ "nullable": true,
2758
+ "missing_tokens": [
2759
+ "na"
2760
+ ],
2761
+ "parse_format": null,
2762
+ "impute_strategy": "median",
2763
+ "profile_stats": {
2764
+ "missing_rate": 0.011349,
2765
+ "unique_count": 20000,
2766
+ "unique_ratio": 0.332723,
2767
+ "example_values": [
2768
+ "45554",
2769
+ "4141758",
2770
+ "3910",
2771
+ "266134",
2772
+ "639496"
2773
+ ]
2774
+ }
2775
+ },
2776
+ {
2777
+ "name": "cs_007",
2778
+ "role": "feature",
2779
+ "semantic_type": "numeric",
2780
+ "nullable": true,
2781
+ "missing_tokens": [
2782
+ "na"
2783
+ ],
2784
+ "parse_format": null,
2785
+ "impute_strategy": "median",
2786
+ "profile_stats": {
2787
+ "missing_rate": 0.011349,
2788
+ "unique_count": 17357,
2789
+ "unique_ratio": 0.288754,
2790
+ "example_values": [
2791
+ "796",
2792
+ "35486",
2793
+ "14",
2794
+ "17560",
2795
+ "18796"
2796
+ ]
2797
+ }
2798
+ },
2799
+ {
2800
+ "name": "cs_008",
2801
+ "role": "feature",
2802
+ "semantic_type": "numeric",
2803
+ "nullable": true,
2804
+ "missing_tokens": [
2805
+ "na"
2806
+ ],
2807
+ "parse_format": null,
2808
+ "impute_strategy": "median",
2809
+ "profile_stats": {
2810
+ "missing_rate": 0.011349,
2811
+ "unique_count": 777,
2812
+ "unique_ratio": 0.012926,
2813
+ "example_values": [
2814
+ "10",
2815
+ "36",
2816
+ "0",
2817
+ "92",
2818
+ "172"
2819
+ ]
2820
+ }
2821
+ },
2822
+ {
2823
+ "name": "cs_009",
2824
+ "role": "feature",
2825
+ "semantic_type": "numeric",
2826
+ "nullable": true,
2827
+ "missing_tokens": [
2828
+ "na"
2829
+ ],
2830
+ "parse_format": null,
2831
+ "impute_strategy": "median",
2832
+ "profile_stats": {
2833
+ "missing_rate": 0.011349,
2834
+ "unique_count": 62,
2835
+ "unique_ratio": 0.001031,
2836
+ "example_values": [
2837
+ "0",
2838
+ "6",
2839
+ "2",
2840
+ "4",
2841
+ "16"
2842
+ ]
2843
+ }
2844
+ },
2845
+ {
2846
+ "name": "ct_000",
2847
+ "role": "feature",
2848
+ "semantic_type": "numeric",
2849
+ "nullable": true,
2850
+ "missing_tokens": [
2851
+ "na"
2852
+ ],
2853
+ "parse_format": null,
2854
+ "impute_strategy": "median",
2855
+ "profile_stats": {
2856
+ "missing_rate": 0.23,
2857
+ "unique_count": 2629,
2858
+ "unique_ratio": 0.056156,
2859
+ "example_values": [
2860
+ "170",
2861
+ "64",
2862
+ "1086",
2863
+ "2314",
2864
+ "50"
2865
+ ]
2866
+ }
2867
+ },
2868
+ {
2869
+ "name": "cu_000",
2870
+ "role": "feature",
2871
+ "semantic_type": "numeric",
2872
+ "nullable": true,
2873
+ "missing_tokens": [
2874
+ "na"
2875
+ ],
2876
+ "parse_format": null,
2877
+ "impute_strategy": "median",
2878
+ "profile_stats": {
2879
+ "missing_rate": 0.23,
2880
+ "unique_count": 3510,
2881
+ "unique_ratio": 0.074974,
2882
+ "example_values": [
2883
+ "250",
2884
+ "204",
2885
+ "5802",
2886
+ "2174",
2887
+ "116"
2888
+ ]
2889
+ }
2890
+ },
2891
+ {
2892
+ "name": "cv_000",
2893
+ "role": "feature",
2894
+ "semantic_type": "numeric",
2895
+ "nullable": true,
2896
+ "missing_tokens": [
2897
+ "na"
2898
+ ],
2899
+ "parse_format": null,
2900
+ "impute_strategy": "median",
2901
+ "profile_stats": {
2902
+ "missing_rate": 0.23,
2903
+ "unique_count": 20000,
2904
+ "unique_ratio": 0.427204,
2905
+ "example_values": [
2906
+ "87446",
2907
+ "13252",
2908
+ "2020630",
2909
+ "1765100",
2910
+ "7728"
2911
+ ]
2912
+ }
2913
+ },
2914
+ {
2915
+ "name": "cx_000",
2916
+ "role": "feature",
2917
+ "semantic_type": "numeric",
2918
+ "nullable": true,
2919
+ "missing_tokens": [
2920
+ "na"
2921
+ ],
2922
+ "parse_format": null,
2923
+ "impute_strategy": "median",
2924
+ "profile_stats": {
2925
+ "missing_rate": 0.23,
2926
+ "unique_count": 20000,
2927
+ "unique_ratio": 0.427204,
2928
+ "example_values": [
2929
+ "35022",
2930
+ "408",
2931
+ "227550",
2932
+ "14782",
2933
+ "1044"
2934
+ ]
2935
+ }
2936
+ },
2937
+ {
2938
+ "name": "cy_000",
2939
+ "role": "feature",
2940
+ "semantic_type": "numeric",
2941
+ "nullable": true,
2942
+ "missing_tokens": [
2943
+ "na"
2944
+ ],
2945
+ "parse_format": null,
2946
+ "impute_strategy": "median",
2947
+ "profile_stats": {
2948
+ "missing_rate": 0.23,
2949
+ "unique_count": 743,
2950
+ "unique_ratio": 0.015871,
2951
+ "example_values": [
2952
+ "0",
2953
+ "384",
2954
+ "5030",
2955
+ "2930",
2956
+ "54"
2957
+ ]
2958
+ }
2959
+ },
2960
+ {
2961
+ "name": "cz_000",
2962
+ "role": "feature",
2963
+ "semantic_type": "numeric",
2964
+ "nullable": true,
2965
+ "missing_tokens": [
2966
+ "na"
2967
+ ],
2968
+ "parse_format": null,
2969
+ "impute_strategy": "median",
2970
+ "profile_stats": {
2971
+ "missing_rate": 0.23,
2972
+ "unique_count": 10768,
2973
+ "unique_ratio": 0.230007,
2974
+ "example_values": [
2975
+ "28",
2976
+ "2",
2977
+ "60784",
2978
+ "36524",
2979
+ "0"
2980
+ ]
2981
+ }
2982
+ },
2983
+ {
2984
+ "name": "da_000",
2985
+ "role": "feature",
2986
+ "semantic_type": "boolean",
2987
+ "nullable": true,
2988
+ "missing_tokens": [
2989
+ "na"
2990
+ ],
2991
+ "parse_format": null,
2992
+ "impute_strategy": "mode",
2993
+ "profile_stats": {
2994
+ "missing_rate": 0.23,
2995
+ "unique_count": 257,
2996
+ "unique_ratio": 0.00549,
2997
+ "example_values": [
2998
+ "0",
2999
+ "302",
3000
+ "308",
3001
+ "58",
3002
+ "272"
3003
+ ]
3004
+ }
3005
+ },
3006
+ {
3007
+ "name": "db_000",
3008
+ "role": "feature",
3009
+ "semantic_type": "numeric",
3010
+ "nullable": true,
3011
+ "missing_tokens": [
3012
+ "na"
3013
+ ],
3014
+ "parse_format": null,
3015
+ "impute_strategy": "median",
3016
+ "profile_stats": {
3017
+ "missing_rate": 0.23,
3018
+ "unique_count": 141,
3019
+ "unique_ratio": 0.003012,
3020
+ "example_values": [
3021
+ "18",
3022
+ "0",
3023
+ "20",
3024
+ "14",
3025
+ "34"
3026
+ ]
3027
+ }
3028
+ },
3029
+ {
3030
+ "name": "dc_000",
3031
+ "role": "feature",
3032
+ "semantic_type": "numeric",
3033
+ "nullable": true,
3034
+ "missing_tokens": [
3035
+ "na"
3036
+ ],
3037
+ "parse_format": null,
3038
+ "impute_strategy": "median",
3039
+ "profile_stats": {
3040
+ "missing_rate": 0.23,
3041
+ "unique_count": 20000,
3042
+ "unique_ratio": 0.427204,
3043
+ "example_values": [
3044
+ "87734",
3045
+ "13272",
3046
+ "2039720",
3047
+ "2079548",
3048
+ "8936"
3049
+ ]
3050
+ }
3051
+ },
3052
+ {
3053
+ "name": "dd_000",
3054
+ "role": "feature",
3055
+ "semantic_type": "numeric",
3056
+ "nullable": true,
3057
+ "missing_tokens": [
3058
+ "na"
3059
+ ],
3060
+ "parse_format": null,
3061
+ "impute_strategy": "median",
3062
+ "profile_stats": {
3063
+ "missing_rate": 0.041776,
3064
+ "unique_count": 6626,
3065
+ "unique_ratio": 0.113732,
3066
+ "example_values": [
3067
+ "128",
3068
+ "2812",
3069
+ "182",
3070
+ "1232",
3071
+ "2136"
3072
+ ]
3073
+ }
3074
+ },
3075
+ {
3076
+ "name": "de_000",
3077
+ "role": "feature",
3078
+ "semantic_type": "numeric",
3079
+ "nullable": true,
3080
+ "missing_tokens": [
3081
+ "na"
3082
+ ],
3083
+ "parse_format": null,
3084
+ "impute_strategy": "median",
3085
+ "profile_stats": {
3086
+ "missing_rate": 0.045691,
3087
+ "unique_count": 1935,
3088
+ "unique_ratio": 0.033349,
3089
+ "example_values": [
3090
+ "50",
3091
+ "270",
3092
+ "328",
3093
+ "116",
3094
+ "240"
3095
+ ]
3096
+ }
3097
+ },
3098
+ {
3099
+ "name": "df_000",
3100
+ "role": "feature",
3101
+ "semantic_type": "boolean",
3102
+ "nullable": true,
3103
+ "missing_tokens": [
3104
+ "na"
3105
+ ],
3106
+ "parse_format": null,
3107
+ "impute_strategy": "mode",
3108
+ "profile_stats": {
3109
+ "missing_rate": 0.066299,
3110
+ "unique_count": 404,
3111
+ "unique_ratio": 0.007117,
3112
+ "example_values": [
3113
+ "0",
3114
+ "40",
3115
+ "440",
3116
+ "1100",
3117
+ "2418750"
3118
+ ]
3119
+ }
3120
+ },
3121
+ {
3122
+ "name": "dg_000",
3123
+ "role": "feature",
3124
+ "semantic_type": "numeric",
3125
+ "nullable": true,
3126
+ "missing_tokens": [
3127
+ "na"
3128
+ ],
3129
+ "parse_format": null,
3130
+ "impute_strategy": "median",
3131
+ "profile_stats": {
3132
+ "missing_rate": 0.066283,
3133
+ "unique_count": 1333,
3134
+ "unique_ratio": 0.023481,
3135
+ "example_values": [
3136
+ "0",
3137
+ "1172",
3138
+ "17600",
3139
+ "10482",
3140
+ "4176232"
3141
+ ]
3142
+ }
3143
+ },
3144
+ {
3145
+ "name": "dh_000",
3146
+ "role": "feature",
3147
+ "semantic_type": "numeric",
3148
+ "nullable": true,
3149
+ "missing_tokens": [
3150
+ "na"
3151
+ ],
3152
+ "parse_format": null,
3153
+ "impute_strategy": "median",
3154
+ "profile_stats": {
3155
+ "missing_rate": 0.066299,
3156
+ "unique_count": 1059,
3157
+ "unique_ratio": 0.018655,
3158
+ "example_values": [
3159
+ "0",
3160
+ "80",
3161
+ "5510",
3162
+ "110",
3163
+ "160"
3164
+ ]
3165
+ }
3166
+ },
3167
+ {
3168
+ "name": "di_000",
3169
+ "role": "feature",
3170
+ "semantic_type": "numeric",
3171
+ "nullable": true,
3172
+ "missing_tokens": [
3173
+ "na"
3174
+ ],
3175
+ "parse_format": null,
3176
+ "impute_strategy": "median",
3177
+ "profile_stats": {
3178
+ "missing_rate": 0.066283,
3179
+ "unique_count": 5674,
3180
+ "unique_ratio": 0.099947,
3181
+ "example_values": [
3182
+ "0",
3183
+ "286",
3184
+ "36630",
3185
+ "7796",
3186
+ "66"
3187
+ ]
3188
+ }
3189
+ },
3190
+ {
3191
+ "name": "dj_000",
3192
+ "role": "feature",
3193
+ "semantic_type": "boolean",
3194
+ "nullable": true,
3195
+ "missing_tokens": [
3196
+ "na"
3197
+ ],
3198
+ "parse_format": null,
3199
+ "impute_strategy": "mode",
3200
+ "profile_stats": {
3201
+ "missing_rate": 0.066283,
3202
+ "unique_count": 72,
3203
+ "unique_ratio": 0.001268,
3204
+ "example_values": [
3205
+ "0",
3206
+ "40",
3207
+ "260",
3208
+ "10",
3209
+ "200"
3210
+ ]
3211
+ }
3212
+ },
3213
+ {
3214
+ "name": "dk_000",
3215
+ "role": "feature",
3216
+ "semantic_type": "boolean",
3217
+ "nullable": true,
3218
+ "missing_tokens": [
3219
+ "na"
3220
+ ],
3221
+ "parse_format": null,
3222
+ "impute_strategy": "mode",
3223
+ "profile_stats": {
3224
+ "missing_rate": 0.066283,
3225
+ "unique_count": 267,
3226
+ "unique_ratio": 0.004703,
3227
+ "example_values": [
3228
+ "0",
3229
+ "5646",
3230
+ "502",
3231
+ "54",
3232
+ "572"
3233
+ ]
3234
+ }
3235
+ },
3236
+ {
3237
+ "name": "dl_000",
3238
+ "role": "feature",
3239
+ "semantic_type": "boolean",
3240
+ "nullable": true,
3241
+ "missing_tokens": [
3242
+ "na"
3243
+ ],
3244
+ "parse_format": null,
3245
+ "impute_strategy": "mode",
3246
+ "profile_stats": {
3247
+ "missing_rate": 0.066299,
3248
+ "unique_count": 191,
3249
+ "unique_ratio": 0.003365,
3250
+ "example_values": [
3251
+ "0",
3252
+ "160",
3253
+ "1190",
3254
+ "25620",
3255
+ "1900"
3256
+ ]
3257
+ }
3258
+ },
3259
+ {
3260
+ "name": "dm_000",
3261
+ "role": "feature",
3262
+ "semantic_type": "boolean",
3263
+ "nullable": true,
3264
+ "missing_tokens": [
3265
+ "na"
3266
+ ],
3267
+ "parse_format": null,
3268
+ "impute_strategy": "mode",
3269
+ "profile_stats": {
3270
+ "missing_rate": 0.066299,
3271
+ "unique_count": 236,
3272
+ "unique_ratio": 0.004157,
3273
+ "example_values": [
3274
+ "0",
3275
+ "7842",
3276
+ "47464",
3277
+ "136746",
3278
+ "25864"
3279
+ ]
3280
+ }
3281
+ },
3282
+ {
3283
+ "name": "dn_000",
3284
+ "role": "feature",
3285
+ "semantic_type": "numeric",
3286
+ "nullable": true,
3287
+ "missing_tokens": [
3288
+ "na"
3289
+ ],
3290
+ "parse_format": null,
3291
+ "impute_strategy": "median",
3292
+ "profile_stats": {
3293
+ "missing_rate": 0.011365,
3294
+ "unique_count": 20000,
3295
+ "unique_ratio": 0.332729,
3296
+ "example_values": [
3297
+ "582",
3298
+ "18072",
3299
+ "676",
3300
+ "15162",
3301
+ "24566"
3302
+ ]
3303
+ }
3304
+ },
3305
+ {
3306
+ "name": "do_000",
3307
+ "role": "feature",
3308
+ "semantic_type": "numeric",
3309
+ "nullable": true,
3310
+ "missing_tokens": [
3311
+ "na"
3312
+ ],
3313
+ "parse_format": null,
3314
+ "impute_strategy": "median",
3315
+ "profile_stats": {
3316
+ "missing_rate": 0.045674,
3317
+ "unique_count": 20000,
3318
+ "unique_ratio": 0.344691,
3319
+ "example_values": [
3320
+ "676",
3321
+ "71612",
3322
+ "0",
3323
+ "27588",
3324
+ "27348"
3325
+ ]
3326
+ }
3327
+ },
3328
+ {
3329
+ "name": "dp_000",
3330
+ "role": "feature",
3331
+ "semantic_type": "numeric",
3332
+ "nullable": true,
3333
+ "missing_tokens": [
3334
+ "na"
3335
+ ],
3336
+ "parse_format": null,
3337
+ "impute_strategy": "median",
3338
+ "profile_stats": {
3339
+ "missing_rate": 0.045707,
3340
+ "unique_count": 11680,
3341
+ "unique_ratio": 0.201306,
3342
+ "example_values": [
3343
+ "274",
3344
+ "14700",
3345
+ "0",
3346
+ "6920",
3347
+ "9376"
3348
+ ]
3349
+ }
3350
+ },
3351
+ {
3352
+ "name": "dq_000",
3353
+ "role": "feature",
3354
+ "semantic_type": "numeric",
3355
+ "nullable": true,
3356
+ "missing_tokens": [
3357
+ "na"
3358
+ ],
3359
+ "parse_format": null,
3360
+ "impute_strategy": "median",
3361
+ "profile_stats": {
3362
+ "missing_rate": 0.045707,
3363
+ "unique_count": 8172,
3364
+ "unique_ratio": 0.140846,
3365
+ "example_values": [
3366
+ "0",
3367
+ "5916",
3368
+ "80",
3369
+ "46424",
3370
+ "1634"
3371
+ ]
3372
+ }
3373
+ },
3374
+ {
3375
+ "name": "dr_000",
3376
+ "role": "feature",
3377
+ "semantic_type": "numeric",
3378
+ "nullable": true,
3379
+ "missing_tokens": [
3380
+ "na"
3381
+ ],
3382
+ "parse_format": null,
3383
+ "impute_strategy": "median",
3384
+ "profile_stats": {
3385
+ "missing_rate": 0.045707,
3386
+ "unique_count": 6718,
3387
+ "unique_ratio": 0.115786,
3388
+ "example_values": [
3389
+ "0",
3390
+ "1822",
3391
+ "20",
3392
+ "22158",
3393
+ "462"
3394
+ ]
3395
+ }
3396
+ },
3397
+ {
3398
+ "name": "ds_000",
3399
+ "role": "feature",
3400
+ "semantic_type": "numeric",
3401
+ "nullable": true,
3402
+ "missing_tokens": [
3403
+ "na"
3404
+ ],
3405
+ "parse_format": null,
3406
+ "impute_strategy": "median",
3407
+ "profile_stats": {
3408
+ "missing_rate": 0.045724,
3409
+ "unique_count": 20000,
3410
+ "unique_ratio": 0.344709,
3411
+ "example_values": [
3412
+ "1818",
3413
+ "195476",
3414
+ "382",
3415
+ "67782",
3416
+ "81362"
3417
+ ]
3418
+ }
3419
+ },
3420
+ {
3421
+ "name": "dt_000",
3422
+ "role": "feature",
3423
+ "semantic_type": "numeric",
3424
+ "nullable": true,
3425
+ "missing_tokens": [
3426
+ "na"
3427
+ ],
3428
+ "parse_format": null,
3429
+ "impute_strategy": "median",
3430
+ "profile_stats": {
3431
+ "missing_rate": 0.045724,
3432
+ "unique_count": 15973,
3433
+ "unique_ratio": 0.275302,
3434
+ "example_values": [
3435
+ "366",
3436
+ "45576",
3437
+ "118",
3438
+ "9494",
3439
+ "14780"
3440
+ ]
3441
+ }
3442
+ },
3443
+ {
3444
+ "name": "du_000",
3445
+ "role": "feature",
3446
+ "semantic_type": "numeric",
3447
+ "nullable": true,
3448
+ "missing_tokens": [
3449
+ "na"
3450
+ ],
3451
+ "parse_format": null,
3452
+ "impute_strategy": "median",
3453
+ "profile_stats": {
3454
+ "missing_rate": 0.045707,
3455
+ "unique_count": 20000,
3456
+ "unique_ratio": 0.344703,
3457
+ "example_values": [
3458
+ "172440",
3459
+ "4797440",
3460
+ "44360",
3461
+ "50580",
3462
+ "7797080"
3463
+ ]
3464
+ }
3465
+ },
3466
+ {
3467
+ "name": "dv_000",
3468
+ "role": "feature",
3469
+ "semantic_type": "numeric",
3470
+ "nullable": true,
3471
+ "missing_tokens": [
3472
+ "na"
3473
+ ],
3474
+ "parse_format": null,
3475
+ "impute_strategy": "median",
3476
+ "profile_stats": {
3477
+ "missing_rate": 0.045707,
3478
+ "unique_count": 20000,
3479
+ "unique_ratio": 0.344703,
3480
+ "example_values": [
3481
+ "17258",
3482
+ "2234018",
3483
+ "4450",
3484
+ "10454",
3485
+ "1354532"
3486
+ ]
3487
+ }
3488
+ },
3489
+ {
3490
+ "name": "dx_000",
3491
+ "role": "feature",
3492
+ "semantic_type": "numeric",
3493
+ "nullable": true,
3494
+ "missing_tokens": [
3495
+ "na"
3496
+ ],
3497
+ "parse_format": null,
3498
+ "impute_strategy": "median",
3499
+ "profile_stats": {
3500
+ "missing_rate": 0.045691,
3501
+ "unique_count": 14891,
3502
+ "unique_ratio": 0.256644,
3503
+ "example_values": [
3504
+ "28760",
3505
+ "0",
3506
+ "9742",
3507
+ "9654",
3508
+ "54468"
3509
+ ]
3510
+ }
3511
+ },
3512
+ {
3513
+ "name": "dy_000",
3514
+ "role": "feature",
3515
+ "semantic_type": "numeric",
3516
+ "nullable": true,
3517
+ "missing_tokens": [
3518
+ "na"
3519
+ ],
3520
+ "parse_format": null,
3521
+ "impute_strategy": "median",
3522
+ "profile_stats": {
3523
+ "missing_rate": 0.045707,
3524
+ "unique_count": 6366,
3525
+ "unique_ratio": 0.109719,
3526
+ "example_values": [
3527
+ "96",
3528
+ "0",
3529
+ "12",
3530
+ "26",
3531
+ "76"
3532
+ ]
3533
+ }
3534
+ },
3535
+ {
3536
+ "name": "dz_000",
3537
+ "role": "feature",
3538
+ "semantic_type": "boolean",
3539
+ "nullable": true,
3540
+ "missing_tokens": [
3541
+ "na"
3542
+ ],
3543
+ "parse_format": null,
3544
+ "impute_strategy": "mode",
3545
+ "profile_stats": {
3546
+ "missing_rate": 0.045674,
3547
+ "unique_count": 45,
3548
+ "unique_ratio": 0.000776,
3549
+ "example_values": [
3550
+ "0",
3551
+ "2",
3552
+ "6",
3553
+ "12",
3554
+ "4"
3555
+ ]
3556
+ }
3557
+ },
3558
+ {
3559
+ "name": "ea_000",
3560
+ "role": "feature",
3561
+ "semantic_type": "boolean",
3562
+ "nullable": true,
3563
+ "missing_tokens": [
3564
+ "na"
3565
+ ],
3566
+ "parse_format": null,
3567
+ "impute_strategy": "mode",
3568
+ "profile_stats": {
3569
+ "missing_rate": 0.045674,
3570
+ "unique_count": 131,
3571
+ "unique_ratio": 0.002258,
3572
+ "example_values": [
3573
+ "0",
3574
+ "2",
3575
+ "8",
3576
+ "10",
3577
+ "18"
3578
+ ]
3579
+ }
3580
+ },
3581
+ {
3582
+ "name": "eb_000",
3583
+ "role": "feature",
3584
+ "semantic_type": "numeric",
3585
+ "nullable": true,
3586
+ "missing_tokens": [
3587
+ "na"
3588
+ ],
3589
+ "parse_format": null,
3590
+ "impute_strategy": "median",
3591
+ "profile_stats": {
3592
+ "missing_rate": 0.066283,
3593
+ "unique_count": 20000,
3594
+ "unique_ratio": 0.352299,
3595
+ "example_values": [
3596
+ "655720",
3597
+ "1186300",
3598
+ "0",
3599
+ "1304800",
3600
+ "2929070"
3601
+ ]
3602
+ }
3603
+ },
3604
+ {
3605
+ "name": "ec_00",
3606
+ "role": "feature",
3607
+ "semantic_type": "numeric",
3608
+ "nullable": true,
3609
+ "missing_tokens": [
3610
+ "na"
3611
+ ],
3612
+ "parse_format": null,
3613
+ "impute_strategy": "median",
3614
+ "profile_stats": {
3615
+ "missing_rate": 0.167862,
3616
+ "unique_count": 20000,
3617
+ "unique_ratio": 0.395304,
3618
+ "example_values": [
3619
+ "65.78",
3620
+ "277.6",
3621
+ "687.2",
3622
+ "1133.78",
3623
+ "127.84"
3624
+ ]
3625
+ }
3626
+ },
3627
+ {
3628
+ "name": "ed_000",
3629
+ "role": "feature",
3630
+ "semantic_type": "numeric",
3631
+ "nullable": true,
3632
+ "missing_tokens": [
3633
+ "na"
3634
+ ],
3635
+ "parse_format": null,
3636
+ "impute_strategy": "median",
3637
+ "profile_stats": {
3638
+ "missing_rate": 0.156793,
3639
+ "unique_count": 3976,
3640
+ "unique_ratio": 0.077555,
3641
+ "example_values": [
3642
+ "68",
3643
+ "130",
3644
+ "756",
3645
+ "1192",
3646
+ "70"
3647
+ ]
3648
+ }
3649
+ },
3650
+ {
3651
+ "name": "ee_000",
3652
+ "role": "feature",
3653
+ "semantic_type": "numeric",
3654
+ "nullable": true,
3655
+ "missing_tokens": [
3656
+ "na"
3657
+ ],
3658
+ "parse_format": null,
3659
+ "impute_strategy": "median",
3660
+ "profile_stats": {
3661
+ "missing_rate": 0.011431,
3662
+ "unique_count": 20000,
3663
+ "unique_ratio": 0.332751,
3664
+ "example_values": [
3665
+ "13308",
3666
+ "536366",
3667
+ "23816",
3668
+ "258900",
3669
+ "622930"
3670
+ ]
3671
+ }
3672
+ },
3673
+ {
3674
+ "name": "ee_001",
3675
+ "role": "feature",
3676
+ "semantic_type": "numeric",
3677
+ "nullable": true,
3678
+ "missing_tokens": [
3679
+ "na"
3680
+ ],
3681
+ "parse_format": null,
3682
+ "impute_strategy": "median",
3683
+ "profile_stats": {
3684
+ "missing_rate": 0.011431,
3685
+ "unique_count": 20000,
3686
+ "unique_ratio": 0.332751,
3687
+ "example_values": [
3688
+ "12120",
3689
+ "707172",
3690
+ "6194",
3691
+ "312464",
3692
+ "546652"
3693
+ ]
3694
+ }
3695
+ },
3696
+ {
3697
+ "name": "ee_002",
3698
+ "role": "feature",
3699
+ "semantic_type": "numeric",
3700
+ "nullable": true,
3701
+ "missing_tokens": [
3702
+ "na"
3703
+ ],
3704
+ "parse_format": null,
3705
+ "impute_strategy": "median",
3706
+ "profile_stats": {
3707
+ "missing_rate": 0.011431,
3708
+ "unique_count": 20000,
3709
+ "unique_ratio": 0.332751,
3710
+ "example_values": [
3711
+ "5308",
3712
+ "421568",
3713
+ "1256",
3714
+ "262268",
3715
+ "319658"
3716
+ ]
3717
+ }
3718
+ },
3719
+ {
3720
+ "name": "ee_003",
3721
+ "role": "feature",
3722
+ "semantic_type": "numeric",
3723
+ "nullable": true,
3724
+ "missing_tokens": [
3725
+ "na"
3726
+ ],
3727
+ "parse_format": null,
3728
+ "impute_strategy": "median",
3729
+ "profile_stats": {
3730
+ "missing_rate": 0.011431,
3731
+ "unique_count": 20000,
3732
+ "unique_ratio": 0.332751,
3733
+ "example_values": [
3734
+ "3258",
3735
+ "212454",
3736
+ "542",
3737
+ "152306",
3738
+ "144106"
3739
+ ]
3740
+ }
3741
+ },
3742
+ {
3743
+ "name": "ee_004",
3744
+ "role": "feature",
3745
+ "semantic_type": "numeric",
3746
+ "nullable": true,
3747
+ "missing_tokens": [
3748
+ "na"
3749
+ ],
3750
+ "parse_format": null,
3751
+ "impute_strategy": "median",
3752
+ "profile_stats": {
3753
+ "missing_rate": 0.011431,
3754
+ "unique_count": 20000,
3755
+ "unique_ratio": 0.332751,
3756
+ "example_values": [
3757
+ "8582",
3758
+ "446284",
3759
+ "1046",
3760
+ "325008",
3761
+ "283446"
3762
+ ]
3763
+ }
3764
+ },
3765
+ {
3766
+ "name": "ee_005",
3767
+ "role": "feature",
3768
+ "semantic_type": "numeric",
3769
+ "nullable": true,
3770
+ "missing_tokens": [
3771
+ "na"
3772
+ ],
3773
+ "parse_format": null,
3774
+ "impute_strategy": "median",
3775
+ "profile_stats": {
3776
+ "missing_rate": 0.011431,
3777
+ "unique_count": 20000,
3778
+ "unique_ratio": 0.332751,
3779
+ "example_values": [
3780
+ "43912",
3781
+ "460602",
3782
+ "350",
3783
+ "446416",
3784
+ "260842"
3785
+ ]
3786
+ }
3787
+ },
3788
+ {
3789
+ "name": "ee_006",
3790
+ "role": "feature",
3791
+ "semantic_type": "numeric",
3792
+ "nullable": true,
3793
+ "missing_tokens": [
3794
+ "na"
3795
+ ],
3796
+ "parse_format": null,
3797
+ "impute_strategy": "median",
3798
+ "profile_stats": {
3799
+ "missing_rate": 0.011431,
3800
+ "unique_count": 20000,
3801
+ "unique_ratio": 0.332751,
3802
+ "example_values": [
3803
+ "6370",
3804
+ "374400",
3805
+ "680",
3806
+ "377770",
3807
+ "168748"
3808
+ ]
3809
+ }
3810
+ },
3811
+ {
3812
+ "name": "ee_007",
3813
+ "role": "feature",
3814
+ "semantic_type": "numeric",
3815
+ "nullable": true,
3816
+ "missing_tokens": [
3817
+ "na"
3818
+ ],
3819
+ "parse_format": null,
3820
+ "impute_strategy": "median",
3821
+ "profile_stats": {
3822
+ "missing_rate": 0.011431,
3823
+ "unique_count": 20000,
3824
+ "unique_ratio": 0.332751,
3825
+ "example_values": [
3826
+ "2886",
3827
+ "371258",
3828
+ "1112",
3829
+ "76752",
3830
+ "108786"
3831
+ ]
3832
+ }
3833
+ },
3834
+ {
3835
+ "name": "ee_008",
3836
+ "role": "feature",
3837
+ "semantic_type": "numeric",
3838
+ "nullable": true,
3839
+ "missing_tokens": [
3840
+ "na"
3841
+ ],
3842
+ "parse_format": null,
3843
+ "impute_strategy": "median",
3844
+ "profile_stats": {
3845
+ "missing_rate": 0.011431,
3846
+ "unique_count": 20000,
3847
+ "unique_ratio": 0.332751,
3848
+ "example_values": [
3849
+ "2584",
3850
+ "2041592",
3851
+ "0",
3852
+ "55228",
3853
+ "151796"
3854
+ ]
3855
+ }
3856
+ },
3857
+ {
3858
+ "name": "ee_009",
3859
+ "role": "feature",
3860
+ "semantic_type": "numeric",
3861
+ "nullable": true,
3862
+ "missing_tokens": [
3863
+ "na"
3864
+ ],
3865
+ "parse_format": null,
3866
+ "impute_strategy": "median",
3867
+ "profile_stats": {
3868
+ "missing_rate": 0.011431,
3869
+ "unique_count": 9722,
3870
+ "unique_ratio": 0.16175,
3871
+ "example_values": [
3872
+ "156",
3873
+ "321636",
3874
+ "0",
3875
+ "944",
3876
+ "12404"
3877
+ ]
3878
+ }
3879
+ },
3880
+ {
3881
+ "name": "ef_000",
3882
+ "role": "feature",
3883
+ "semantic_type": "boolean",
3884
+ "nullable": true,
3885
+ "missing_tokens": [
3886
+ "na"
3887
+ ],
3888
+ "parse_format": null,
3889
+ "impute_strategy": "mode",
3890
+ "profile_stats": {
3891
+ "missing_rate": 0.045691,
3892
+ "unique_count": 27,
3893
+ "unique_ratio": 0.000465,
3894
+ "example_values": [
3895
+ "0",
3896
+ "2",
3897
+ "8",
3898
+ "4",
3899
+ "362"
3900
+ ]
3901
+ }
3902
+ },
3903
+ {
3904
+ "name": "eg_000",
3905
+ "role": "feature",
3906
+ "semantic_type": "boolean",
3907
+ "nullable": true,
3908
+ "missing_tokens": [
3909
+ "na"
3910
+ ],
3911
+ "parse_format": null,
3912
+ "impute_strategy": "mode",
3913
+ "profile_stats": {
3914
+ "missing_rate": 0.045674,
3915
+ "unique_count": 49,
3916
+ "unique_ratio": 0.000844,
3917
+ "example_values": [
3918
+ "0",
3919
+ "2",
3920
+ "6",
3921
+ "8",
3922
+ "20"
3923
+ ]
3924
+ }
3925
+ }
3926
+ ],
3927
+ "public_manifest": "/data/jialinzhang/SynthesizePipeline-server/output-Benchmark-trainonly-v1/n18/tabddpm/tabddpm-n18-20260510_215518/public_gate/staged_input_manifest.json",
3928
+ "train_csv": "/data/jialinzhang/SynthesizePipeline-server/output-Benchmark-trainonly-v1/n18/tabddpm/tabddpm-n18-20260510_215518/staged/public/train.csv",
3929
+ "val_csv": "/data/jialinzhang/SynthesizePipeline-server/output-Benchmark-trainonly-v1/n18/tabddpm/tabddpm-n18-20260510_215518/staged/public/val.csv",
3930
+ "test_csv": "/data/jialinzhang/SynthesizePipeline-server/output-Benchmark-trainonly-v1/n18/tabddpm/tabddpm-n18-20260510_215518/staged/public/test.csv",
3931
+ "features_json": "/data/jialinzhang/SynthesizePipeline-server/output-Benchmark-trainonly-v1/n18/tabddpm/tabddpm-n18-20260510_215518/staged/public/staged_features.json",
3932
+ "public_gate_report": "/data/jialinzhang/SynthesizePipeline-server/output-Benchmark-trainonly-v1/n18/tabddpm/tabddpm-n18-20260510_215518/public_gate/public_gate_report.json"
3933
+ }
syntheticFail/n18/tabddpm/tabddpm-n18-20260510_215518/train_20260510_215528.log ADDED
@@ -0,0 +1,3 @@
 
 
 
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:66a24c2324957b6ba4980b22b7eeed6184f7e4de1bd2269f8194198dcab7acf0
3
+ size 576
syntheticFail/n18/tabddpm/tabddpm-n18-20260511_002808/_tabddpm_runtime/._data ADDED
Binary file (220 Bytes). View file
 
syntheticFail/n18/tabddpm/tabddpm-n18-20260511_002808/_tabddpm_runtime/.gitignore ADDED
@@ -0,0 +1,22 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ .DS_Store
2
+ __pycache__/
3
+ catboost_info/
4
+ **/**.pt
5
+ **/**.ipynb
6
+ !agg_results.ipynb
7
+ **/**.npy
8
+ **/**.gz
9
+ **/**.sh
10
+ **/**.obj
11
+ **/**.png
12
+ **/**.tar
13
+ **/**.code-workspace
14
+ **/**.csv
15
+ exp/**/**/results_catboost.json
16
+ exp/**/**/results_mlp.json
17
+
18
+ configs/
19
+ data/
20
+ junk/
21
+ RF/
22
+ exps/
syntheticFail/n18/tabddpm/tabddpm-n18-20260511_002808/_tabddpm_runtime/.gitmodules ADDED
@@ -0,0 +1,9 @@
 
 
 
 
 
 
 
 
 
 
1
+ [submodule "ctgan"]
2
+ # path = CTGAN/CTGAN
3
+ url = https://github.com/sdv-dev/CTGAN
4
+ [submodule "ctabgan"]
5
+ # path = CTAB-GAN
6
+ url = https://github.com/Team-TUD/CTAB-GAN
7
+ [submodule "ctabgan+"]
8
+ # path = CTAB-GAN-Plus
9
+ url = https://github.com/Team-TUD/CTAB-GAN-Plus
syntheticFail/n18/tabddpm/tabddpm-n18-20260511_002808/_tabddpm_runtime/CONFIG_DESCRIPTION.md ADDED
@@ -0,0 +1,78 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # Description of .toml config for TabDDPM
2
+ First of all, `train.T` and `eval.T` denote preprocessing for training and for evaluation, respectively.
3
+
4
+ Here we list non-obvious parameters.
5
+
6
+ Main part:
7
+ - `seed = 0` -- evaluation seed (and training, but for training it is fixed to 0)
8
+ - `parent_dir = "exp/abalone/check"` -- exp folder
9
+ - `real_data_path = "data/abalone/"`
10
+ - `model_type = "mlp"` -- model type that approximates the reverse process
11
+ - `num_numerical_features ` -- a number of numerical features in dataset
12
+ - `device = "cuda:0"`
13
+
14
+ Model params:
15
+ - `is_y_cond` -- false for regression, true for classification
16
+ - `d_in` -- input dimension (not necessary, since scripts calculate it automatically)
17
+ - `num_calsses` -- zero for regression, a number of classes for classification
18
+ - `rtdl_params` -- MLP parameters
19
+
20
+ ```toml
21
+ seed = 0
22
+ parent_dir = "exp/abalone/check"
23
+ real_data_path = "data/abalone/"
24
+ model_type = "mlp"
25
+ num_numerical_features = 7
26
+ device = "cuda:0"
27
+
28
+ [model_params]
29
+ is_y_cond = false
30
+ d_in = 11
31
+ num_classes = 0
32
+
33
+ [model_params.rtdl_params]
34
+ d_layers = [
35
+ 256,
36
+ 256,
37
+ ]
38
+ dropout = 0.0
39
+
40
+ [diffusion_params]
41
+ num_timesteps = 1000
42
+ gaussian_loss_type = "mse"
43
+ scheduler = "cosine"
44
+
45
+ [train.main]
46
+ steps = 1000
47
+ lr = 0.001
48
+ weight_decay = 1e-05
49
+ batch_size = 4096
50
+
51
+ [train.T]
52
+ seed = 0
53
+ normalization = "quantile"
54
+ num_nan_policy = "__none__"
55
+ cat_nan_policy = "__none__"
56
+ cat_min_frequency = "__none__"
57
+ cat_encoding = "__none__"
58
+ y_policy = "default"
59
+
60
+ [sample]
61
+ num_samples = 20800
62
+ batch_size = 10000
63
+ seed = 0
64
+
65
+ [eval.type]
66
+ eval_model = "catboost"
67
+ eval_type = "synthetic"
68
+
69
+ [eval.T]
70
+ seed = 0
71
+ normalization = "__none__"
72
+ num_nan_policy = "__none__"
73
+ cat_nan_policy = "__none__"
74
+ cat_min_frequency = "__none__"
75
+ cat_encoding = "__none__"
76
+ y_policy = "default"
77
+
78
+ ```
syntheticFail/n18/tabddpm/tabddpm-n18-20260511_002808/_tabddpm_runtime/CTAB-GAN-Plus/.gitignore ADDED
@@ -0,0 +1 @@
 
 
1
+ **/**.csv
syntheticFail/n18/tabddpm/tabddpm-n18-20260511_002808/_tabddpm_runtime/CTAB-GAN-Plus/README.md ADDED
@@ -0,0 +1,49 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # CTAB-GAN+
2
+ 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.
3
+ If you have any question, please contact `z.zhao-8@tudelft.nl` for more information.
4
+
5
+
6
+ ## Prerequisite
7
+
8
+ The required package version
9
+ ```
10
+ numpy==1.21.0
11
+ torch==1.9.1
12
+ pandas==1.2.4
13
+ sklearn==0.24.1
14
+ dython==0.6.4.post1
15
+ scipy==1.4.1
16
+ ```
17
+ 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!
18
+
19
+ ## Example
20
+ `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.
21
+ The evaluation code is also provided.
22
+
23
+ ## Problem type
24
+
25
+ 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:
26
+ ```
27
+ problem_type= {None: None}
28
+ ```
29
+
30
+ ## For large dataset
31
+
32
+ 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
33
+ ```
34
+ sides = [4, 8, 16, 24, 32]
35
+ ```
36
+ 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.
37
+
38
+ ## Bibtex
39
+
40
+ To cite this paper, you could use this bibtex
41
+
42
+ ```
43
+ @article{zhao2022ctab,
44
+ title={CTAB-GAN+: Enhancing Tabular Data Synthesis},
45
+ author={Zhao, Zilong and Kunar, Aditya and Birke, Robert and Chen, Lydia Y},
46
+ journal={arXiv preprint arXiv:2204.00401},
47
+ year={2022}
48
+ }
49
+ ```
syntheticFail/n18/tabddpm/tabddpm-n18-20260511_002808/_tabddpm_runtime/CTAB-GAN-Plus/columns.json ADDED
@@ -0,0 +1,119 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "churn2": {
3
+ "categorical_columns": ["7", "8", "9", "10", "y"],
4
+ "mixed_columns": {"0": [850.0], "3": [0.0]},
5
+ "integer_columns": ["2", "4"],
6
+ "general_columns": ["1", "5", "6"],
7
+ "problem_type": {"Classification": "y"}
8
+ },
9
+ "adult": {
10
+ "categorical_columns": ["6", "7", "8", "9", "10", "11", "12", "13", "y"],
11
+ "mixed_columns": {"3": [0.0], "4": [0.0]},
12
+ "integer_columns": ["0", "1", "2", "5"],
13
+ "general_columns": ["0", "1", "7"],
14
+ "problem_type": {"Classification": "y"}
15
+ },
16
+ "california": {
17
+ "categorical_columns": [],
18
+ "mixed_columns": {"1": [52.0]},
19
+ "integer_columns": ["4"],
20
+ "general_columns": ["0"],
21
+ "problem_type": {"Regression": "y"}
22
+ },
23
+ "default": {
24
+ "categorical_columns": ["20", "21", "22", "y"],
25
+ "mixed_columns": {},
26
+ "general_columns": [],
27
+ "integer_columns": ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19"],
28
+ "problem_type": {"Classification": "y"}
29
+ },
30
+ "buddy": {
31
+ "categorical_columns": ["4", "5", "6", "7", "8", "y"],
32
+ "mixed_columns": {},
33
+ "integer_columns": ["0", "1"],
34
+ "general_columns": ["1", "3", "5"],
35
+ "problem_type": {"Classification": "y"}
36
+ },
37
+ "gesture": {
38
+ "categorical_columns": ["y"],
39
+ "mixed_columns": {},
40
+ "integer_columns": [],
41
+ "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"],
42
+ "problem_type": {"Classification": "y"}
43
+ },
44
+ "wilt": {
45
+ "categorical_columns": ["y"],
46
+ "mixed_columns": {},
47
+ "integer_columns": [],
48
+ "general_columns": ["0", "3"],
49
+ "problem_type": {"Classification": "y"}
50
+ },
51
+ "satellite": {
52
+ "categorical_columns": ["y"],
53
+ "mixed_columns": {},
54
+ "integer_columns": [],
55
+ "problem_type": {"Classification": "y"}
56
+ },
57
+ "higgs-small": {
58
+ "categorical_columns": ["y"],
59
+ "mixed_columns": {},
60
+ "integer_columns": [],
61
+ "general_columns": ["1", "2", "4", "6", "10", "11", "14", "15", "18","19"],
62
+ "problem_type": {"Classification": "y"}
63
+ },
64
+ "diabetes": {
65
+ "categorical_columns": ["y"],
66
+ "mixed_columns": {"3": [0.0], "4": [0.0]},
67
+ "general_columns": [],
68
+ "integer_columns": ["0", "1", "2", "5", "7"],
69
+ "problem_type": {"Classification": "y"}
70
+ },
71
+ "abalone": {
72
+ "categorical_columns": ["7"],
73
+ "mixed_columns": {},
74
+ "integer_columns": ["y"],
75
+ "general_columns": [],
76
+ "problem_type": {"Regression": "y"}
77
+ },
78
+ "insurance": {
79
+ "categorical_columns": ["3", "4", "5"],
80
+ "mixed_columns": {},
81
+ "general_columns": [],
82
+ "integer_columns": ["0", "2"],
83
+ "problem_type": {"Regression": "y"}
84
+ },
85
+ "king": {
86
+ "categorical_columns": ["17", "18", "19"],
87
+ "mixed_columns": {"9": [0.0], "11":[0.0]},
88
+ "general_columns": ["2", "6", "7"],
89
+ "integer_columns": ["0", "2", "5", "7", "8", "9", "12"],
90
+ "problem_type": {"Regression": "y"}
91
+ },
92
+ "cardio": {
93
+ "categorical_columns": ["5", "6", "7", "8", "9", "10", "y"],
94
+ "mixed_columns": {},
95
+ "integer_columns": ["0", "1", "3", "4"],
96
+ "problem_type": {"Classification": "y"}
97
+ },
98
+ "house": {
99
+ "categorical_columns": [],
100
+ "mixed_columns": {"2": [0.0], "6": [0.0], "8": [0.0], "11": [0.0], "12": [1.0], "14": [0.0]},
101
+ "general_columns": ["1", "7"],
102
+ "integer_columns": ["0"],
103
+ "problem_type": {"Regression": "y"}
104
+ },
105
+ "miniboone": {
106
+ "categorical_columns": ["y"],
107
+ "mixed_columns": {},
108
+ "integer_columns": [],
109
+ "general_columns": ["8", "9", "10", "19", "20", "21", "28", "29", "35", "39", "45", "49"],
110
+ "problem_type": {"Classification": "y"}
111
+ },
112
+ "fb-comments": {
113
+ "categorical_columns": ["36", "37", "38", "39", "40", "41", "42", "43", "44", "45", "46", "47", "48", "49", "50"],
114
+ "mixed_columns": {"1": [0.0], "8": [0.0], "10": [0.0]},
115
+ "general_columns": ["26", "36"],
116
+ "integer_columns": [],
117
+ "problem_type": {"Regression": "y"}
118
+ }
119
+ }
syntheticFail/n18/tabddpm/tabddpm-n18-20260511_002808/_tabddpm_runtime/CTAB-GAN-Plus/model copy/ctabgan.py ADDED
@@ -0,0 +1,70 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ """
2
+ Generative model training algorithm based on the CTABGANSynthesiser
3
+
4
+ """
5
+ import pandas as pd
6
+ import time
7
+ from model.pipeline.data_preparation import DataPrep
8
+ from model.synthesizer.ctabgan_synthesizer import CTABGANSynthesizer
9
+
10
+ import warnings
11
+
12
+ warnings.filterwarnings("ignore")
13
+
14
+ class CTABGAN():
15
+
16
+ def __init__(self,
17
+ df,
18
+ test_ratio = 0.20,
19
+ categorical_columns = [ 'workclass', 'education', 'marital-status', 'occupation', 'relationship', 'race', 'gender', 'native-country', 'income'],
20
+ log_columns = [],
21
+ mixed_columns= {'capital-loss':[0.0],'capital-gain':[0.0]},
22
+ general_columns = ["age"],
23
+ non_categorical_columns = [],
24
+ integer_columns = ['age', 'fnlwgt','capital-gain', 'capital-loss','hours-per-week'],
25
+ problem_type= {"Classification": "income"},
26
+ class_dim=(256, 256, 256, 256),
27
+ random_dim=100,
28
+ num_channels=64,
29
+ l2scale=1e-5,
30
+ batch_size=500,
31
+ epochs=150,
32
+ device="cpu"):
33
+
34
+ self.__name__ = 'CTABGAN'
35
+
36
+ self.synthesizer = CTABGANSynthesizer(
37
+ class_dim=class_dim,
38
+ random_dim=random_dim,
39
+ num_channels=num_channels,
40
+ l2scale=l2scale,
41
+ batch_size=batch_size,
42
+ epochs=epochs,
43
+ device=device
44
+ )
45
+ self.raw_df = df
46
+ self.test_ratio = test_ratio
47
+ self.categorical_columns = categorical_columns
48
+ self.log_columns = log_columns
49
+ self.mixed_columns = mixed_columns
50
+ self.general_columns = general_columns
51
+ self.non_categorical_columns = non_categorical_columns
52
+ self.integer_columns = integer_columns
53
+ self.problem_type = problem_type
54
+
55
+ def fit(self):
56
+
57
+ start_time = time.time()
58
+ 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)
59
+ self.synthesizer.fit(train_data=self.data_prep.df, categorical = self.data_prep.column_types["categorical"], mixed = self.data_prep.column_types["mixed"],
60
+ general = self.data_prep.column_types["general"], non_categorical = self.data_prep.column_types["non_categorical"], type=self.problem_type)
61
+ end_time = time.time()
62
+ print('Finished training in',end_time-start_time," seconds.")
63
+
64
+
65
+ def generate_samples(self, seed=0):
66
+
67
+ sample = self.synthesizer.sample(len(self.raw_df), seed)
68
+ sample_df = self.data_prep.inverse_prep(sample)
69
+
70
+ return sample_df
syntheticFail/n18/tabddpm/tabddpm-n18-20260511_002808/_tabddpm_runtime/CTAB-GAN-Plus/model copy/eval/evaluation.py ADDED
@@ -0,0 +1,193 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ import numpy as np
2
+ import pandas as pd
3
+ from sklearn import metrics
4
+ from sklearn import model_selection
5
+ from sklearn.preprocessing import MinMaxScaler,StandardScaler
6
+ from sklearn.neural_network import MLPClassifier
7
+ from sklearn.linear_model import LogisticRegression
8
+ from sklearn import svm,tree
9
+ from sklearn.ensemble import RandomForestClassifier
10
+ from dython.nominal import compute_associations
11
+ from scipy.stats import wasserstein_distance
12
+ from scipy.spatial import distance
13
+ import warnings
14
+
15
+ warnings.filterwarnings("ignore")
16
+
17
+ def supervised_model_training(x_train, y_train, x_test,
18
+ y_test, model_name):
19
+
20
+
21
+ if model_name == 'lr':
22
+ model = LogisticRegression(random_state=42,max_iter=500)
23
+ elif model_name == 'svm':
24
+ model = svm.SVC(random_state=42,probability=True)
25
+ elif model_name == 'dt':
26
+ model = tree.DecisionTreeClassifier(random_state=42)
27
+ elif model_name == 'rf':
28
+ model = RandomForestClassifier(random_state=42)
29
+ elif model_name == "mlp":
30
+ model = MLPClassifier(random_state=42,max_iter=100)
31
+
32
+ model.fit(x_train, y_train)
33
+ pred = model.predict(x_test)
34
+
35
+ if len(np.unique(y_train))>2:
36
+ predict = model.predict_proba(x_test)
37
+ acc = metrics.accuracy_score(y_test,pred)*100
38
+ auc = metrics.roc_auc_score(y_test, predict,average="weighted",multi_class="ovr")
39
+ f1_score = metrics.precision_recall_fscore_support(y_test, pred,average="weighted")[2]
40
+ return [acc, auc,f1_score]
41
+
42
+ else:
43
+ predict = model.predict_proba(x_test)[:,1]
44
+ acc = metrics.accuracy_score(y_test,pred)*100
45
+ auc = metrics.roc_auc_score(y_test, predict)
46
+ f1_score = metrics.precision_recall_fscore_support(y_test,pred)[2].mean()
47
+ return [acc, auc,f1_score]
48
+
49
+
50
+ def get_utility_metrics(real_path,fake_paths,scaler="MinMax",classifiers=["lr","dt","rf","mlp"],test_ratio=.20):
51
+
52
+ data_real = pd.read_csv(real_path).to_numpy()
53
+ data_dim = data_real.shape[1]
54
+
55
+ data_real_y = data_real[:,-1]
56
+ data_real_X = data_real[:,:data_dim-1]
57
+ 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)
58
+
59
+ if scaler=="MinMax":
60
+ scaler_real = MinMaxScaler()
61
+ else:
62
+ scaler_real = StandardScaler()
63
+
64
+ scaler_real.fit(data_real_X)
65
+ X_train_real_scaled = scaler_real.transform(X_train_real)
66
+ X_test_real_scaled = scaler_real.transform(X_test_real)
67
+
68
+ all_real_results = []
69
+ for classifier in classifiers:
70
+ real_results = supervised_model_training(X_train_real_scaled,y_train_real,X_test_real_scaled,y_test_real,classifier)
71
+ all_real_results.append(real_results)
72
+
73
+ all_fake_results_avg = []
74
+
75
+ for fake_path in fake_paths:
76
+ data_fake = pd.read_csv(fake_path).to_numpy()
77
+ data_fake_y = data_fake[:,-1]
78
+ data_fake_X = data_fake[:,:data_dim-1]
79
+ 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)
80
+
81
+ if scaler=="MinMax":
82
+ scaler_fake = MinMaxScaler()
83
+ else:
84
+ scaler_fake = StandardScaler()
85
+
86
+ scaler_fake.fit(data_fake_X)
87
+
88
+ X_train_fake_scaled = scaler_fake.transform(X_train_fake)
89
+
90
+ all_fake_results = []
91
+ for classifier in classifiers:
92
+ fake_results = supervised_model_training(X_train_fake_scaled,y_train_fake,X_test_real_scaled,y_test_real,classifier)
93
+ all_fake_results.append(fake_results)
94
+
95
+ all_fake_results_avg.append(all_fake_results)
96
+
97
+ diff_results = np.array(all_real_results)- np.array(all_fake_results_avg).mean(axis=0)
98
+
99
+ return diff_results
100
+
101
+ def stat_sim(real_path,fake_path,cat_cols=None):
102
+
103
+ Stat_dict={}
104
+
105
+ real = pd.read_csv(real_path)
106
+ fake = pd.read_csv(fake_path)
107
+
108
+ really = real.copy()
109
+ fakey = fake.copy()
110
+
111
+ real_corr = compute_associations(real, nominal_columns=cat_cols)
112
+
113
+ fake_corr = compute_associations(fake, nominal_columns=cat_cols)
114
+
115
+ corr_dist = np.linalg.norm(real_corr - fake_corr)
116
+
117
+ cat_stat = []
118
+ num_stat = []
119
+
120
+ for column in real.columns:
121
+
122
+ if column in cat_cols:
123
+
124
+ real_pdf=(really[column].value_counts()/really[column].value_counts().sum())
125
+ fake_pdf=(fakey[column].value_counts()/fakey[column].value_counts().sum())
126
+ categories = (fakey[column].value_counts()/fakey[column].value_counts().sum()).keys().tolist()
127
+ sorted_categories = sorted(categories)
128
+
129
+ real_pdf_values = []
130
+ fake_pdf_values = []
131
+
132
+ for i in sorted_categories:
133
+ real_pdf_values.append(real_pdf[i])
134
+ fake_pdf_values.append(fake_pdf[i])
135
+
136
+ if len(real_pdf)!=len(fake_pdf):
137
+ zero_cats = set(really[column].value_counts().keys())-set(fakey[column].value_counts().keys())
138
+ for z in zero_cats:
139
+ real_pdf_values.append(real_pdf[z])
140
+ fake_pdf_values.append(0)
141
+ Stat_dict[column]=(distance.jensenshannon(real_pdf_values,fake_pdf_values, 2.0))
142
+ cat_stat.append(Stat_dict[column])
143
+ else:
144
+ scaler = MinMaxScaler()
145
+ scaler.fit(real[column].values.reshape(-1,1))
146
+ l1 = scaler.transform(real[column].values.reshape(-1,1)).flatten()
147
+ l2 = scaler.transform(fake[column].values.reshape(-1,1)).flatten()
148
+ Stat_dict[column]= (wasserstein_distance(l1,l2))
149
+ num_stat.append(Stat_dict[column])
150
+
151
+ return [np.mean(num_stat),np.mean(cat_stat),corr_dist]
152
+
153
+ def privacy_metrics(real_path,fake_path,data_percent=15):
154
+
155
+ real = pd.read_csv(real_path).drop_duplicates(keep=False)
156
+ fake = pd.read_csv(fake_path).drop_duplicates(keep=False)
157
+
158
+ real_refined = real.sample(n=int(len(real)*(.01*data_percent)), random_state=42).to_numpy()
159
+ fake_refined = fake.sample(n=int(len(fake)*(.01*data_percent)), random_state=42).to_numpy()
160
+
161
+ scalerR = StandardScaler()
162
+ scalerR.fit(real_refined)
163
+ scalerF = StandardScaler()
164
+ scalerF.fit(fake_refined)
165
+ df_real_scaled = scalerR.transform(real_refined)
166
+ df_fake_scaled = scalerF.transform(fake_refined)
167
+
168
+ dist_rf = metrics.pairwise_distances(df_real_scaled, Y=df_fake_scaled, metric='minkowski', n_jobs=-1)
169
+ dist_rr = metrics.pairwise_distances(df_real_scaled, Y=None, metric='minkowski', n_jobs=-1)
170
+ rd_dist_rr = dist_rr[~np.eye(dist_rr.shape[0],dtype=bool)].reshape(dist_rr.shape[0],-1)
171
+ dist_ff = metrics.pairwise_distances(df_fake_scaled, Y=None, metric='minkowski', n_jobs=-1)
172
+ rd_dist_ff = dist_ff[~np.eye(dist_ff.shape[0],dtype=bool)].reshape(dist_ff.shape[0],-1)
173
+ smallest_two_indexes_rf = [dist_rf[i].argsort()[:2] for i in range(len(dist_rf))]
174
+ smallest_two_rf = [dist_rf[i][smallest_two_indexes_rf[i]] for i in range(len(dist_rf))]
175
+ smallest_two_indexes_rr = [rd_dist_rr[i].argsort()[:2] for i in range(len(rd_dist_rr))]
176
+ smallest_two_rr = [rd_dist_rr[i][smallest_two_indexes_rr[i]] for i in range(len(rd_dist_rr))]
177
+ smallest_two_indexes_ff = [rd_dist_ff[i].argsort()[:2] for i in range(len(rd_dist_ff))]
178
+ smallest_two_ff = [rd_dist_ff[i][smallest_two_indexes_ff[i]] for i in range(len(rd_dist_ff))]
179
+ nn_ratio_rr = np.array([i[0]/i[1] for i in smallest_two_rr])
180
+ nn_ratio_ff = np.array([i[0]/i[1] for i in smallest_two_ff])
181
+ nn_ratio_rf = np.array([i[0]/i[1] for i in smallest_two_rf])
182
+ nn_fifth_perc_rr = np.percentile(nn_ratio_rr,5)
183
+ nn_fifth_perc_ff = np.percentile(nn_ratio_ff,5)
184
+ nn_fifth_perc_rf = np.percentile(nn_ratio_rf,5)
185
+
186
+ min_dist_rf = np.array([i[0] for i in smallest_two_rf])
187
+ fifth_perc_rf = np.percentile(min_dist_rf,5)
188
+ min_dist_rr = np.array([i[0] for i in smallest_two_rr])
189
+ fifth_perc_rr = np.percentile(min_dist_rr,5)
190
+ min_dist_ff = np.array([i[0] for i in smallest_two_ff])
191
+ fifth_perc_ff = np.percentile(min_dist_ff,5)
192
+
193
+ 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/n18/tabddpm/tabddpm-n18-20260511_002808/_tabddpm_runtime/CTAB-GAN-Plus/model copy/pipeline/data_preparation.py ADDED
@@ -0,0 +1,130 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ import numpy as np
2
+ import pandas as pd
3
+ from sklearn import preprocessing
4
+ from sklearn import model_selection
5
+
6
+ class DataPrep(object):
7
+
8
+ 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):
9
+
10
+
11
+ self.categorical_columns = categorical
12
+ self.log_columns = log
13
+ self.mixed_columns = mixed
14
+ self.general_columns = general
15
+ self.non_categorical_columns = non_categorical
16
+ self.integer_columns = integer
17
+ self.column_types = dict()
18
+ self.column_types["categorical"] = []
19
+ self.column_types["mixed"] = {}
20
+ self.column_types["general"] = []
21
+ self.column_types["non_categorical"] = []
22
+ self.lower_bounds = {}
23
+ self.label_encoder_list = []
24
+
25
+ target_col = list(type.values())[0]
26
+ if target_col is not None:
27
+ y_real = raw_df[target_col]
28
+ X_real = raw_df.drop(columns=[target_col])
29
+ 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)
30
+
31
+ X_train_real[target_col]= y_train_real
32
+
33
+ self.df = X_train_real
34
+ else:
35
+ self.df = raw_df
36
+
37
+ self.df = self.df.replace(r' ', np.nan)
38
+ self.df = self.df.fillna('empty')
39
+
40
+ all_columns= set(self.df.columns)
41
+ irrelevant_missing_columns = set(self.categorical_columns)
42
+ relevant_missing_columns = list(all_columns - irrelevant_missing_columns)
43
+
44
+ for i in relevant_missing_columns:
45
+ if i in self.log_columns:
46
+ if "empty" in list(self.df[i].values):
47
+ self.df[i] = self.df[i].apply(lambda x: -9999999 if x=="empty" else x)
48
+ self.mixed_columns[i] = [-9999999]
49
+ elif i in list(self.mixed_columns.keys()):
50
+ if "empty" in list(self.df[i].values):
51
+ self.df[i] = self.df[i].apply(lambda x: -9999999 if x=="empty" else x )
52
+ self.mixed_columns[i].append(-9999999)
53
+ else:
54
+ if "empty" in list(self.df[i].values):
55
+ self.df[i] = self.df[i].apply(lambda x: -9999999 if x=="empty" else x)
56
+ self.mixed_columns[i] = [-9999999]
57
+
58
+ if self.log_columns:
59
+ for log_column in self.log_columns:
60
+ valid_indices = []
61
+ for idx,val in enumerate(self.df[log_column].values):
62
+ if val!=-9999999:
63
+ valid_indices.append(idx)
64
+ eps = 1
65
+ lower = np.min(self.df[log_column].iloc[valid_indices].values)
66
+ self.lower_bounds[log_column] = lower
67
+ if lower>0:
68
+ self.df[log_column] = self.df[log_column].apply(lambda x: np.log(x) if x!=-9999999 else -9999999)
69
+ elif lower == 0:
70
+ self.df[log_column] = self.df[log_column].apply(lambda x: np.log(x+eps) if x!=-9999999 else -9999999)
71
+ else:
72
+ self.df[log_column] = self.df[log_column].apply(lambda x: np.log(x-lower+eps) if x!=-9999999 else -9999999)
73
+
74
+ for column_index, column in enumerate(self.df.columns):
75
+ if column in self.categorical_columns:
76
+ label_encoder = preprocessing.LabelEncoder()
77
+ self.df[column] = self.df[column].astype(str)
78
+ label_encoder.fit(self.df[column])
79
+ current_label_encoder = dict()
80
+ current_label_encoder['column'] = column
81
+ current_label_encoder['label_encoder'] = label_encoder
82
+ transformed_column = label_encoder.transform(self.df[column])
83
+ self.df[column] = transformed_column
84
+ self.label_encoder_list.append(current_label_encoder)
85
+ self.column_types["categorical"].append(column_index)
86
+
87
+ if column in self.general_columns:
88
+ self.column_types["general"].append(column_index)
89
+
90
+ if column in self.non_categorical_columns:
91
+ self.column_types["non_categorical"].append(column_index)
92
+
93
+ elif column in self.mixed_columns:
94
+ self.column_types["mixed"][column_index] = self.mixed_columns[column]
95
+
96
+ elif column in self.general_columns:
97
+ self.column_types["general"].append(column_index)
98
+
99
+
100
+ super().__init__()
101
+
102
+ def inverse_prep(self, data, eps=1):
103
+
104
+ df_sample = pd.DataFrame(data,columns=self.df.columns)
105
+
106
+ for i in range(len(self.label_encoder_list)):
107
+ le = self.label_encoder_list[i]["label_encoder"]
108
+ df_sample[self.label_encoder_list[i]["column"]] = df_sample[self.label_encoder_list[i]["column"]].astype(int)
109
+ df_sample[self.label_encoder_list[i]["column"]] = le.inverse_transform(df_sample[self.label_encoder_list[i]["column"]])
110
+
111
+ if self.log_columns:
112
+ for i in df_sample:
113
+ if i in self.log_columns:
114
+ lower_bound = self.lower_bounds[i]
115
+ if lower_bound>0:
116
+ df_sample[i].apply(lambda x: np.exp(x))
117
+ elif lower_bound==0:
118
+ 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))
119
+ else:
120
+ df_sample[i] = df_sample[i].apply(lambda x: np.exp(x)-eps+lower_bound)
121
+
122
+ if self.integer_columns:
123
+ for column in self.integer_columns:
124
+ df_sample[column]= (np.round(df_sample[column].values))
125
+ df_sample[column] = df_sample[column].astype(int)
126
+
127
+ df_sample.replace(-9999999, np.nan,inplace=True)
128
+ df_sample.replace('empty', np.nan,inplace=True)
129
+
130
+ return df_sample
syntheticFail/n18/tabddpm/tabddpm-n18-20260511_002808/_tabddpm_runtime/CTAB-GAN-Plus/model copy/privacy_utils/rdp_accountant.py ADDED
@@ -0,0 +1,280 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ from __future__ import absolute_import
2
+ from __future__ import division
3
+ from __future__ import print_function
4
+
5
+ import math
6
+ import sys
7
+
8
+ import numpy as np
9
+ from scipy import special
10
+ import six
11
+
12
+ ########################
13
+ # LOG-SPACE ARITHMETIC #
14
+ ########################
15
+
16
+
17
+ def _log_add(logx, logy):
18
+ """Add two numbers in the log space."""
19
+ a, b = min(logx, logy), max(logx, logy)
20
+ if a == -np.inf: # adding 0
21
+ return b
22
+ # Use exp(a) + exp(b) = (exp(a - b) + 1) * exp(b)
23
+ return math.log1p(math.exp(a - b)) + b # log1p(x) = log(x + 1)
24
+
25
+
26
+ def _log_sub(logx, logy):
27
+ """Subtract two numbers in the log space. Answer must be non-negative."""
28
+ if logx < logy:
29
+ raise ValueError("The result of subtraction must be non-negative.")
30
+ if logy == -np.inf: # subtracting 0
31
+ return logx
32
+ if logx == logy:
33
+ return -np.inf # 0 is represented as -np.inf in the log space.
34
+
35
+ try:
36
+ # Use exp(x) - exp(y) = (exp(x - y) - 1) * exp(y).
37
+ return math.log(math.expm1(logx - logy)) + logy # expm1(x) = exp(x) - 1
38
+ except OverflowError:
39
+ return logx
40
+
41
+
42
+ def _log_print(logx):
43
+ """Pretty print."""
44
+ if logx < math.log(sys.float_info.max):
45
+ return "{}".format(math.exp(logx))
46
+ else:
47
+ return "exp({})".format(logx)
48
+
49
+
50
+ def _compute_log_a_int(q, sigma, alpha):
51
+ """Compute log(A_alpha) for integer alpha. 0 < q < 1."""
52
+ assert isinstance(alpha, six.integer_types)
53
+
54
+ # Initialize with 0 in the log space.
55
+ log_a = -np.inf
56
+
57
+ for i in range(alpha + 1):
58
+ log_coef_i = (
59
+ math.log(special.binom(alpha, i)) + i * math.log(q) +
60
+ (alpha - i) * math.log(1 - q))
61
+
62
+ s = log_coef_i + (i * i - i) / (2 * (sigma**2))
63
+ log_a = _log_add(log_a, s)
64
+
65
+ return float(log_a)
66
+
67
+
68
+ def _compute_log_a_frac(q, sigma, alpha):
69
+ """Compute log(A_alpha) for fractional alpha. 0 < q < 1."""
70
+ # The two parts of A_alpha, integrals over (-inf,z0] and [z0, +inf), are
71
+ # initialized to 0 in the log space:
72
+ log_a0, log_a1 = -np.inf, -np.inf
73
+ i = 0
74
+
75
+ z0 = sigma**2 * math.log(1 / q - 1) + .5
76
+
77
+ while True: # do ... until loop
78
+ coef = special.binom(alpha, i)
79
+ log_coef = math.log(abs(coef))
80
+ j = alpha - i
81
+
82
+ log_t0 = log_coef + i * math.log(q) + j * math.log(1 - q)
83
+ log_t1 = log_coef + j * math.log(q) + i * math.log(1 - q)
84
+
85
+ log_e0 = math.log(.5) + _log_erfc((i - z0) / (math.sqrt(2) * sigma))
86
+ log_e1 = math.log(.5) + _log_erfc((z0 - j) / (math.sqrt(2) * sigma))
87
+
88
+ log_s0 = log_t0 + (i * i - i) / (2 * (sigma**2)) + log_e0
89
+ log_s1 = log_t1 + (j * j - j) / (2 * (sigma**2)) + log_e1
90
+
91
+ if coef > 0:
92
+ log_a0 = _log_add(log_a0, log_s0)
93
+ log_a1 = _log_add(log_a1, log_s1)
94
+ else:
95
+ log_a0 = _log_sub(log_a0, log_s0)
96
+ log_a1 = _log_sub(log_a1, log_s1)
97
+
98
+ i += 1
99
+ if max(log_s0, log_s1) < -30:
100
+ break
101
+
102
+ return _log_add(log_a0, log_a1)
103
+
104
+
105
+ def _compute_log_a(q, sigma, alpha):
106
+ """Compute log(A_alpha) for any positive finite alpha."""
107
+ if float(alpha).is_integer():
108
+ return _compute_log_a_int(q, sigma, int(alpha))
109
+ else:
110
+ return _compute_log_a_frac(q, sigma, alpha)
111
+
112
+
113
+ def _log_erfc(x):
114
+ """Compute log(erfc(x)) with high accuracy for large x."""
115
+ try:
116
+ return math.log(2) + special.log_ndtr(-x * 2**.5)
117
+ except NameError:
118
+ # If log_ndtr is not available, approximate as follows:
119
+ r = special.erfc(x)
120
+ if r == 0.0:
121
+ # Using the Laurent series at infinity for the tail of the erfc function:
122
+ # erfc(x) ~ exp(-x^2-.5/x^2+.625/x^4)/(x*pi^.5)
123
+ # To verify in Mathematica:
124
+ # Series[Log[Erfc[x]] + Log[x] + Log[Pi]/2 + x^2, {x, Infinity, 6}]
125
+ return (-math.log(math.pi) / 2 - math.log(x) - x**2 - .5 * x**-2 +
126
+ .625 * x**-4 - 37. / 24. * x**-6 + 353. / 64. * x**-8)
127
+ else:
128
+ return math.log(r)
129
+
130
+
131
+ def _compute_delta(orders, rdp, eps):
132
+ """Compute delta given a list of RDP values and target epsilon.
133
+
134
+ Args:
135
+ orders: An array (or a scalar) of orders.
136
+ rdp: A list (or a scalar) of RDP guarantees.
137
+ eps: The target epsilon.
138
+
139
+ Returns:
140
+ Pair of (delta, optimal_order).
141
+
142
+ Raises:
143
+ ValueError: If input is malformed.
144
+
145
+ """
146
+ orders_vec = np.atleast_1d(orders)
147
+ rdp_vec = np.atleast_1d(rdp)
148
+
149
+ if len(orders_vec) != len(rdp_vec):
150
+ raise ValueError("Input lists must have the same length.")
151
+
152
+ deltas = np.exp((rdp_vec - eps) * (orders_vec - 1))
153
+ idx_opt = np.argmin(deltas)
154
+ return min(deltas[idx_opt], 1.), orders_vec[idx_opt]
155
+
156
+
157
+ def _compute_eps(orders, rdp, delta):
158
+ """Compute epsilon given a list of RDP values and target delta.
159
+
160
+ Args:
161
+ orders: An array (or a scalar) of orders.
162
+ rdp: A list (or a scalar) of RDP guarantees.
163
+ delta: The target delta.
164
+
165
+ Returns:
166
+ Pair of (eps, optimal_order).
167
+
168
+ Raises:
169
+ ValueError: If input is malformed.
170
+
171
+ """
172
+ orders_vec = np.atleast_1d(orders)
173
+ rdp_vec = np.atleast_1d(rdp)
174
+
175
+ if len(orders_vec) != len(rdp_vec):
176
+ raise ValueError("Input lists must have the same length.")
177
+
178
+ eps = rdp_vec - math.log(delta) / (orders_vec - 1)
179
+
180
+ idx_opt = np.nanargmin(eps) # Ignore NaNs
181
+ return eps[idx_opt], orders_vec[idx_opt]
182
+
183
+
184
+ def _compute_rdp(q, sigma, alpha):
185
+ """Compute RDP of the Sampled Gaussian mechanism at order alpha.
186
+
187
+ Args:
188
+ q: The sampling rate.
189
+ sigma: The std of the additive Gaussian noise.
190
+ alpha: The order at which RDP is computed.
191
+
192
+ Returns:
193
+ RDP at alpha, can be np.inf.
194
+ """
195
+ if q == 0:
196
+ return 0
197
+
198
+ if q == 1.:
199
+ return alpha / (2 * sigma**2)
200
+
201
+ if np.isinf(alpha):
202
+ return np.inf
203
+
204
+ return _compute_log_a(q, sigma, alpha) / (alpha - 1)
205
+
206
+
207
+ def compute_rdp(q, noise_multiplier, steps, orders):
208
+ """Compute RDP of the Sampled Gaussian Mechanism.
209
+
210
+ Args:
211
+ q: The sampling rate.
212
+ noise_multiplier: The ratio of the standard deviation of the Gaussian noise
213
+ to the l2-sensitivity of the function to which it is added.
214
+ steps: The number of steps.
215
+ orders: An array (or a scalar) of RDP orders.
216
+
217
+ Returns:
218
+ The RDPs at all orders, can be np.inf.
219
+ """
220
+ if np.isscalar(orders):
221
+ rdp = _compute_rdp(q, noise_multiplier, orders)
222
+ else:
223
+ rdp = np.array([_compute_rdp(q, noise_multiplier, order)
224
+ for order in orders])
225
+
226
+ return rdp * steps
227
+
228
+
229
+ def get_privacy_spent(orders, rdp, target_eps=None, target_delta=None):
230
+ """Compute delta (or eps) for given eps (or delta) from RDP values.
231
+
232
+ Args:
233
+ orders: An array (or a scalar) of RDP orders.
234
+ rdp: An array of RDP values. Must be of the same length as the orders list.
235
+ target_eps: If not None, the epsilon for which we compute the corresponding
236
+ delta.
237
+ target_delta: If not None, the delta for which we compute the corresponding
238
+ epsilon. Exactly one of target_eps and target_delta must be None.
239
+
240
+ Returns:
241
+ eps, delta, opt_order.
242
+
243
+ Raises:
244
+ ValueError: If target_eps and target_delta are messed up.
245
+ """
246
+ if target_eps is None and target_delta is None:
247
+ raise ValueError(
248
+ "Exactly one out of eps and delta must be None. (Both are).")
249
+
250
+ if target_eps is not None and target_delta is not None:
251
+ raise ValueError(
252
+ "Exactly one out of eps and delta must be None. (None is).")
253
+
254
+ if target_eps is not None:
255
+ delta, opt_order = _compute_delta(orders, rdp, target_eps)
256
+ return target_eps, delta, opt_order
257
+ else:
258
+ eps, opt_order = _compute_eps(orders, rdp, target_delta)
259
+ return eps, target_delta, opt_order
260
+
261
+
262
+ def compute_rdp_from_ledger(ledger, orders):
263
+ """Compute RDP of Sampled Gaussian Mechanism from ledger.
264
+
265
+ Args:
266
+ ledger: A formatted privacy ledger.
267
+ orders: An array (or a scalar) of RDP orders.
268
+
269
+ Returns:
270
+ RDP at all orders, can be np.inf.
271
+ """
272
+ total_rdp = np.zeros_like(orders, dtype=float)
273
+ for sample in ledger:
274
+ # Compute equivalent z from l2_clip_bounds and noise stddevs in sample.
275
+ # See https://arxiv.org/pdf/1812.06210.pdf for derivation of this formula.
276
+ effective_z = sum([
277
+ (q.noise_stddev / q.l2_norm_bound)**-2 for q in sample.queries])**-0.5
278
+ total_rdp += compute_rdp(
279
+ sample.selection_probability, effective_z, 1, orders)
280
+ return total_rdp
syntheticFail/n18/tabddpm/tabddpm-n18-20260511_002808/_tabddpm_runtime/CTAB-GAN-Plus/model copy/synthesizer/ctabgan_synthesizer.py ADDED
@@ -0,0 +1,601 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ import numpy as np
2
+ import pandas as pd
3
+ import torch
4
+ import torch.utils.data
5
+ import torch.optim as optim
6
+ from torch.optim import Adam
7
+ from torch.nn import functional as F
8
+ from torch.nn import (Dropout, LeakyReLU, Linear, Module, ReLU, Sequential,
9
+ Conv2d, ConvTranspose2d, Sigmoid, init, BCELoss, CrossEntropyLoss,SmoothL1Loss,LayerNorm)
10
+ from model.synthesizer.transformer import ImageTransformer,DataTransformer
11
+ from model.privacy_utils.rdp_accountant import compute_rdp, get_privacy_spent
12
+ from tqdm import tqdm
13
+
14
+
15
+ class Classifier(Module):
16
+ def __init__(self,input_dim, dis_dims,st_ed):
17
+ super(Classifier,self).__init__()
18
+ dim = input_dim-(st_ed[1]-st_ed[0])
19
+ seq = []
20
+ self.str_end = st_ed
21
+ for item in list(dis_dims):
22
+ seq += [
23
+ Linear(dim, item),
24
+ LeakyReLU(0.2),
25
+ Dropout(0.5)
26
+ ]
27
+ dim = item
28
+
29
+ if (st_ed[1]-st_ed[0])==1:
30
+ seq += [Linear(dim, 1)]
31
+
32
+ elif (st_ed[1]-st_ed[0])==2:
33
+ seq += [Linear(dim, 1),Sigmoid()]
34
+ else:
35
+ seq += [Linear(dim,(st_ed[1]-st_ed[0]))]
36
+
37
+ self.seq = Sequential(*seq)
38
+
39
+ def forward(self, input):
40
+
41
+ label=None
42
+
43
+ if (self.str_end[1]-self.str_end[0])==1:
44
+ label = input[:, self.str_end[0]:self.str_end[1]]
45
+ else:
46
+ label = torch.argmax(input[:, self.str_end[0]:self.str_end[1]], axis=-1)
47
+
48
+ new_imp = torch.cat((input[:,:self.str_end[0]],input[:,self.str_end[1]:]),1)
49
+
50
+ if ((self.str_end[1]-self.str_end[0])==2) | ((self.str_end[1]-self.str_end[0])==1):
51
+ return self.seq(new_imp).view(-1), label
52
+ else:
53
+ return self.seq(new_imp), label
54
+
55
+ def apply_activate(data, output_info):
56
+ data_t = []
57
+ st = 0
58
+ for item in output_info:
59
+ if item[1] == 'tanh':
60
+ ed = st + item[0]
61
+ data_t.append(torch.tanh(data[:, st:ed]))
62
+ st = ed
63
+ elif item[1] == 'softmax':
64
+ ed = st + item[0]
65
+ data_t.append(F.gumbel_softmax(data[:, st:ed], tau=0.2))
66
+ st = ed
67
+ return torch.cat(data_t, dim=1)
68
+
69
+ def get_st_ed(target_col_index,output_info):
70
+ st = 0
71
+ c= 0
72
+ tc= 0
73
+
74
+ for item in output_info:
75
+ if c==target_col_index:
76
+ break
77
+ if item[1]=='tanh':
78
+ st += item[0]
79
+ if item[2] == 'yes_g':
80
+ c+=1
81
+ elif item[1] == 'softmax':
82
+ st += item[0]
83
+ c+=1
84
+ tc+=1
85
+
86
+ ed= st+output_info[tc][0]
87
+
88
+ return (st,ed)
89
+
90
+ def random_choice_prob_index_sampling(probs,col_idx):
91
+ option_list = []
92
+ for i in col_idx:
93
+ pp = probs[i]
94
+ option_list.append(np.random.choice(np.arange(len(probs[i])), p=pp))
95
+
96
+ return np.array(option_list).reshape(col_idx.shape)
97
+
98
+ def random_choice_prob_index(a, axis=1):
99
+ r = np.expand_dims(np.random.rand(a.shape[1 - axis]), axis=axis)
100
+ return (a.cumsum(axis=axis) > r).argmax(axis=axis)
101
+
102
+ def maximum_interval(output_info):
103
+ max_interval = 0
104
+ for item in output_info:
105
+ max_interval = max(max_interval, item[0])
106
+ return max_interval
107
+
108
+ class Cond(object):
109
+ def __init__(self, data, output_info):
110
+
111
+ self.model = []
112
+ st = 0
113
+ counter = 0
114
+ for item in output_info:
115
+
116
+ if item[1] == 'tanh':
117
+ st += item[0]
118
+ continue
119
+ elif item[1] == 'softmax':
120
+ ed = st + item[0]
121
+ counter += 1
122
+ self.model.append(np.argmax(data[:, st:ed], axis=-1))
123
+ st = ed
124
+
125
+ self.interval = []
126
+ self.n_col = 0
127
+ self.n_opt = 0
128
+ st = 0
129
+ self.p = np.zeros((counter, maximum_interval(output_info)))
130
+ self.p_sampling = []
131
+ for item in output_info:
132
+ if item[1] == 'tanh':
133
+ st += item[0]
134
+ continue
135
+ elif item[1] == 'softmax':
136
+ ed = st + item[0]
137
+ tmp = np.sum(data[:, st:ed], axis=0)
138
+ tmp_sampling = np.sum(data[:, st:ed], axis=0)
139
+ tmp = np.log(tmp + 1)
140
+ tmp = tmp / np.sum(tmp)
141
+ tmp_sampling = tmp_sampling / np.sum(tmp_sampling)
142
+ self.p_sampling.append(tmp_sampling)
143
+ self.p[self.n_col, :item[0]] = tmp
144
+ self.interval.append((self.n_opt, item[0]))
145
+ self.n_opt += item[0]
146
+ self.n_col += 1
147
+ st = ed
148
+
149
+ self.interval = np.asarray(self.interval)
150
+
151
+ def sample_train(self, batch):
152
+ if self.n_col == 0:
153
+ return None
154
+ batch = batch
155
+
156
+ idx = np.random.choice(np.arange(self.n_col), batch)
157
+
158
+ vec = np.zeros((batch, self.n_opt), dtype='float32')
159
+ mask = np.zeros((batch, self.n_col), dtype='float32')
160
+ mask[np.arange(batch), idx] = 1
161
+ opt1prime = random_choice_prob_index(self.p[idx])
162
+ for i in np.arange(batch):
163
+ vec[i, self.interval[idx[i], 0] + opt1prime[i]] = 1
164
+
165
+ return vec, mask, idx, opt1prime
166
+
167
+ def sample(self, batch):
168
+ if self.n_col == 0:
169
+ return None
170
+ batch = batch
171
+
172
+ idx = np.random.choice(np.arange(self.n_col), batch)
173
+
174
+ vec = np.zeros((batch, self.n_opt), dtype='float32')
175
+ opt1prime = random_choice_prob_index_sampling(self.p_sampling,idx)
176
+
177
+ for i in np.arange(batch):
178
+ vec[i, self.interval[idx[i], 0] + opt1prime[i]] = 1
179
+
180
+ return vec
181
+
182
+ def cond_loss(data, output_info, c, m):
183
+ loss = []
184
+ st = 0
185
+ st_c = 0
186
+ for item in output_info:
187
+ if item[1] == 'tanh':
188
+ st += item[0]
189
+ continue
190
+
191
+ elif item[1] == 'softmax':
192
+ ed = st + item[0]
193
+ ed_c = st_c + item[0]
194
+ tmp = F.cross_entropy(
195
+ data[:, st:ed],
196
+ torch.argmax(c[:, st_c:ed_c], dim=1),
197
+ reduction='none')
198
+ loss.append(tmp)
199
+ st = ed
200
+ st_c = ed_c
201
+
202
+ loss = torch.stack(loss, dim=1)
203
+ return (loss * m).sum() / data.size()[0]
204
+
205
+ class Sampler(object):
206
+ def __init__(self, data, output_info):
207
+ super(Sampler, self).__init__()
208
+ self.data = data
209
+ self.model = []
210
+ self.n = len(data)
211
+ st = 0
212
+ for item in output_info:
213
+ if item[1] == 'tanh':
214
+ st += item[0]
215
+ continue
216
+ elif item[1] == 'softmax':
217
+ ed = st + item[0]
218
+ tmp = []
219
+ for j in range(item[0]):
220
+ tmp.append(np.nonzero(data[:, st + j])[0])
221
+ self.model.append(tmp)
222
+ st = ed
223
+
224
+ def sample(self, n, col, opt):
225
+ if col is None:
226
+ idx = np.random.choice(np.arange(self.n), n)
227
+ return self.data[idx]
228
+ idx = []
229
+ for c, o in zip(col, opt):
230
+ idx.append(np.random.choice(self.model[c][o]))
231
+ return self.data[idx]
232
+
233
+ class Discriminator(Module):
234
+ def __init__(self, side, layers):
235
+ super(Discriminator, self).__init__()
236
+ self.side = side
237
+ info = len(layers)-2
238
+ self.seq = Sequential(*layers)
239
+ self.seq_info = Sequential(*layers[:info])
240
+
241
+ def forward(self, input):
242
+ return (self.seq(input)), self.seq_info(input)
243
+
244
+ class Generator(Module):
245
+ def __init__(self, side, layers):
246
+ super(Generator, self).__init__()
247
+ self.side = side
248
+ self.seq = Sequential(*layers)
249
+
250
+ def forward(self, input_):
251
+ return self.seq(input_)
252
+
253
+ def determine_layers_disc(side, num_channels):
254
+ assert side >= 4 and side <= 64
255
+
256
+ layer_dims = [(1, side), (num_channels, side // 2)]
257
+
258
+ while layer_dims[-1][1] > 3 and len(layer_dims) < 4:
259
+ layer_dims.append((layer_dims[-1][0] * 2, layer_dims[-1][1] // 2))
260
+
261
+ layerNorms = []
262
+ num_c = num_channels
263
+ num_s = side / 2
264
+ for l in range(len(layer_dims) - 1):
265
+ layerNorms.append([int(num_c), int(num_s), int(num_s)])
266
+ num_c = num_c * 2
267
+ num_s = num_s / 2
268
+
269
+ layers_D = []
270
+
271
+ for prev, curr, ln in zip(layer_dims, layer_dims[1:], layerNorms):
272
+ layers_D += [
273
+ Conv2d(prev[0], curr[0], 4, 2, 1, bias=False),
274
+ LayerNorm(ln),
275
+ LeakyReLU(0.2, inplace=True),
276
+ ]
277
+
278
+ layers_D += [Conv2d(layer_dims[-1][0], 1, layer_dims[-1][1], 1, 0), ReLU(True)]
279
+
280
+ return layers_D
281
+
282
+ def determine_layers_gen(side, random_dim, num_channels):
283
+ assert side >= 4 and side <= 64
284
+
285
+ layer_dims = [(1, side), (num_channels, side // 2)]
286
+
287
+ while layer_dims[-1][1] > 3 and len(layer_dims) < 4:
288
+ layer_dims.append((layer_dims[-1][0] * 2, layer_dims[-1][1] // 2))
289
+
290
+ layerNorms = []
291
+
292
+ num_c = num_channels * (2 ** (len(layer_dims) - 2))
293
+ num_s = int(side / (2 ** (len(layer_dims) - 1)))
294
+ for l in range(len(layer_dims) - 1):
295
+ layerNorms.append([int(num_c), int(num_s), int(num_s)])
296
+ num_c = num_c / 2
297
+ num_s = num_s * 2
298
+
299
+ layers_G = [ConvTranspose2d(random_dim, layer_dims[-1][0], layer_dims[-1][1], 1, 0, output_padding=0, bias=False)]
300
+
301
+ for prev, curr, ln in zip(reversed(layer_dims), reversed(layer_dims[:-1]), layerNorms):
302
+ layers_G += [LayerNorm(ln), ReLU(True), ConvTranspose2d(prev[0], curr[0], 4, 2, 1, output_padding=0, bias=True)]
303
+ return layers_G
304
+
305
+ def slerp(val, low, high):
306
+ low_norm = low/torch.norm(low, dim=1, keepdim=True)
307
+ high_norm = high/torch.norm(high, dim=1, keepdim=True)
308
+ omega = torch.acos((low_norm*high_norm).sum(1)).view(val.size(0), 1)
309
+ so = torch.sin(omega)
310
+ res = (torch.sin((1.0-val)*omega)/so)*low + (torch.sin(val*omega)/so) * high
311
+
312
+ return res
313
+
314
+ def calc_gradient_penalty_slerp(netD, real_data, fake_data, transformer, device='cpu', lambda_=10):
315
+ batchsize = real_data.shape[0]
316
+ alpha = torch.rand(batchsize, 1, device=device)
317
+ interpolates = slerp(alpha, real_data, fake_data)
318
+ interpolates = interpolates.to(device)
319
+ interpolates = transformer.transform(interpolates)
320
+ interpolates = torch.autograd.Variable(interpolates, requires_grad=True)
321
+ disc_interpolates,_ = netD(interpolates)
322
+
323
+ gradients = torch.autograd.grad(outputs=disc_interpolates, inputs=interpolates,
324
+ grad_outputs=torch.ones(disc_interpolates.size()).to(device),
325
+ create_graph=True, retain_graph=True, only_inputs=True)[0]
326
+
327
+ gradients_norm = gradients.norm(2, dim=1)
328
+ gradient_penalty = ((gradients_norm - 1) ** 2).mean() * lambda_
329
+
330
+ return gradient_penalty
331
+
332
+ def weights_init(m):
333
+ classname = m.__class__.__name__
334
+
335
+ if classname.find('Conv') != -1:
336
+ init.normal_(m.weight.data, 0.0, 0.02)
337
+
338
+ elif classname.find('BatchNorm') != -1:
339
+ init.normal_(m.weight.data, 1.0, 0.02)
340
+ init.constant_(m.bias.data, 0)
341
+
342
+ class CTABGANSynthesizer:
343
+ def __init__(self,
344
+ class_dim=(256, 256, 256, 256),
345
+ random_dim=100,
346
+ num_channels=64,
347
+ l2scale=1e-5,
348
+ batch_size=500,
349
+ epochs=150,
350
+ device="cpu"):
351
+
352
+
353
+ self.random_dim = random_dim
354
+ self.class_dim = class_dim
355
+ self.num_channels = num_channels
356
+ self.dside = None
357
+ self.gside = None
358
+ self.l2scale = l2scale
359
+ self.batch_size = batch_size
360
+ self.epochs = epochs
361
+ self.device = torch.device(device)
362
+
363
+ def fit(self, train_data=pd.DataFrame, categorical=[], mixed={}, general=[], non_categorical=[], type={}):
364
+
365
+ problem_type = None
366
+ target_index=None
367
+ if type:
368
+ problem_type = list(type.keys())[0]
369
+ if problem_type:
370
+ target_index = train_data.columns.get_loc(type[problem_type])
371
+
372
+ self.transformer = DataTransformer(train_data=train_data, categorical_list=categorical, mixed_dict=mixed, general_list=general, non_categorical_list=non_categorical)
373
+ self.transformer.fit()
374
+ train_data = self.transformer.transform(train_data.values)
375
+ data_sampler = Sampler(train_data, self.transformer.output_info)
376
+ data_dim = self.transformer.output_dim
377
+ self.cond_generator = Cond(train_data, self.transformer.output_info)
378
+
379
+ sides = [4, 8, 16, 24, 64]
380
+ col_size_d = data_dim + self.cond_generator.n_opt
381
+ for i in sides:
382
+ if i * i >= col_size_d:
383
+ self.dside = i
384
+ break
385
+
386
+ sides = [4, 8, 16, 24, 64]
387
+ col_size_g = data_dim
388
+ for i in sides:
389
+ if i * i >= col_size_g:
390
+ self.gside = i
391
+ break
392
+
393
+
394
+ layers_G = determine_layers_gen(self.gside, self.random_dim+self.cond_generator.n_opt, self.num_channels)
395
+ layers_D = determine_layers_disc(self.dside, self.num_channels)
396
+
397
+ self.generator = Generator(self.gside, layers_G).to(self.device)
398
+ discriminator = Discriminator(self.dside, layers_D).to(self.device)
399
+ optimizer_params = dict(lr=2e-4, betas=(0.5, 0.9), eps=1e-3, weight_decay=self.l2scale)
400
+ optimizerG = Adam(self.generator.parameters(), **optimizer_params)
401
+ optimizerD = Adam(discriminator.parameters(), **optimizer_params)
402
+
403
+ st_ed = None
404
+ classifier=None
405
+ optimizerC= None
406
+ if target_index != None:
407
+ st_ed= get_st_ed(target_index,self.transformer.output_info)
408
+ classifier = Classifier(data_dim,self.class_dim,st_ed).to(self.device)
409
+ optimizerC = optim.Adam(classifier.parameters(),**optimizer_params)
410
+
411
+
412
+ self.generator.apply(weights_init)
413
+ discriminator.apply(weights_init)
414
+
415
+ self.Gtransformer = ImageTransformer(self.gside)
416
+ self.Dtransformer = ImageTransformer(self.dside)
417
+
418
+ epsilon = 0
419
+ epoch = 0
420
+ steps = 0
421
+ ci = 1
422
+
423
+ for i in tqdm(range(self.epochs)):
424
+
425
+
426
+ for _ in range(ci):
427
+ noisez = torch.randn(self.batch_size, self.random_dim, device=self.device)
428
+ condvec = self.cond_generator.sample_train(self.batch_size)
429
+
430
+ c, m, col, opt = condvec
431
+ c = torch.from_numpy(c).to(self.device)
432
+ m = torch.from_numpy(m).to(self.device)
433
+ noisez = torch.cat([noisez, c], dim=1)
434
+ noisez = noisez.view(self.batch_size,self.random_dim+self.cond_generator.n_opt,1,1)
435
+
436
+ perm = np.arange(self.batch_size)
437
+ np.random.shuffle(perm)
438
+ real = data_sampler.sample(self.batch_size, col[perm], opt[perm])
439
+ c_perm = c[perm]
440
+
441
+ real = torch.from_numpy(real.astype('float32')).to(self.device)
442
+
443
+ fake = self.generator(noisez)
444
+ faket = self.Gtransformer.inverse_transform(fake)
445
+ fakeact = apply_activate(faket, self.transformer.output_info)
446
+
447
+ fake_cat = torch.cat([fakeact, c], dim=1)
448
+ real_cat = torch.cat([real, c_perm], dim=1)
449
+
450
+ real_cat_d = self.Dtransformer.transform(real_cat)
451
+ fake_cat_d = self.Dtransformer.transform(fake_cat)
452
+
453
+ optimizerD.zero_grad()
454
+
455
+ d_real,_ = discriminator(real_cat_d)
456
+
457
+
458
+ d_real = -torch.mean(d_real)
459
+ d_real.backward()
460
+
461
+
462
+ d_fake,_ = discriminator(fake_cat_d)
463
+
464
+ d_fake = torch.mean(d_fake)
465
+
466
+ d_fake.backward()
467
+
468
+ pen = calc_gradient_penalty_slerp(discriminator, real_cat, fake_cat, self.Dtransformer , self.device)
469
+
470
+ pen.backward()
471
+
472
+ optimizerD.step()
473
+
474
+ noisez = torch.randn(self.batch_size, self.random_dim, device=self.device)
475
+
476
+ condvec = self.cond_generator.sample_train(self.batch_size)
477
+
478
+ c, m, col, opt = condvec
479
+ c = torch.from_numpy(c).to(self.device)
480
+ m = torch.from_numpy(m).to(self.device)
481
+ noisez = torch.cat([noisez, c], dim=1)
482
+ noisez = noisez.view(self.batch_size,self.random_dim+self.cond_generator.n_opt,1,1)
483
+
484
+ optimizerG.zero_grad()
485
+
486
+ fake = self.generator(noisez)
487
+ faket = self.Gtransformer.inverse_transform(fake)
488
+ fakeact = apply_activate(faket, self.transformer.output_info)
489
+
490
+ fake_cat = torch.cat([fakeact, c], dim=1)
491
+ fake_cat = self.Dtransformer.transform(fake_cat)
492
+
493
+ y_fake,info_fake = discriminator(fake_cat)
494
+
495
+ cross_entropy = cond_loss(faket, self.transformer.output_info, c, m)
496
+
497
+ _,info_real = discriminator(real_cat_d)
498
+
499
+
500
+ g = -torch.mean(y_fake) + cross_entropy
501
+ g.backward(retain_graph=True)
502
+ 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)
503
+ 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)
504
+ loss_info = loss_mean + loss_std
505
+ loss_info.backward()
506
+ optimizerG.step()
507
+
508
+
509
+ if problem_type:
510
+
511
+ fake = self.generator(noisez)
512
+
513
+ faket = self.Gtransformer.inverse_transform(fake)
514
+
515
+ fakeact = apply_activate(faket, self.transformer.output_info)
516
+
517
+ real_pre, real_label = classifier(real)
518
+ fake_pre, fake_label = classifier(fakeact)
519
+
520
+ c_loss = CrossEntropyLoss()
521
+
522
+ if (st_ed[1] - st_ed[0])==1:
523
+ c_loss= SmoothL1Loss()
524
+ real_label = real_label.type_as(real_pre)
525
+ fake_label = fake_label.type_as(fake_pre)
526
+ real_label = torch.reshape(real_label,real_pre.size())
527
+ fake_label = torch.reshape(fake_label,fake_pre.size())
528
+
529
+
530
+ elif (st_ed[1] - st_ed[0])==2:
531
+ c_loss = BCELoss()
532
+ real_label = real_label.type_as(real_pre)
533
+ fake_label = fake_label.type_as(fake_pre)
534
+
535
+ loss_cc = c_loss(real_pre, real_label)
536
+ loss_cg = c_loss(fake_pre, fake_label)
537
+
538
+ optimizerG.zero_grad()
539
+ loss_cg.backward()
540
+ optimizerG.step()
541
+
542
+ optimizerC.zero_grad()
543
+ loss_cc.backward()
544
+ optimizerC.step()
545
+
546
+
547
+
548
+
549
+ @torch.no_grad()
550
+ def sample(self, n, seed=0):
551
+
552
+ torch.manual_seed(seed)
553
+ torch.cuda.manual_seed(seed)
554
+ sample_batch_size = 8092
555
+ self.generator.eval()
556
+
557
+ output_info = self.transformer.output_info
558
+ steps = n // sample_batch_size + 1
559
+
560
+ data = []
561
+
562
+ for i in range(steps):
563
+ noisez = torch.randn(self.batch_size, self.random_dim, device=self.device)
564
+ condvec = self.cond_generator.sample(self.batch_size)
565
+ c = condvec
566
+ c = torch.from_numpy(c).to(self.device)
567
+ noisez = torch.cat([noisez, c], dim=1)
568
+ noisez = noisez.view(self.batch_size,self.random_dim+self.cond_generator.n_opt,1,1)
569
+
570
+ fake = self.generator(noisez)
571
+ faket = self.Gtransformer.inverse_transform(fake)
572
+ fakeact = apply_activate(faket,output_info)
573
+ data.append(fakeact.detach().cpu().numpy())
574
+
575
+ data = np.concatenate(data, axis=0)
576
+ result,resample = self.transformer.inverse_transform(data)
577
+
578
+ while len(result) < n:
579
+ data_resample = []
580
+ steps_left = resample// self.batch_size + 1
581
+
582
+ for i in range(steps_left):
583
+ noisez = torch.randn(self.batch_size, self.random_dim, device=self.device)
584
+ condvec = self.cond_generator.sample(self.batch_size)
585
+ c = condvec
586
+ c = torch.from_numpy(c).to(self.device)
587
+ noisez = torch.cat([noisez, c], dim=1)
588
+ noisez = noisez.view(self.batch_size,self.random_dim+self.cond_generator.n_opt,1,1)
589
+
590
+ fake = self.generator(noisez)
591
+ faket = self.Gtransformer.inverse_transform(fake)
592
+ fakeact = apply_activate(faket, output_info)
593
+ data_resample.append(fakeact.detach().cpu().numpy())
594
+
595
+ data_resample = np.concatenate(data_resample, axis=0)
596
+
597
+ res,resample = self.transformer.inverse_transform(data_resample)
598
+ result = np.concatenate([result,res],axis=0)
599
+
600
+ return result[0:n]
601
+
syntheticFail/n18/tabddpm/tabddpm-n18-20260511_002808/_tabddpm_runtime/CTAB-GAN-Plus/model copy/synthesizer/transformer.py ADDED
@@ -0,0 +1,429 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ import numpy as np
2
+ import pandas as pd
3
+ import torch
4
+ from sklearn.mixture import BayesianGaussianMixture
5
+
6
+ class DataTransformer():
7
+
8
+ def __init__(self, train_data=pd.DataFrame, categorical_list=[], mixed_dict={}, general_list=[], non_categorical_list=[], n_clusters=10, eps=0.005):
9
+ self.meta = None
10
+ self.n_clusters = n_clusters
11
+ self.eps = eps
12
+ self.train_data = train_data
13
+ self.categorical_columns= categorical_list
14
+ self.mixed_columns= mixed_dict
15
+ self.general_columns = general_list
16
+ self.non_categorical_columns= non_categorical_list
17
+
18
+ def get_metadata(self):
19
+
20
+ meta = []
21
+
22
+ for index in range(self.train_data.shape[1]):
23
+ column = self.train_data.iloc[:,index]
24
+ if index in self.categorical_columns:
25
+ if index in self.non_categorical_columns:
26
+ meta.append({
27
+ "name": index,
28
+ "type": "continuous",
29
+ "min": column.min(),
30
+ "max": column.max(),
31
+ })
32
+ else:
33
+ mapper = column.value_counts().index.tolist()
34
+ meta.append({
35
+ "name": index,
36
+ "type": "categorical",
37
+ "size": len(mapper),
38
+ "i2s": mapper
39
+ })
40
+
41
+ elif index in self.mixed_columns.keys():
42
+ meta.append({
43
+ "name": index,
44
+ "type": "mixed",
45
+ "min": column.min(),
46
+ "max": column.max(),
47
+ "modal": self.mixed_columns[index]
48
+ })
49
+ else:
50
+ meta.append({
51
+ "name": index,
52
+ "type": "continuous",
53
+ "min": column.min(),
54
+ "max": column.max(),
55
+ })
56
+
57
+ return meta
58
+
59
+ def fit(self):
60
+ data = self.train_data.values
61
+ self.meta = self.get_metadata()
62
+ model = []
63
+ self.ordering = []
64
+ self.output_info = []
65
+ self.output_dim = 0
66
+ self.components = []
67
+ self.filter_arr = []
68
+ for id_, info in enumerate(self.meta):
69
+ if info['type'] == "continuous":
70
+ if id_ not in self.general_columns:
71
+ gm = BayesianGaussianMixture(
72
+ n_components = self.n_clusters,
73
+ weight_concentration_prior_type='dirichlet_process',
74
+ weight_concentration_prior=0.001,
75
+ max_iter=100,n_init=1, random_state=42)
76
+ gm.fit(data[:, id_].reshape([-1, 1]))
77
+ mode_freq = (pd.Series(gm.predict(data[:, id_].reshape([-1, 1]))).value_counts().keys())
78
+ model.append(gm)
79
+ old_comp = gm.weights_ > self.eps
80
+ comp = []
81
+ for i in range(self.n_clusters):
82
+ if (i in (mode_freq)) & old_comp[i]:
83
+ comp.append(True)
84
+ else:
85
+ comp.append(False)
86
+ self.components.append(comp)
87
+ self.output_info += [(1, 'tanh','no_g'), (np.sum(comp), 'softmax')]
88
+ self.output_dim += 1 + np.sum(comp)
89
+ else:
90
+ model.append(None)
91
+ self.components.append(None)
92
+ self.output_info += [(1, 'tanh','yes_g')]
93
+ self.output_dim += 1
94
+
95
+ elif info['type'] == "mixed":
96
+
97
+ gm1 = BayesianGaussianMixture(
98
+ n_components = self.n_clusters,
99
+ weight_concentration_prior_type='dirichlet_process',
100
+ weight_concentration_prior=0.001, max_iter=100,
101
+ n_init=1,random_state=42)
102
+ gm2 = BayesianGaussianMixture(
103
+ n_components = self.n_clusters,
104
+ weight_concentration_prior_type='dirichlet_process',
105
+ weight_concentration_prior=0.001, max_iter=100,
106
+ n_init=1,random_state=42)
107
+
108
+ gm1.fit(data[:, id_].reshape([-1, 1]))
109
+
110
+ filter_arr = []
111
+ for element in data[:, id_]:
112
+ if element not in info['modal']:
113
+ filter_arr.append(True)
114
+ else:
115
+ filter_arr.append(False)
116
+
117
+ gm2.fit(data[:, id_][filter_arr].reshape([-1, 1]))
118
+ mode_freq = (pd.Series(gm2.predict(data[:, id_][filter_arr].reshape([-1, 1]))).value_counts().keys())
119
+ self.filter_arr.append(filter_arr)
120
+ model.append((gm1,gm2))
121
+
122
+ old_comp = gm2.weights_ > self.eps
123
+
124
+ comp = []
125
+
126
+ for i in range(self.n_clusters):
127
+ if (i in (mode_freq)) & old_comp[i]:
128
+ comp.append(True)
129
+ else:
130
+ comp.append(False)
131
+
132
+ self.components.append(comp)
133
+
134
+ self.output_info += [(1, 'tanh',"no_g"), (np.sum(comp) + len(info['modal']), 'softmax')]
135
+ self.output_dim += 1 + np.sum(comp) + len(info['modal'])
136
+ else:
137
+ model.append(None)
138
+ self.components.append(None)
139
+ self.output_info += [(info['size'], 'softmax')]
140
+ self.output_dim += info['size']
141
+ self.model = model
142
+
143
+ def transform(self, data, ispositive = False, positive_list = None):
144
+ values = []
145
+ mixed_counter = 0
146
+ for id_, info in enumerate(self.meta):
147
+ current = data[:, id_]
148
+ if info['type'] == "continuous":
149
+ if id_ not in self.general_columns:
150
+ current = current.reshape([-1, 1])
151
+ means = self.model[id_].means_.reshape((1, self.n_clusters))
152
+ stds = np.sqrt(self.model[id_].covariances_).reshape((1, self.n_clusters))
153
+ features = np.empty(shape=(len(current),self.n_clusters))
154
+ if ispositive == True:
155
+ if id_ in positive_list:
156
+ features = np.abs(current - means) / (4 * stds)
157
+ else:
158
+ features = (current - means) / (4 * stds)
159
+
160
+ probs = self.model[id_].predict_proba(current.reshape([-1, 1]))
161
+ n_opts = sum(self.components[id_])
162
+ features = features[:, self.components[id_]]
163
+ probs = probs[:, self.components[id_]]
164
+
165
+ opt_sel = np.zeros(len(data), dtype='int')
166
+ for i in range(len(data)):
167
+ pp = probs[i] + 1e-6
168
+ pp = pp / sum(pp)
169
+ opt_sel[i] = np.random.choice(np.arange(n_opts), p=pp)
170
+
171
+ idx = np.arange((len(features)))
172
+ features = features[idx, opt_sel].reshape([-1, 1])
173
+ features = np.clip(features, -.99, .99)
174
+ probs_onehot = np.zeros_like(probs)
175
+ probs_onehot[np.arange(len(probs)), opt_sel] = 1
176
+
177
+ re_ordered_phot = np.zeros_like(probs_onehot)
178
+
179
+ col_sums = probs_onehot.sum(axis=0)
180
+
181
+
182
+ n = probs_onehot.shape[1]
183
+ largest_indices = np.argsort(-1*col_sums)[:n]
184
+ self.ordering.append(largest_indices)
185
+ for id,val in enumerate(largest_indices):
186
+ re_ordered_phot[:,id] = probs_onehot[:,val]
187
+
188
+
189
+ values += [features, re_ordered_phot]
190
+
191
+ else:
192
+
193
+ self.ordering.append(None)
194
+
195
+ if id_ in self.non_categorical_columns:
196
+ info['min'] = -1e-3
197
+ info['max'] = info['max'] + 1e-3
198
+
199
+ current = (current - (info['min'])) / (info['max'] - info['min'])
200
+ current = current * 2 - 1
201
+ current = current.reshape([-1, 1])
202
+ values.append(current)
203
+
204
+ elif info['type'] == "mixed":
205
+
206
+ means_0 = self.model[id_][0].means_.reshape([-1])
207
+ stds_0 = np.sqrt(self.model[id_][0].covariances_).reshape([-1])
208
+
209
+ zero_std_list = []
210
+ means_needed = []
211
+ stds_needed = []
212
+
213
+ for mode in info['modal']:
214
+ if mode!=-9999999:
215
+ dist = []
216
+ for idx,val in enumerate(list(means_0.flatten())):
217
+ dist.append(abs(mode-val))
218
+ index_min = np.argmin(np.array(dist))
219
+ zero_std_list.append(index_min)
220
+ else: continue
221
+
222
+ for idx in zero_std_list:
223
+ means_needed.append(means_0[idx])
224
+ stds_needed.append(stds_0[idx])
225
+
226
+
227
+ mode_vals = []
228
+
229
+ for i,j,k in zip(info['modal'],means_needed,stds_needed):
230
+ this_val = np.abs(i - j) / (4*k)
231
+ mode_vals.append(this_val)
232
+
233
+ if -9999999 in info["modal"]:
234
+ mode_vals.append(0)
235
+
236
+ current = current.reshape([-1, 1])
237
+ filter_arr = self.filter_arr[mixed_counter]
238
+ current = current[filter_arr]
239
+
240
+ means = self.model[id_][1].means_.reshape((1, self.n_clusters))
241
+ stds = np.sqrt(self.model[id_][1].covariances_).reshape((1, self.n_clusters))
242
+ features = np.empty(shape=(len(current),self.n_clusters))
243
+ if ispositive == True:
244
+ if id_ in positive_list:
245
+ features = np.abs(current - means) / (4 * stds)
246
+ else:
247
+ features = (current - means) / (4 * stds)
248
+
249
+ probs = self.model[id_][1].predict_proba(current.reshape([-1, 1]))
250
+
251
+ n_opts = sum(self.components[id_]) # 8
252
+ features = features[:, self.components[id_]]
253
+ probs = probs[:, self.components[id_]]
254
+
255
+ opt_sel = np.zeros(len(current), dtype='int')
256
+ for i in range(len(current)):
257
+ pp = probs[i] + 1e-6
258
+ pp = pp / sum(pp)
259
+ opt_sel[i] = np.random.choice(np.arange(n_opts), p=pp)
260
+ idx = np.arange((len(features)))
261
+ features = features[idx, opt_sel].reshape([-1, 1])
262
+ features = np.clip(features, -.99, .99)
263
+ probs_onehot = np.zeros_like(probs)
264
+ probs_onehot[np.arange(len(probs)), opt_sel] = 1
265
+ extra_bits = np.zeros([len(current), len(info['modal'])])
266
+ temp_probs_onehot = np.concatenate([extra_bits,probs_onehot], axis = 1)
267
+ final = np.zeros([len(data), 1 + probs_onehot.shape[1] + len(info['modal'])])
268
+ features_curser = 0
269
+ for idx, val in enumerate(data[:, id_]):
270
+ if val in info['modal']:
271
+ category_ = list(map(info['modal'].index, [val]))[0]
272
+ final[idx, 0] = mode_vals[category_]
273
+ final[idx, (category_+1)] = 1
274
+
275
+ else:
276
+ final[idx, 0] = features[features_curser]
277
+ final[idx, (1+len(info['modal'])):] = temp_probs_onehot[features_curser][len(info['modal']):]
278
+ features_curser = features_curser + 1
279
+
280
+ just_onehot = final[:,1:]
281
+ re_ordered_jhot= np.zeros_like(just_onehot)
282
+ n = just_onehot.shape[1]
283
+ col_sums = just_onehot.sum(axis=0)
284
+ largest_indices = np.argsort(-1*col_sums)[:n]
285
+ self.ordering.append(largest_indices)
286
+ for id,val in enumerate(largest_indices):
287
+ re_ordered_jhot[:,id] = just_onehot[:,val]
288
+ final_features = final[:,0].reshape([-1, 1])
289
+ values += [final_features, re_ordered_jhot]
290
+ mixed_counter = mixed_counter + 1
291
+
292
+ else:
293
+ self.ordering.append(None)
294
+ col_t = np.zeros([len(data), info['size']])
295
+ idx = list(map(info['i2s'].index, current))
296
+ col_t[np.arange(len(data)), idx] = 1
297
+ values.append(col_t)
298
+
299
+ return np.concatenate(values, axis=1)
300
+
301
+ def inverse_transform(self, data):
302
+ data_t = np.zeros([len(data), len(self.meta)])
303
+ invalid_ids = []
304
+ st = 0
305
+ for id_, info in enumerate(self.meta):
306
+ if info['type'] == "continuous":
307
+ if id_ not in self.general_columns:
308
+ u = data[:, st]
309
+ v = data[:, st + 1:st + 1 + np.sum(self.components[id_])]
310
+ order = self.ordering[id_]
311
+ v_re_ordered = np.zeros_like(v)
312
+
313
+ for id,val in enumerate(order):
314
+ v_re_ordered[:,val] = v[:,id]
315
+
316
+ v = v_re_ordered
317
+
318
+ u = np.clip(u, -1, 1)
319
+ v_t = np.ones((data.shape[0], self.n_clusters)) * -100
320
+ v_t[:, self.components[id_]] = v
321
+ v = v_t
322
+ st += 1 + np.sum(self.components[id_])
323
+ means = self.model[id_].means_.reshape([-1])
324
+ stds = np.sqrt(self.model[id_].covariances_).reshape([-1])
325
+ p_argmax = np.argmax(v, axis=1)
326
+ std_t = stds[p_argmax]
327
+ mean_t = means[p_argmax]
328
+ tmp = u * 4 * std_t + mean_t
329
+
330
+ for idx,val in enumerate(tmp):
331
+ if (val < info["min"]) | (val > info['max']):
332
+ invalid_ids.append(idx)
333
+
334
+ if id_ in self.non_categorical_columns:
335
+
336
+ tmp = np.round(tmp)
337
+
338
+ data_t[:, id_] = tmp
339
+
340
+ else:
341
+ u = data[:, st]
342
+ u = (u + 1) / 2
343
+ u = np.clip(u, 0, 1)
344
+ u = u * (info['max'] - info['min']) + info['min']
345
+ if id_ in self.non_categorical_columns:
346
+ data_t[:, id_] = np.round(u)
347
+ else: data_t[:, id_] = u
348
+
349
+ st += 1
350
+
351
+ elif info['type'] == "mixed":
352
+
353
+ u = data[:, st]
354
+ full_v = data[:,(st+1):(st+1)+len(info['modal'])+np.sum(self.components[id_])]
355
+ order = self.ordering[id_]
356
+ full_v_re_ordered = np.zeros_like(full_v)
357
+
358
+ for id,val in enumerate(order):
359
+ full_v_re_ordered[:,val] = full_v[:,id]
360
+
361
+ full_v = full_v_re_ordered
362
+
363
+
364
+ mixed_v = full_v[:,:len(info['modal'])]
365
+ v = full_v[:,-np.sum(self.components[id_]):]
366
+
367
+ u = np.clip(u, -1, 1)
368
+ v_t = np.ones((data.shape[0], self.n_clusters)) * -100
369
+ v_t[:, self.components[id_]] = v
370
+ v = np.concatenate([mixed_v,v_t], axis=1)
371
+
372
+ st += 1 + np.sum(self.components[id_]) + len(info['modal'])
373
+ means = self.model[id_][1].means_.reshape([-1])
374
+ stds = np.sqrt(self.model[id_][1].covariances_).reshape([-1])
375
+ p_argmax = np.argmax(v, axis=1)
376
+
377
+ result = np.zeros_like(u)
378
+
379
+ for idx in range(len(data)):
380
+ if p_argmax[idx] < len(info['modal']):
381
+ argmax_value = p_argmax[idx]
382
+ result[idx] = float(list(map(info['modal'].__getitem__, [argmax_value]))[0])
383
+ else:
384
+ std_t = stds[(p_argmax[idx]-len(info['modal']))]
385
+ mean_t = means[(p_argmax[idx]-len(info['modal']))]
386
+ result[idx] = u[idx] * 4 * std_t + mean_t
387
+
388
+ for idx,val in enumerate(result):
389
+ if (val < info["min"]) | (val > info['max']):
390
+ invalid_ids.append(idx)
391
+
392
+ data_t[:, id_] = result
393
+
394
+ else:
395
+ current = data[:, st:st + info['size']]
396
+ st += info['size']
397
+ idx = np.argmax(current, axis=1)
398
+ data_t[:, id_] = list(map(info['i2s'].__getitem__, idx))
399
+
400
+
401
+ invalid_ids = np.unique(np.array(invalid_ids))
402
+ all_ids = np.arange(0,len(data))
403
+ valid_ids = list(set(all_ids) - set(invalid_ids))
404
+
405
+ return data_t[valid_ids],len(invalid_ids)
406
+
407
+
408
+ class ImageTransformer():
409
+
410
+ def __init__(self, side):
411
+
412
+ self.height = side
413
+
414
+ def transform(self, data):
415
+
416
+ if self.height * self.height > len(data[0]):
417
+
418
+ padding = torch.zeros((len(data), self.height * self.height - len(data[0]))).to(data.device)
419
+ data = torch.cat([data, padding], axis=1)
420
+
421
+ return data.view(-1, 1, self.height, self.height)
422
+
423
+ def inverse_transform(self, data):
424
+
425
+ data = data.view(-1, self.height * self.height)
426
+
427
+ return data
428
+
429
+
syntheticFail/n18/tabddpm/tabddpm-n18-20260511_002808/_tabddpm_runtime/CTAB-GAN-Plus/model/ctabgan.py ADDED
@@ -0,0 +1,72 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ """
2
+ Generative model training algorithm based on the CTABGANSynthesiser
3
+
4
+ """
5
+ import pandas as pd
6
+ import time
7
+ from model.pipeline.data_preparation import DataPrep
8
+ from model.synthesizer.ctabgan_synthesizer import CTABGANSynthesizer
9
+
10
+ import warnings
11
+
12
+ warnings.filterwarnings("ignore")
13
+
14
+ class CTABGAN():
15
+
16
+ def __init__(self,
17
+ df,
18
+ test_ratio = 0.20,
19
+ categorical_columns = [],
20
+ log_columns = [],
21
+ mixed_columns= {},
22
+ general_columns = [],
23
+ non_categorical_columns = [],
24
+ integer_columns = [],
25
+ problem_type= {},
26
+ class_dim=(256, 256, 256, 256),
27
+ random_dim=100,
28
+ num_channels=64,
29
+ l2scale=1e-5,
30
+ batch_size=500,
31
+ epochs=150,
32
+ lr=2e-4,
33
+ device="cpu"):
34
+
35
+ self.__name__ = 'CTABGAN'
36
+
37
+ self.synthesizer = CTABGANSynthesizer(
38
+ class_dim=class_dim,
39
+ random_dim=random_dim,
40
+ num_channels=num_channels,
41
+ l2scale=l2scale,
42
+ lr=lr,
43
+ batch_size=batch_size,
44
+ epochs=epochs,
45
+ device=device
46
+ )
47
+ self.raw_df = df
48
+ self.test_ratio = test_ratio
49
+ self.categorical_columns = categorical_columns
50
+ self.log_columns = log_columns
51
+ self.mixed_columns = mixed_columns
52
+ self.general_columns = general_columns
53
+ self.non_categorical_columns = non_categorical_columns
54
+ self.integer_columns = integer_columns
55
+ self.problem_type = problem_type
56
+
57
+ def fit(self):
58
+
59
+ start_time = time.time()
60
+ 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)
61
+ self.synthesizer.fit(train_data=self.data_prep.df, categorical = self.data_prep.column_types["categorical"], mixed = self.data_prep.column_types["mixed"],
62
+ general = self.data_prep.column_types["general"], non_categorical = self.data_prep.column_types["non_categorical"], type=self.problem_type)
63
+ end_time = time.time()
64
+ print('Finished training in',end_time-start_time," seconds.")
65
+
66
+
67
+ def generate_samples(self, num_samples, seed=0):
68
+
69
+ sample = self.synthesizer.sample(num_samples, seed)
70
+ sample_df = self.data_prep.inverse_prep(sample)
71
+
72
+ return sample_df
syntheticFail/n18/tabddpm/tabddpm-n18-20260511_002808/_tabddpm_runtime/CTAB-GAN-Plus/model/eval/evaluation.py ADDED
@@ -0,0 +1,193 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ import numpy as np
2
+ import pandas as pd
3
+ from sklearn import metrics
4
+ from sklearn import model_selection
5
+ from sklearn.preprocessing import MinMaxScaler,StandardScaler
6
+ from sklearn.neural_network import MLPClassifier
7
+ from sklearn.linear_model import LogisticRegression
8
+ from sklearn import svm,tree
9
+ from sklearn.ensemble import RandomForestClassifier
10
+ from dython.nominal import compute_associations
11
+ from scipy.stats import wasserstein_distance
12
+ from scipy.spatial import distance
13
+ import warnings
14
+
15
+ warnings.filterwarnings("ignore")
16
+
17
+ def supervised_model_training(x_train, y_train, x_test,
18
+ y_test, model_name):
19
+
20
+
21
+ if model_name == 'lr':
22
+ model = LogisticRegression(random_state=42,max_iter=500)
23
+ elif model_name == 'svm':
24
+ model = svm.SVC(random_state=42,probability=True)
25
+ elif model_name == 'dt':
26
+ model = tree.DecisionTreeClassifier(random_state=42)
27
+ elif model_name == 'rf':
28
+ model = RandomForestClassifier(random_state=42)
29
+ elif model_name == "mlp":
30
+ model = MLPClassifier(random_state=42,max_iter=100)
31
+
32
+ model.fit(x_train, y_train)
33
+ pred = model.predict(x_test)
34
+
35
+ if len(np.unique(y_train))>2:
36
+ predict = model.predict_proba(x_test)
37
+ acc = metrics.accuracy_score(y_test,pred)*100
38
+ auc = metrics.roc_auc_score(y_test, predict,average="weighted",multi_class="ovr")
39
+ f1_score = metrics.precision_recall_fscore_support(y_test, pred,average="weighted")[2]
40
+ return [acc, auc,f1_score]
41
+
42
+ else:
43
+ predict = model.predict_proba(x_test)[:,1]
44
+ acc = metrics.accuracy_score(y_test,pred)*100
45
+ auc = metrics.roc_auc_score(y_test, predict)
46
+ f1_score = metrics.precision_recall_fscore_support(y_test,pred)[2].mean()
47
+ return [acc, auc,f1_score]
48
+
49
+
50
+ def get_utility_metrics(real_path,fake_paths,scaler="MinMax",classifiers=["lr","dt","rf","mlp"],test_ratio=.20):
51
+
52
+ data_real = pd.read_csv(real_path).to_numpy()
53
+ data_dim = data_real.shape[1]
54
+
55
+ data_real_y = data_real[:,-1]
56
+ data_real_X = data_real[:,:data_dim-1]
57
+ 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)
58
+
59
+ if scaler=="MinMax":
60
+ scaler_real = MinMaxScaler()
61
+ else:
62
+ scaler_real = StandardScaler()
63
+
64
+ scaler_real.fit(data_real_X)
65
+ X_train_real_scaled = scaler_real.transform(X_train_real)
66
+ X_test_real_scaled = scaler_real.transform(X_test_real)
67
+
68
+ all_real_results = []
69
+ for classifier in classifiers:
70
+ real_results = supervised_model_training(X_train_real_scaled,y_train_real,X_test_real_scaled,y_test_real,classifier)
71
+ all_real_results.append(real_results)
72
+
73
+ all_fake_results_avg = []
74
+
75
+ for fake_path in fake_paths:
76
+ data_fake = pd.read_csv(fake_path).to_numpy()
77
+ data_fake_y = data_fake[:,-1]
78
+ data_fake_X = data_fake[:,:data_dim-1]
79
+ 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)
80
+
81
+ if scaler=="MinMax":
82
+ scaler_fake = MinMaxScaler()
83
+ else:
84
+ scaler_fake = StandardScaler()
85
+
86
+ scaler_fake.fit(data_fake_X)
87
+
88
+ X_train_fake_scaled = scaler_fake.transform(X_train_fake)
89
+
90
+ all_fake_results = []
91
+ for classifier in classifiers:
92
+ fake_results = supervised_model_training(X_train_fake_scaled,y_train_fake,X_test_real_scaled,y_test_real,classifier)
93
+ all_fake_results.append(fake_results)
94
+
95
+ all_fake_results_avg.append(all_fake_results)
96
+
97
+ diff_results = np.array(all_real_results)- np.array(all_fake_results_avg).mean(axis=0)
98
+
99
+ return diff_results
100
+
101
+ def stat_sim(real_path,fake_path,cat_cols=None):
102
+
103
+ Stat_dict={}
104
+
105
+ real = pd.read_csv(real_path)
106
+ fake = pd.read_csv(fake_path)
107
+
108
+ really = real.copy()
109
+ fakey = fake.copy()
110
+
111
+ real_corr = compute_associations(real, nominal_columns=cat_cols)
112
+
113
+ fake_corr = compute_associations(fake, nominal_columns=cat_cols)
114
+
115
+ corr_dist = np.linalg.norm(real_corr - fake_corr)
116
+
117
+ cat_stat = []
118
+ num_stat = []
119
+
120
+ for column in real.columns:
121
+
122
+ if column in cat_cols:
123
+
124
+ real_pdf=(really[column].value_counts()/really[column].value_counts().sum())
125
+ fake_pdf=(fakey[column].value_counts()/fakey[column].value_counts().sum())
126
+ categories = (fakey[column].value_counts()/fakey[column].value_counts().sum()).keys().tolist()
127
+ sorted_categories = sorted(categories)
128
+
129
+ real_pdf_values = []
130
+ fake_pdf_values = []
131
+
132
+ for i in sorted_categories:
133
+ real_pdf_values.append(real_pdf[i])
134
+ fake_pdf_values.append(fake_pdf[i])
135
+
136
+ if len(real_pdf)!=len(fake_pdf):
137
+ zero_cats = set(really[column].value_counts().keys())-set(fakey[column].value_counts().keys())
138
+ for z in zero_cats:
139
+ real_pdf_values.append(real_pdf[z])
140
+ fake_pdf_values.append(0)
141
+ Stat_dict[column]=(distance.jensenshannon(real_pdf_values,fake_pdf_values, 2.0))
142
+ cat_stat.append(Stat_dict[column])
143
+ else:
144
+ scaler = MinMaxScaler()
145
+ scaler.fit(real[column].values.reshape(-1,1))
146
+ l1 = scaler.transform(real[column].values.reshape(-1,1)).flatten()
147
+ l2 = scaler.transform(fake[column].values.reshape(-1,1)).flatten()
148
+ Stat_dict[column]= (wasserstein_distance(l1,l2))
149
+ num_stat.append(Stat_dict[column])
150
+
151
+ return [np.mean(num_stat),np.mean(cat_stat),corr_dist]
152
+
153
+ def privacy_metrics(real_path,fake_path,data_percent=15):
154
+
155
+ real = pd.read_csv(real_path).drop_duplicates(keep=False)
156
+ fake = pd.read_csv(fake_path).drop_duplicates(keep=False)
157
+
158
+ real_refined = real.sample(n=int(len(real)*(.01*data_percent)), random_state=42).to_numpy()
159
+ fake_refined = fake.sample(n=int(len(fake)*(.01*data_percent)), random_state=42).to_numpy()
160
+
161
+ scalerR = StandardScaler()
162
+ scalerR.fit(real_refined)
163
+ scalerF = StandardScaler()
164
+ scalerF.fit(fake_refined)
165
+ df_real_scaled = scalerR.transform(real_refined)
166
+ df_fake_scaled = scalerF.transform(fake_refined)
167
+
168
+ dist_rf = metrics.pairwise_distances(df_real_scaled, Y=df_fake_scaled, metric='minkowski', n_jobs=-1)
169
+ dist_rr = metrics.pairwise_distances(df_real_scaled, Y=None, metric='minkowski', n_jobs=-1)
170
+ rd_dist_rr = dist_rr[~np.eye(dist_rr.shape[0],dtype=bool)].reshape(dist_rr.shape[0],-1)
171
+ dist_ff = metrics.pairwise_distances(df_fake_scaled, Y=None, metric='minkowski', n_jobs=-1)
172
+ rd_dist_ff = dist_ff[~np.eye(dist_ff.shape[0],dtype=bool)].reshape(dist_ff.shape[0],-1)
173
+ smallest_two_indexes_rf = [dist_rf[i].argsort()[:2] for i in range(len(dist_rf))]
174
+ smallest_two_rf = [dist_rf[i][smallest_two_indexes_rf[i]] for i in range(len(dist_rf))]
175
+ smallest_two_indexes_rr = [rd_dist_rr[i].argsort()[:2] for i in range(len(rd_dist_rr))]
176
+ smallest_two_rr = [rd_dist_rr[i][smallest_two_indexes_rr[i]] for i in range(len(rd_dist_rr))]
177
+ smallest_two_indexes_ff = [rd_dist_ff[i].argsort()[:2] for i in range(len(rd_dist_ff))]
178
+ smallest_two_ff = [rd_dist_ff[i][smallest_two_indexes_ff[i]] for i in range(len(rd_dist_ff))]
179
+ nn_ratio_rr = np.array([i[0]/i[1] for i in smallest_two_rr])
180
+ nn_ratio_ff = np.array([i[0]/i[1] for i in smallest_two_ff])
181
+ nn_ratio_rf = np.array([i[0]/i[1] for i in smallest_two_rf])
182
+ nn_fifth_perc_rr = np.percentile(nn_ratio_rr,5)
183
+ nn_fifth_perc_ff = np.percentile(nn_ratio_ff,5)
184
+ nn_fifth_perc_rf = np.percentile(nn_ratio_rf,5)
185
+
186
+ min_dist_rf = np.array([i[0] for i in smallest_two_rf])
187
+ fifth_perc_rf = np.percentile(min_dist_rf,5)
188
+ min_dist_rr = np.array([i[0] for i in smallest_two_rr])
189
+ fifth_perc_rr = np.percentile(min_dist_rr,5)
190
+ min_dist_ff = np.array([i[0] for i in smallest_two_ff])
191
+ fifth_perc_ff = np.percentile(min_dist_ff,5)
192
+
193
+ 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/n18/tabddpm/tabddpm-n18-20260511_002808/_tabddpm_runtime/CTAB-GAN-Plus/model/pipeline/data_preparation.py ADDED
@@ -0,0 +1,131 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ import numpy as np
2
+ import pandas as pd
3
+ from sklearn import preprocessing
4
+ from sklearn import model_selection
5
+
6
+ class DataPrep(object):
7
+
8
+ 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):
9
+
10
+
11
+ self.categorical_columns = categorical
12
+ self.log_columns = log
13
+ self.mixed_columns = mixed
14
+ self.general_columns = general
15
+ self.non_categorical_columns = non_categorical
16
+ self.integer_columns = integer
17
+ self.column_types = dict()
18
+ self.column_types["categorical"] = []
19
+ self.column_types["mixed"] = {}
20
+ self.column_types["general"] = []
21
+ self.column_types["non_categorical"] = []
22
+ self.lower_bounds = {}
23
+ self.label_encoder_list = []
24
+
25
+ target_col = list(type.values())[0]
26
+ if target_col is not None:
27
+ y_real = raw_df[target_col]
28
+ X_real = raw_df.drop(columns=[target_col])
29
+ # 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)
30
+ X_train_real, y_train_real = X_real, y_real
31
+
32
+ X_train_real[target_col]= y_train_real
33
+
34
+ self.df = X_train_real
35
+ else:
36
+ self.df = raw_df
37
+
38
+ self.df = self.df.replace(r' ', np.nan)
39
+ self.df = self.df.fillna('empty')
40
+
41
+ all_columns= set(self.df.columns)
42
+ irrelevant_missing_columns = set(self.categorical_columns)
43
+ relevant_missing_columns = list(all_columns - irrelevant_missing_columns)
44
+
45
+ for i in relevant_missing_columns:
46
+ if i in self.log_columns:
47
+ if "empty" in list(self.df[i].values):
48
+ self.df[i] = self.df[i].apply(lambda x: -9999999 if x=="empty" else x)
49
+ self.mixed_columns[i] = [-9999999]
50
+ elif i in list(self.mixed_columns.keys()):
51
+ if "empty" in list(self.df[i].values):
52
+ self.df[i] = self.df[i].apply(lambda x: -9999999 if x=="empty" else x )
53
+ self.mixed_columns[i].append(-9999999)
54
+ else:
55
+ if "empty" in list(self.df[i].values):
56
+ self.df[i] = self.df[i].apply(lambda x: -9999999 if x=="empty" else x)
57
+ self.mixed_columns[i] = [-9999999]
58
+
59
+ if self.log_columns:
60
+ for log_column in self.log_columns:
61
+ valid_indices = []
62
+ for idx,val in enumerate(self.df[log_column].values):
63
+ if val!=-9999999:
64
+ valid_indices.append(idx)
65
+ eps = 1
66
+ lower = np.min(self.df[log_column].iloc[valid_indices].values)
67
+ self.lower_bounds[log_column] = lower
68
+ if lower>0:
69
+ self.df[log_column] = self.df[log_column].apply(lambda x: np.log(x) if x!=-9999999 else -9999999)
70
+ elif lower == 0:
71
+ self.df[log_column] = self.df[log_column].apply(lambda x: np.log(x+eps) if x!=-9999999 else -9999999)
72
+ else:
73
+ self.df[log_column] = self.df[log_column].apply(lambda x: np.log(x-lower+eps) if x!=-9999999 else -9999999)
74
+
75
+ for column_index, column in enumerate(self.df.columns):
76
+ if column in self.categorical_columns:
77
+ label_encoder = preprocessing.LabelEncoder()
78
+ self.df[column] = self.df[column].astype(str)
79
+ label_encoder.fit(self.df[column])
80
+ current_label_encoder = dict()
81
+ current_label_encoder['column'] = column
82
+ current_label_encoder['label_encoder'] = label_encoder
83
+ transformed_column = label_encoder.transform(self.df[column])
84
+ self.df[column] = transformed_column
85
+ self.label_encoder_list.append(current_label_encoder)
86
+ self.column_types["categorical"].append(column_index)
87
+
88
+ if column in self.general_columns:
89
+ self.column_types["general"].append(column_index)
90
+
91
+ if column in self.non_categorical_columns:
92
+ self.column_types["non_categorical"].append(column_index)
93
+
94
+ elif column in self.mixed_columns:
95
+ self.column_types["mixed"][column_index] = self.mixed_columns[column]
96
+
97
+ elif column in self.general_columns:
98
+ self.column_types["general"].append(column_index)
99
+
100
+
101
+ super().__init__()
102
+
103
+ def inverse_prep(self, data, eps=1):
104
+
105
+ df_sample = pd.DataFrame(data,columns=self.df.columns)
106
+
107
+ for i in range(len(self.label_encoder_list)):
108
+ le = self.label_encoder_list[i]["label_encoder"]
109
+ df_sample[self.label_encoder_list[i]["column"]] = df_sample[self.label_encoder_list[i]["column"]].astype(int)
110
+ df_sample[self.label_encoder_list[i]["column"]] = le.inverse_transform(df_sample[self.label_encoder_list[i]["column"]])
111
+
112
+ if self.log_columns:
113
+ for i in df_sample:
114
+ if i in self.log_columns:
115
+ lower_bound = self.lower_bounds[i]
116
+ if lower_bound>0:
117
+ df_sample[i].apply(lambda x: np.exp(x))
118
+ elif lower_bound==0:
119
+ 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))
120
+ else:
121
+ df_sample[i] = df_sample[i].apply(lambda x: np.exp(x)-eps+lower_bound)
122
+
123
+ if self.integer_columns:
124
+ for column in self.integer_columns:
125
+ df_sample[column]= (np.round(df_sample[column].values))
126
+ df_sample[column] = df_sample[column].astype(int)
127
+
128
+ df_sample.replace(-9999999, np.nan,inplace=True)
129
+ df_sample.replace('empty', np.nan,inplace=True)
130
+
131
+ return df_sample
syntheticFail/n18/tabddpm/tabddpm-n18-20260511_002808/_tabddpm_runtime/CTAB-GAN-Plus/model/privacy_utils/rdp_accountant.py ADDED
@@ -0,0 +1,280 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ from __future__ import absolute_import
2
+ from __future__ import division
3
+ from __future__ import print_function
4
+
5
+ import math
6
+ import sys
7
+
8
+ import numpy as np
9
+ from scipy import special
10
+ import six
11
+
12
+ ########################
13
+ # LOG-SPACE ARITHMETIC #
14
+ ########################
15
+
16
+
17
+ def _log_add(logx, logy):
18
+ """Add two numbers in the log space."""
19
+ a, b = min(logx, logy), max(logx, logy)
20
+ if a == -np.inf: # adding 0
21
+ return b
22
+ # Use exp(a) + exp(b) = (exp(a - b) + 1) * exp(b)
23
+ return math.log1p(math.exp(a - b)) + b # log1p(x) = log(x + 1)
24
+
25
+
26
+ def _log_sub(logx, logy):
27
+ """Subtract two numbers in the log space. Answer must be non-negative."""
28
+ if logx < logy:
29
+ raise ValueError("The result of subtraction must be non-negative.")
30
+ if logy == -np.inf: # subtracting 0
31
+ return logx
32
+ if logx == logy:
33
+ return -np.inf # 0 is represented as -np.inf in the log space.
34
+
35
+ try:
36
+ # Use exp(x) - exp(y) = (exp(x - y) - 1) * exp(y).
37
+ return math.log(math.expm1(logx - logy)) + logy # expm1(x) = exp(x) - 1
38
+ except OverflowError:
39
+ return logx
40
+
41
+
42
+ def _log_print(logx):
43
+ """Pretty print."""
44
+ if logx < math.log(sys.float_info.max):
45
+ return "{}".format(math.exp(logx))
46
+ else:
47
+ return "exp({})".format(logx)
48
+
49
+
50
+ def _compute_log_a_int(q, sigma, alpha):
51
+ """Compute log(A_alpha) for integer alpha. 0 < q < 1."""
52
+ assert isinstance(alpha, six.integer_types)
53
+
54
+ # Initialize with 0 in the log space.
55
+ log_a = -np.inf
56
+
57
+ for i in range(alpha + 1):
58
+ log_coef_i = (
59
+ math.log(special.binom(alpha, i)) + i * math.log(q) +
60
+ (alpha - i) * math.log(1 - q))
61
+
62
+ s = log_coef_i + (i * i - i) / (2 * (sigma**2))
63
+ log_a = _log_add(log_a, s)
64
+
65
+ return float(log_a)
66
+
67
+
68
+ def _compute_log_a_frac(q, sigma, alpha):
69
+ """Compute log(A_alpha) for fractional alpha. 0 < q < 1."""
70
+ # The two parts of A_alpha, integrals over (-inf,z0] and [z0, +inf), are
71
+ # initialized to 0 in the log space:
72
+ log_a0, log_a1 = -np.inf, -np.inf
73
+ i = 0
74
+
75
+ z0 = sigma**2 * math.log(1 / q - 1) + .5
76
+
77
+ while True: # do ... until loop
78
+ coef = special.binom(alpha, i)
79
+ log_coef = math.log(abs(coef))
80
+ j = alpha - i
81
+
82
+ log_t0 = log_coef + i * math.log(q) + j * math.log(1 - q)
83
+ log_t1 = log_coef + j * math.log(q) + i * math.log(1 - q)
84
+
85
+ log_e0 = math.log(.5) + _log_erfc((i - z0) / (math.sqrt(2) * sigma))
86
+ log_e1 = math.log(.5) + _log_erfc((z0 - j) / (math.sqrt(2) * sigma))
87
+
88
+ log_s0 = log_t0 + (i * i - i) / (2 * (sigma**2)) + log_e0
89
+ log_s1 = log_t1 + (j * j - j) / (2 * (sigma**2)) + log_e1
90
+
91
+ if coef > 0:
92
+ log_a0 = _log_add(log_a0, log_s0)
93
+ log_a1 = _log_add(log_a1, log_s1)
94
+ else:
95
+ log_a0 = _log_sub(log_a0, log_s0)
96
+ log_a1 = _log_sub(log_a1, log_s1)
97
+
98
+ i += 1
99
+ if max(log_s0, log_s1) < -30:
100
+ break
101
+
102
+ return _log_add(log_a0, log_a1)
103
+
104
+
105
+ def _compute_log_a(q, sigma, alpha):
106
+ """Compute log(A_alpha) for any positive finite alpha."""
107
+ if float(alpha).is_integer():
108
+ return _compute_log_a_int(q, sigma, int(alpha))
109
+ else:
110
+ return _compute_log_a_frac(q, sigma, alpha)
111
+
112
+
113
+ def _log_erfc(x):
114
+ """Compute log(erfc(x)) with high accuracy for large x."""
115
+ try:
116
+ return math.log(2) + special.log_ndtr(-x * 2**.5)
117
+ except NameError:
118
+ # If log_ndtr is not available, approximate as follows:
119
+ r = special.erfc(x)
120
+ if r == 0.0:
121
+ # Using the Laurent series at infinity for the tail of the erfc function:
122
+ # erfc(x) ~ exp(-x^2-.5/x^2+.625/x^4)/(x*pi^.5)
123
+ # To verify in Mathematica:
124
+ # Series[Log[Erfc[x]] + Log[x] + Log[Pi]/2 + x^2, {x, Infinity, 6}]
125
+ return (-math.log(math.pi) / 2 - math.log(x) - x**2 - .5 * x**-2 +
126
+ .625 * x**-4 - 37. / 24. * x**-6 + 353. / 64. * x**-8)
127
+ else:
128
+ return math.log(r)
129
+
130
+
131
+ def _compute_delta(orders, rdp, eps):
132
+ """Compute delta given a list of RDP values and target epsilon.
133
+
134
+ Args:
135
+ orders: An array (or a scalar) of orders.
136
+ rdp: A list (or a scalar) of RDP guarantees.
137
+ eps: The target epsilon.
138
+
139
+ Returns:
140
+ Pair of (delta, optimal_order).
141
+
142
+ Raises:
143
+ ValueError: If input is malformed.
144
+
145
+ """
146
+ orders_vec = np.atleast_1d(orders)
147
+ rdp_vec = np.atleast_1d(rdp)
148
+
149
+ if len(orders_vec) != len(rdp_vec):
150
+ raise ValueError("Input lists must have the same length.")
151
+
152
+ deltas = np.exp((rdp_vec - eps) * (orders_vec - 1))
153
+ idx_opt = np.argmin(deltas)
154
+ return min(deltas[idx_opt], 1.), orders_vec[idx_opt]
155
+
156
+
157
+ def _compute_eps(orders, rdp, delta):
158
+ """Compute epsilon given a list of RDP values and target delta.
159
+
160
+ Args:
161
+ orders: An array (or a scalar) of orders.
162
+ rdp: A list (or a scalar) of RDP guarantees.
163
+ delta: The target delta.
164
+
165
+ Returns:
166
+ Pair of (eps, optimal_order).
167
+
168
+ Raises:
169
+ ValueError: If input is malformed.
170
+
171
+ """
172
+ orders_vec = np.atleast_1d(orders)
173
+ rdp_vec = np.atleast_1d(rdp)
174
+
175
+ if len(orders_vec) != len(rdp_vec):
176
+ raise ValueError("Input lists must have the same length.")
177
+
178
+ eps = rdp_vec - math.log(delta) / (orders_vec - 1)
179
+
180
+ idx_opt = np.nanargmin(eps) # Ignore NaNs
181
+ return eps[idx_opt], orders_vec[idx_opt]
182
+
183
+
184
+ def _compute_rdp(q, sigma, alpha):
185
+ """Compute RDP of the Sampled Gaussian mechanism at order alpha.
186
+
187
+ Args:
188
+ q: The sampling rate.
189
+ sigma: The std of the additive Gaussian noise.
190
+ alpha: The order at which RDP is computed.
191
+
192
+ Returns:
193
+ RDP at alpha, can be np.inf.
194
+ """
195
+ if q == 0:
196
+ return 0
197
+
198
+ if q == 1.:
199
+ return alpha / (2 * sigma**2)
200
+
201
+ if np.isinf(alpha):
202
+ return np.inf
203
+
204
+ return _compute_log_a(q, sigma, alpha) / (alpha - 1)
205
+
206
+
207
+ def compute_rdp(q, noise_multiplier, steps, orders):
208
+ """Compute RDP of the Sampled Gaussian Mechanism.
209
+
210
+ Args:
211
+ q: The sampling rate.
212
+ noise_multiplier: The ratio of the standard deviation of the Gaussian noise
213
+ to the l2-sensitivity of the function to which it is added.
214
+ steps: The number of steps.
215
+ orders: An array (or a scalar) of RDP orders.
216
+
217
+ Returns:
218
+ The RDPs at all orders, can be np.inf.
219
+ """
220
+ if np.isscalar(orders):
221
+ rdp = _compute_rdp(q, noise_multiplier, orders)
222
+ else:
223
+ rdp = np.array([_compute_rdp(q, noise_multiplier, order)
224
+ for order in orders])
225
+
226
+ return rdp * steps
227
+
228
+
229
+ def get_privacy_spent(orders, rdp, target_eps=None, target_delta=None):
230
+ """Compute delta (or eps) for given eps (or delta) from RDP values.
231
+
232
+ Args:
233
+ orders: An array (or a scalar) of RDP orders.
234
+ rdp: An array of RDP values. Must be of the same length as the orders list.
235
+ target_eps: If not None, the epsilon for which we compute the corresponding
236
+ delta.
237
+ target_delta: If not None, the delta for which we compute the corresponding
238
+ epsilon. Exactly one of target_eps and target_delta must be None.
239
+
240
+ Returns:
241
+ eps, delta, opt_order.
242
+
243
+ Raises:
244
+ ValueError: If target_eps and target_delta are messed up.
245
+ """
246
+ if target_eps is None and target_delta is None:
247
+ raise ValueError(
248
+ "Exactly one out of eps and delta must be None. (Both are).")
249
+
250
+ if target_eps is not None and target_delta is not None:
251
+ raise ValueError(
252
+ "Exactly one out of eps and delta must be None. (None is).")
253
+
254
+ if target_eps is not None:
255
+ delta, opt_order = _compute_delta(orders, rdp, target_eps)
256
+ return target_eps, delta, opt_order
257
+ else:
258
+ eps, opt_order = _compute_eps(orders, rdp, target_delta)
259
+ return eps, target_delta, opt_order
260
+
261
+
262
+ def compute_rdp_from_ledger(ledger, orders):
263
+ """Compute RDP of Sampled Gaussian Mechanism from ledger.
264
+
265
+ Args:
266
+ ledger: A formatted privacy ledger.
267
+ orders: An array (or a scalar) of RDP orders.
268
+
269
+ Returns:
270
+ RDP at all orders, can be np.inf.
271
+ """
272
+ total_rdp = np.zeros_like(orders, dtype=float)
273
+ for sample in ledger:
274
+ # Compute equivalent z from l2_clip_bounds and noise stddevs in sample.
275
+ # See https://arxiv.org/pdf/1812.06210.pdf for derivation of this formula.
276
+ effective_z = sum([
277
+ (q.noise_stddev / q.l2_norm_bound)**-2 for q in sample.queries])**-0.5
278
+ total_rdp += compute_rdp(
279
+ sample.selection_probability, effective_z, 1, orders)
280
+ return total_rdp
syntheticFail/n18/tabddpm/tabddpm-n18-20260511_002808/_tabddpm_runtime/CTAB-GAN-Plus/model/synthesizer/ctabgan_synthesizer.py ADDED
@@ -0,0 +1,605 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ import numpy as np
2
+ import pandas as pd
3
+ import torch
4
+ import torch.utils.data
5
+ import torch.optim as optim
6
+ from torch.optim import Adam
7
+ from torch.nn import functional as F
8
+ from torch.nn import (Dropout, LeakyReLU, Linear, Module, ReLU, Sequential,
9
+ Conv2d, ConvTranspose2d, Sigmoid, init, BCELoss, CrossEntropyLoss,SmoothL1Loss,LayerNorm)
10
+ from model.synthesizer.transformer import ImageTransformer,DataTransformer
11
+ from model.privacy_utils.rdp_accountant import compute_rdp, get_privacy_spent
12
+ from tqdm import tqdm, trange
13
+ import time
14
+
15
+
16
+ class Classifier(Module):
17
+ def __init__(self,input_dim, dis_dims,st_ed):
18
+ super(Classifier,self).__init__()
19
+ dim = input_dim-(st_ed[1]-st_ed[0])
20
+ seq = []
21
+ self.str_end = st_ed
22
+ for item in list(dis_dims):
23
+ seq += [
24
+ Linear(dim, item),
25
+ LeakyReLU(0.2),
26
+ Dropout(0.5)
27
+ ]
28
+ dim = item
29
+
30
+ if (st_ed[1]-st_ed[0])==1:
31
+ seq += [Linear(dim, 1)]
32
+
33
+ elif (st_ed[1]-st_ed[0])==2:
34
+ seq += [Linear(dim, 1),Sigmoid()]
35
+ else:
36
+ seq += [Linear(dim,(st_ed[1]-st_ed[0]))]
37
+
38
+ self.seq = Sequential(*seq)
39
+
40
+ def forward(self, input):
41
+
42
+ label=None
43
+
44
+ if (self.str_end[1]-self.str_end[0])==1:
45
+ label = input[:, self.str_end[0]:self.str_end[1]]
46
+ else:
47
+ label = torch.argmax(input[:, self.str_end[0]:self.str_end[1]], axis=-1)
48
+
49
+ new_imp = torch.cat((input[:,:self.str_end[0]],input[:,self.str_end[1]:]),1)
50
+
51
+ if ((self.str_end[1]-self.str_end[0])==2) | ((self.str_end[1]-self.str_end[0])==1):
52
+ return self.seq(new_imp).view(-1), label
53
+ else:
54
+ return self.seq(new_imp), label
55
+
56
+ def apply_activate(data, output_info):
57
+ data_t = []
58
+ st = 0
59
+ for item in output_info:
60
+ if item[1] == 'tanh':
61
+ ed = st + item[0]
62
+ data_t.append(torch.tanh(data[:, st:ed]))
63
+ st = ed
64
+ elif item[1] == 'softmax':
65
+ ed = st + item[0]
66
+ data_t.append(F.gumbel_softmax(data[:, st:ed], tau=0.2))
67
+ st = ed
68
+ return torch.cat(data_t, dim=1)
69
+
70
+ def get_st_ed(target_col_index,output_info):
71
+ st = 0
72
+ c= 0
73
+ tc= 0
74
+
75
+ for item in output_info:
76
+ if c==target_col_index:
77
+ break
78
+ if item[1]=='tanh':
79
+ st += item[0]
80
+ if item[2] == 'yes_g':
81
+ c+=1
82
+ elif item[1] == 'softmax':
83
+ st += item[0]
84
+ c+=1
85
+ tc+=1
86
+
87
+ ed= st+output_info[tc][0]
88
+
89
+ return (st,ed)
90
+
91
+ def random_choice_prob_index_sampling(probs,col_idx):
92
+ option_list = []
93
+ for i in col_idx:
94
+ pp = probs[i]
95
+ option_list.append(np.random.choice(np.arange(len(probs[i])), p=pp))
96
+
97
+ return np.array(option_list).reshape(col_idx.shape)
98
+
99
+ def random_choice_prob_index(a, axis=1):
100
+ r = np.expand_dims(np.random.rand(a.shape[1 - axis]), axis=axis)
101
+ return (a.cumsum(axis=axis) > r).argmax(axis=axis)
102
+
103
+ def maximum_interval(output_info):
104
+ max_interval = 0
105
+ for item in output_info:
106
+ max_interval = max(max_interval, item[0])
107
+ return max_interval
108
+
109
+ class Cond(object):
110
+ def __init__(self, data, output_info):
111
+
112
+ self.model = []
113
+ st = 0
114
+ counter = 0
115
+ for item in output_info:
116
+
117
+ if item[1] == 'tanh':
118
+ st += item[0]
119
+ continue
120
+ elif item[1] == 'softmax':
121
+ ed = st + item[0]
122
+ counter += 1
123
+ self.model.append(np.argmax(data[:, st:ed], axis=-1))
124
+ st = ed
125
+
126
+ self.interval = []
127
+ self.n_col = 0
128
+ self.n_opt = 0
129
+ st = 0
130
+ self.p = np.zeros((counter, maximum_interval(output_info)))
131
+ self.p_sampling = []
132
+ for item in output_info:
133
+ if item[1] == 'tanh':
134
+ st += item[0]
135
+ continue
136
+ elif item[1] == 'softmax':
137
+ ed = st + item[0]
138
+ tmp = np.sum(data[:, st:ed], axis=0)
139
+ tmp_sampling = np.sum(data[:, st:ed], axis=0)
140
+ tmp = np.log(tmp + 1)
141
+ tmp = tmp / np.sum(tmp)
142
+ tmp_sampling = tmp_sampling / np.sum(tmp_sampling)
143
+ self.p_sampling.append(tmp_sampling)
144
+ self.p[self.n_col, :item[0]] = tmp
145
+ self.interval.append((self.n_opt, item[0]))
146
+ self.n_opt += item[0]
147
+ self.n_col += 1
148
+ st = ed
149
+
150
+ self.interval = np.asarray(self.interval)
151
+
152
+ def sample_train(self, batch):
153
+ if self.n_col == 0:
154
+ return None
155
+ batch = batch
156
+
157
+ idx = np.random.choice(np.arange(self.n_col), batch)
158
+
159
+ vec = np.zeros((batch, self.n_opt), dtype='float32')
160
+ mask = np.zeros((batch, self.n_col), dtype='float32')
161
+ mask[np.arange(batch), idx] = 1
162
+ opt1prime = random_choice_prob_index(self.p[idx])
163
+ for i in np.arange(batch):
164
+ vec[i, self.interval[idx[i], 0] + opt1prime[i]] = 1
165
+
166
+ return vec, mask, idx, opt1prime
167
+
168
+ def sample(self, batch):
169
+ if self.n_col == 0:
170
+ return None
171
+ batch = batch
172
+
173
+ idx = np.random.choice(np.arange(self.n_col), batch)
174
+
175
+ vec = np.zeros((batch, self.n_opt), dtype='float32')
176
+ opt1prime = random_choice_prob_index_sampling(self.p_sampling,idx)
177
+
178
+ for i in np.arange(batch):
179
+ vec[i, self.interval[idx[i], 0] + opt1prime[i]] = 1
180
+
181
+ return vec
182
+
183
+ def cond_loss(data, output_info, c, m):
184
+ loss = []
185
+ st = 0
186
+ st_c = 0
187
+ for item in output_info:
188
+ if item[1] == 'tanh':
189
+ st += item[0]
190
+ continue
191
+
192
+ elif item[1] == 'softmax':
193
+ ed = st + item[0]
194
+ ed_c = st_c + item[0]
195
+ tmp = F.cross_entropy(
196
+ data[:, st:ed],
197
+ torch.argmax(c[:, st_c:ed_c], dim=1),
198
+ reduction='none')
199
+ loss.append(tmp)
200
+ st = ed
201
+ st_c = ed_c
202
+
203
+ loss = torch.stack(loss, dim=1)
204
+ return (loss * m).sum() / data.size()[0]
205
+
206
+ class Sampler(object):
207
+ def __init__(self, data, output_info):
208
+ super(Sampler, self).__init__()
209
+ self.data = data
210
+ self.model = []
211
+ self.n = len(data)
212
+ st = 0
213
+ for item in output_info:
214
+ if item[1] == 'tanh':
215
+ st += item[0]
216
+ continue
217
+ elif item[1] == 'softmax':
218
+ ed = st + item[0]
219
+ tmp = []
220
+ for j in range(item[0]):
221
+ tmp.append(np.nonzero(data[:, st + j])[0])
222
+ self.model.append(tmp)
223
+ st = ed
224
+
225
+ def sample(self, n, col, opt):
226
+ if col is None:
227
+ idx = np.random.choice(np.arange(self.n), n)
228
+ return self.data[idx]
229
+ idx = []
230
+ for c, o in zip(col, opt):
231
+ idx.append(np.random.choice(self.model[c][o]))
232
+ return self.data[idx]
233
+
234
+ class Discriminator(Module):
235
+ def __init__(self, side, layers):
236
+ super(Discriminator, self).__init__()
237
+ self.side = side
238
+ info = len(layers)-2
239
+ self.seq = Sequential(*layers)
240
+ self.seq_info = Sequential(*layers[:info])
241
+
242
+ def forward(self, input):
243
+ return (self.seq(input)), self.seq_info(input)
244
+
245
+ class Generator(Module):
246
+ def __init__(self, side, layers):
247
+ super(Generator, self).__init__()
248
+ self.side = side
249
+ self.seq = Sequential(*layers)
250
+
251
+ def forward(self, input_):
252
+ return self.seq(input_)
253
+
254
+ def determine_layers_disc(side, num_channels):
255
+ assert side >= 4 and side <= 64
256
+
257
+ layer_dims = [(1, side), (num_channels, side // 2)]
258
+
259
+ while layer_dims[-1][1] > 3 and len(layer_dims) < 4:
260
+ layer_dims.append((layer_dims[-1][0] * 2, layer_dims[-1][1] // 2))
261
+
262
+ layerNorms = []
263
+ num_c = num_channels
264
+ num_s = side / 2
265
+ for l in range(len(layer_dims) - 1):
266
+ layerNorms.append([int(num_c), int(num_s), int(num_s)])
267
+ num_c = num_c * 2
268
+ num_s = num_s / 2
269
+
270
+ layers_D = []
271
+
272
+ for prev, curr, ln in zip(layer_dims, layer_dims[1:], layerNorms):
273
+ layers_D += [
274
+ Conv2d(prev[0], curr[0], 4, 2, 1, bias=False),
275
+ LayerNorm(ln),
276
+ LeakyReLU(0.2, inplace=True),
277
+ ]
278
+
279
+ layers_D += [Conv2d(layer_dims[-1][0], 1, layer_dims[-1][1], 1, 0), ReLU(True)]
280
+
281
+ return layers_D
282
+
283
+ def determine_layers_gen(side, random_dim, num_channels):
284
+ assert side >= 4 and side <= 64
285
+
286
+ layer_dims = [(1, side), (num_channels, side // 2)]
287
+
288
+ while layer_dims[-1][1] > 3 and len(layer_dims) < 4:
289
+ layer_dims.append((layer_dims[-1][0] * 2, layer_dims[-1][1] // 2))
290
+
291
+ layerNorms = []
292
+
293
+ num_c = num_channels * (2 ** (len(layer_dims) - 2))
294
+ num_s = int(side / (2 ** (len(layer_dims) - 1)))
295
+ for l in range(len(layer_dims) - 1):
296
+ layerNorms.append([int(num_c), int(num_s), int(num_s)])
297
+ num_c = num_c / 2
298
+ num_s = num_s * 2
299
+
300
+ layers_G = [ConvTranspose2d(random_dim, layer_dims[-1][0], layer_dims[-1][1], 1, 0, output_padding=0, bias=False)]
301
+
302
+ for prev, curr, ln in zip(reversed(layer_dims), reversed(layer_dims[:-1]), layerNorms):
303
+ layers_G += [LayerNorm(ln), ReLU(True), ConvTranspose2d(prev[0], curr[0], 4, 2, 1, output_padding=0, bias=True)]
304
+ return layers_G
305
+
306
+ def slerp(val, low, high):
307
+ low_norm = low/torch.norm(low, dim=1, keepdim=True)
308
+ high_norm = high/torch.norm(high, dim=1, keepdim=True)
309
+ omega = torch.acos((low_norm*high_norm).sum(1)).view(val.size(0), 1)
310
+ so = torch.sin(omega)
311
+ res = (torch.sin((1.0-val)*omega)/so)*low + (torch.sin(val*omega)/so) * high
312
+
313
+ return res
314
+
315
+ def calc_gradient_penalty_slerp(netD, real_data, fake_data, transformer, device='cpu', lambda_=10):
316
+ batchsize = real_data.shape[0]
317
+ alpha = torch.rand(batchsize, 1, device=device)
318
+ interpolates = slerp(alpha, real_data, fake_data)
319
+ interpolates = interpolates.to(device)
320
+ interpolates = transformer.transform(interpolates)
321
+ interpolates = torch.autograd.Variable(interpolates, requires_grad=True)
322
+ disc_interpolates,_ = netD(interpolates)
323
+
324
+ gradients = torch.autograd.grad(outputs=disc_interpolates, inputs=interpolates,
325
+ grad_outputs=torch.ones(disc_interpolates.size()).to(device),
326
+ create_graph=True, retain_graph=True, only_inputs=True)[0]
327
+
328
+ gradients_norm = gradients.norm(2, dim=1)
329
+ gradient_penalty = ((gradients_norm - 1) ** 2).mean() * lambda_
330
+
331
+ return gradient_penalty
332
+
333
+ def weights_init(m):
334
+ classname = m.__class__.__name__
335
+
336
+ if classname.find('Conv') != -1:
337
+ init.normal_(m.weight.data, 0.0, 0.02)
338
+
339
+ elif classname.find('BatchNorm') != -1:
340
+ init.normal_(m.weight.data, 1.0, 0.02)
341
+ init.constant_(m.bias.data, 0)
342
+
343
+ class CTABGANSynthesizer:
344
+ def __init__(self,
345
+ class_dim=(256, 256, 256, 256),
346
+ random_dim=100,
347
+ num_channels=64,
348
+ l2scale=1e-5,
349
+ batch_size=500,
350
+ epochs=150,
351
+ lr=2e-4,
352
+ device="cpu"):
353
+
354
+
355
+ self.random_dim = random_dim
356
+ self.class_dim = class_dim
357
+ self.num_channels = num_channels
358
+ self.dside = None
359
+ self.gside = None
360
+ self.l2scale = l2scale
361
+ self.lr = lr
362
+ self.batch_size = batch_size
363
+ self.epochs = epochs
364
+ self.device = torch.device(device)
365
+
366
+ def fit(self, train_data=pd.DataFrame, categorical=[], mixed={}, general=[], non_categorical=[], type={}):
367
+
368
+ problem_type = None
369
+ target_index=None
370
+ if type:
371
+ problem_type = list(type.keys())[0]
372
+ if problem_type:
373
+ target_index = train_data.columns.get_loc(type[problem_type])
374
+
375
+ self.transformer = DataTransformer(train_data=train_data, categorical_list=categorical, mixed_dict=mixed, general_list=general, non_categorical_list=non_categorical)
376
+ self.transformer.fit()
377
+ train_data = self.transformer.transform(train_data.values)
378
+ data_sampler = Sampler(train_data, self.transformer.output_info)
379
+ data_dim = self.transformer.output_dim
380
+ self.cond_generator = Cond(train_data, self.transformer.output_info)
381
+
382
+ sides = [4, 8, 16, 24, 32]
383
+ col_size_d = data_dim + self.cond_generator.n_opt
384
+ for i in sides:
385
+ if i * i >= col_size_d:
386
+ self.dside = i
387
+ break
388
+
389
+ sides = [4, 8, 16, 24, 32]
390
+ col_size_g = data_dim
391
+ for i in sides:
392
+ if i * i >= col_size_g:
393
+ self.gside = i
394
+ break
395
+
396
+
397
+ layers_G = determine_layers_gen(self.gside, self.random_dim+self.cond_generator.n_opt, self.num_channels)
398
+ layers_D = determine_layers_disc(self.dside, self.num_channels)
399
+
400
+ self.generator = Generator(self.gside, layers_G).to(self.device)
401
+ discriminator = Discriminator(self.dside, layers_D).to(self.device)
402
+ optimizer_params = dict(lr=self.lr, betas=(0.5, 0.9), eps=1e-3, weight_decay=self.l2scale)
403
+ optimizerG = Adam(self.generator.parameters(), **optimizer_params)
404
+ optimizerD = Adam(discriminator.parameters(), **optimizer_params)
405
+
406
+ st_ed = None
407
+ classifier=None
408
+ optimizerC= None
409
+ if target_index != None:
410
+ st_ed= get_st_ed(target_index,self.transformer.output_info)
411
+ classifier = Classifier(data_dim,self.class_dim,st_ed).to(self.device)
412
+ optimizerC = optim.Adam(classifier.parameters(),**optimizer_params)
413
+
414
+
415
+ self.generator.apply(weights_init)
416
+ discriminator.apply(weights_init)
417
+
418
+ self.Gtransformer = ImageTransformer(self.gside)
419
+ self.Dtransformer = ImageTransformer(self.dside)
420
+
421
+ epsilon = 0
422
+ epoch = 0
423
+ steps = 0
424
+ ci = 1
425
+
426
+ for i in tqdm(range(self.epochs)):
427
+
428
+
429
+ for _ in range(ci):
430
+ noisez = torch.randn(self.batch_size, self.random_dim, device=self.device)
431
+ condvec = self.cond_generator.sample_train(self.batch_size)
432
+
433
+ c, m, col, opt = condvec
434
+ c = torch.from_numpy(c).to(self.device)
435
+ m = torch.from_numpy(m).to(self.device)
436
+ noisez = torch.cat([noisez, c], dim=1)
437
+ noisez = noisez.view(self.batch_size,self.random_dim+self.cond_generator.n_opt,1,1)
438
+
439
+ perm = np.arange(self.batch_size)
440
+ np.random.shuffle(perm)
441
+ real = data_sampler.sample(self.batch_size, col[perm], opt[perm])
442
+ c_perm = c[perm]
443
+
444
+ real = torch.from_numpy(real.astype('float32')).to(self.device)
445
+
446
+ fake = self.generator(noisez)
447
+ faket = self.Gtransformer.inverse_transform(fake)
448
+ fakeact = apply_activate(faket, self.transformer.output_info)
449
+
450
+ fake_cat = torch.cat([fakeact, c], dim=1)
451
+ real_cat = torch.cat([real, c_perm], dim=1)
452
+
453
+ real_cat_d = self.Dtransformer.transform(real_cat)
454
+ fake_cat_d = self.Dtransformer.transform(fake_cat)
455
+
456
+ optimizerD.zero_grad()
457
+
458
+ d_real,_ = discriminator(real_cat_d)
459
+
460
+
461
+ d_real = -torch.mean(d_real)
462
+ d_real.backward()
463
+
464
+
465
+ d_fake,_ = discriminator(fake_cat_d)
466
+
467
+ d_fake = torch.mean(d_fake)
468
+
469
+ d_fake.backward()
470
+
471
+ pen = calc_gradient_penalty_slerp(discriminator, real_cat, fake_cat, self.Dtransformer , self.device)
472
+
473
+ pen.backward()
474
+
475
+ optimizerD.step()
476
+
477
+ noisez = torch.randn(self.batch_size, self.random_dim, device=self.device)
478
+
479
+ condvec = self.cond_generator.sample_train(self.batch_size)
480
+
481
+ c, m, col, opt = condvec
482
+ c = torch.from_numpy(c).to(self.device)
483
+ m = torch.from_numpy(m).to(self.device)
484
+ noisez = torch.cat([noisez, c], dim=1)
485
+ noisez = noisez.view(self.batch_size,self.random_dim+self.cond_generator.n_opt,1,1)
486
+
487
+ optimizerG.zero_grad()
488
+
489
+ fake = self.generator(noisez)
490
+ faket = self.Gtransformer.inverse_transform(fake)
491
+ fakeact = apply_activate(faket, self.transformer.output_info)
492
+
493
+ fake_cat = torch.cat([fakeact, c], dim=1)
494
+ fake_cat = self.Dtransformer.transform(fake_cat)
495
+
496
+ y_fake,info_fake = discriminator(fake_cat)
497
+
498
+ cross_entropy = cond_loss(faket, self.transformer.output_info, c, m)
499
+
500
+ _,info_real = discriminator(real_cat_d)
501
+
502
+
503
+ g = -torch.mean(y_fake) + cross_entropy
504
+ g.backward(retain_graph=True)
505
+ 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)
506
+ 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)
507
+ loss_info = loss_mean + loss_std
508
+ loss_info.backward()
509
+ optimizerG.step()
510
+
511
+
512
+ if problem_type:
513
+
514
+ fake = self.generator(noisez)
515
+
516
+ faket = self.Gtransformer.inverse_transform(fake)
517
+
518
+ fakeact = apply_activate(faket, self.transformer.output_info)
519
+
520
+ real_pre, real_label = classifier(real)
521
+ fake_pre, fake_label = classifier(fakeact)
522
+
523
+ c_loss = CrossEntropyLoss()
524
+
525
+ if (st_ed[1] - st_ed[0])==1:
526
+ c_loss= SmoothL1Loss()
527
+ real_label = real_label.type_as(real_pre)
528
+ fake_label = fake_label.type_as(fake_pre)
529
+ real_label = torch.reshape(real_label,real_pre.size())
530
+ fake_label = torch.reshape(fake_label,fake_pre.size())
531
+
532
+
533
+ elif (st_ed[1] - st_ed[0])==2:
534
+ c_loss = BCELoss()
535
+ real_label = real_label.type_as(real_pre)
536
+ fake_label = fake_label.type_as(fake_pre)
537
+
538
+ loss_cc = c_loss(real_pre, real_label)
539
+ loss_cg = c_loss(fake_pre, fake_label)
540
+
541
+ optimizerG.zero_grad()
542
+ loss_cg.backward()
543
+ optimizerG.step()
544
+
545
+ optimizerC.zero_grad()
546
+ loss_cc.backward()
547
+ optimizerC.step()
548
+
549
+
550
+
551
+
552
+ @torch.no_grad()
553
+ def sample(self, n, seed=0):
554
+ print(n)
555
+ torch.manual_seed(seed)
556
+ torch.cuda.manual_seed(seed)
557
+ sample_batch_size = 8092
558
+ self.generator.eval()
559
+
560
+ output_info = self.transformer.output_info
561
+ steps = n // sample_batch_size + 1
562
+
563
+ data = []
564
+
565
+ for i in range(steps):
566
+ noisez = torch.randn(sample_batch_size, self.random_dim, device=self.device)
567
+ condvec = self.cond_generator.sample(sample_batch_size)
568
+ c = condvec
569
+ c = torch.from_numpy(c).to(self.device)
570
+ noisez = torch.cat([noisez, c], dim=1)
571
+ noisez = noisez.view(sample_batch_size,self.random_dim+self.cond_generator.n_opt,1,1)
572
+
573
+ fake = self.generator(noisez)
574
+ faket = self.Gtransformer.inverse_transform(fake)
575
+ fakeact = apply_activate(faket,output_info)
576
+ data.append(fakeact.detach().cpu().numpy())
577
+
578
+ data = np.concatenate(data, axis=0)
579
+ result,resample = self.transformer.inverse_transform(data)
580
+
581
+ t0 = time.time()
582
+ while len(result) < n and (time.time() - t0) <= 600:
583
+ data_resample = []
584
+ steps_left = resample// sample_batch_size + 1
585
+ # print(f"Sampling: {len(result)}/{n}")
586
+ for i in range(steps_left):
587
+ noisez = torch.randn(sample_batch_size, self.random_dim, device=self.device)
588
+ condvec = self.cond_generator.sample(sample_batch_size)
589
+ c = condvec
590
+ c = torch.from_numpy(c).to(self.device)
591
+ noisez = torch.cat([noisez, c], dim=1)
592
+ noisez = noisez.view(sample_batch_size,self.random_dim+self.cond_generator.n_opt,1,1)
593
+
594
+ fake = self.generator(noisez)
595
+ faket = self.Gtransformer.inverse_transform(fake)
596
+ fakeact = apply_activate(faket, output_info)
597
+ data_resample.append(fakeact.detach().cpu().numpy())
598
+
599
+ data_resample = np.concatenate(data_resample, axis=0)
600
+
601
+ res,resample = self.transformer.inverse_transform(data_resample)
602
+ result = np.concatenate([result,res],axis=0)
603
+
604
+ return result[0:n]
605
+
syntheticFail/n18/tabddpm/tabddpm-n18-20260511_002808/_tabddpm_runtime/CTAB-GAN-Plus/model/synthesizer/transformer.py ADDED
@@ -0,0 +1,429 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ import numpy as np
2
+ import pandas as pd
3
+ import torch
4
+ from sklearn.mixture import BayesianGaussianMixture
5
+
6
+ class DataTransformer():
7
+
8
+ def __init__(self, train_data=pd.DataFrame, categorical_list=[], mixed_dict={}, general_list=[], non_categorical_list=[], n_clusters=10, eps=0.005):
9
+ self.meta = None
10
+ self.n_clusters = n_clusters
11
+ self.eps = eps
12
+ self.train_data = train_data
13
+ self.categorical_columns= categorical_list
14
+ self.mixed_columns= mixed_dict
15
+ self.general_columns = general_list
16
+ self.non_categorical_columns= non_categorical_list
17
+
18
+ def get_metadata(self):
19
+
20
+ meta = []
21
+
22
+ for index in range(self.train_data.shape[1]):
23
+ column = self.train_data.iloc[:,index]
24
+ if index in self.categorical_columns:
25
+ if index in self.non_categorical_columns:
26
+ meta.append({
27
+ "name": index,
28
+ "type": "continuous",
29
+ "min": column.min(),
30
+ "max": column.max(),
31
+ })
32
+ else:
33
+ mapper = column.value_counts().index.tolist()
34
+ meta.append({
35
+ "name": index,
36
+ "type": "categorical",
37
+ "size": len(mapper),
38
+ "i2s": mapper
39
+ })
40
+
41
+ elif index in self.mixed_columns.keys():
42
+ meta.append({
43
+ "name": index,
44
+ "type": "mixed",
45
+ "min": column.min(),
46
+ "max": column.max(),
47
+ "modal": self.mixed_columns[index]
48
+ })
49
+ else:
50
+ meta.append({
51
+ "name": index,
52
+ "type": "continuous",
53
+ "min": column.min(),
54
+ "max": column.max(),
55
+ })
56
+
57
+ return meta
58
+
59
+ def fit(self):
60
+ data = self.train_data.values
61
+ self.meta = self.get_metadata()
62
+ model = []
63
+ self.ordering = []
64
+ self.output_info = []
65
+ self.output_dim = 0
66
+ self.components = []
67
+ self.filter_arr = []
68
+ for id_, info in enumerate(self.meta):
69
+ if info['type'] == "continuous":
70
+ if id_ not in self.general_columns:
71
+ gm = BayesianGaussianMixture(
72
+ n_components = self.n_clusters,
73
+ weight_concentration_prior_type='dirichlet_process',
74
+ weight_concentration_prior=0.001,
75
+ max_iter=100,n_init=1, random_state=42)
76
+ gm.fit(data[:, id_].reshape([-1, 1]))
77
+ mode_freq = (pd.Series(gm.predict(data[:, id_].reshape([-1, 1]))).value_counts().keys())
78
+ model.append(gm)
79
+ old_comp = gm.weights_ > self.eps
80
+ comp = []
81
+ for i in range(self.n_clusters):
82
+ if (i in (mode_freq)) & old_comp[i]:
83
+ comp.append(True)
84
+ else:
85
+ comp.append(False)
86
+ self.components.append(comp)
87
+ self.output_info += [(1, 'tanh','no_g'), (np.sum(comp), 'softmax')]
88
+ self.output_dim += 1 + np.sum(comp)
89
+ else:
90
+ model.append(None)
91
+ self.components.append(None)
92
+ self.output_info += [(1, 'tanh','yes_g')]
93
+ self.output_dim += 1
94
+
95
+ elif info['type'] == "mixed":
96
+
97
+ gm1 = BayesianGaussianMixture(
98
+ n_components = self.n_clusters,
99
+ weight_concentration_prior_type='dirichlet_process',
100
+ weight_concentration_prior=0.001, max_iter=100,
101
+ n_init=1,random_state=42)
102
+ gm2 = BayesianGaussianMixture(
103
+ n_components = self.n_clusters,
104
+ weight_concentration_prior_type='dirichlet_process',
105
+ weight_concentration_prior=0.001, max_iter=100,
106
+ n_init=1,random_state=42)
107
+
108
+ gm1.fit(data[:, id_].reshape([-1, 1]))
109
+
110
+ filter_arr = []
111
+ for element in data[:, id_]:
112
+ if element not in info['modal']:
113
+ filter_arr.append(True)
114
+ else:
115
+ filter_arr.append(False)
116
+
117
+ gm2.fit(data[:, id_][filter_arr].reshape([-1, 1]))
118
+ mode_freq = (pd.Series(gm2.predict(data[:, id_][filter_arr].reshape([-1, 1]))).value_counts().keys())
119
+ self.filter_arr.append(filter_arr)
120
+ model.append((gm1,gm2))
121
+
122
+ old_comp = gm2.weights_ > self.eps
123
+
124
+ comp = []
125
+
126
+ for i in range(self.n_clusters):
127
+ if (i in (mode_freq)) & old_comp[i]:
128
+ comp.append(True)
129
+ else:
130
+ comp.append(False)
131
+
132
+ self.components.append(comp)
133
+
134
+ self.output_info += [(1, 'tanh',"no_g"), (np.sum(comp) + len(info['modal']), 'softmax')]
135
+ self.output_dim += 1 + np.sum(comp) + len(info['modal'])
136
+ else:
137
+ model.append(None)
138
+ self.components.append(None)
139
+ self.output_info += [(info['size'], 'softmax')]
140
+ self.output_dim += info['size']
141
+ self.model = model
142
+
143
+ def transform(self, data, ispositive = False, positive_list = None):
144
+ values = []
145
+ mixed_counter = 0
146
+ for id_, info in enumerate(self.meta):
147
+ current = data[:, id_]
148
+ if info['type'] == "continuous":
149
+ if id_ not in self.general_columns:
150
+ current = current.reshape([-1, 1])
151
+ means = self.model[id_].means_.reshape((1, self.n_clusters))
152
+ stds = np.sqrt(self.model[id_].covariances_).reshape((1, self.n_clusters))
153
+ features = np.empty(shape=(len(current),self.n_clusters))
154
+ if ispositive == True:
155
+ if id_ in positive_list:
156
+ features = np.abs(current - means) / (4 * stds)
157
+ else:
158
+ features = (current - means) / (4 * stds)
159
+
160
+ probs = self.model[id_].predict_proba(current.reshape([-1, 1]))
161
+ n_opts = sum(self.components[id_])
162
+ features = features[:, self.components[id_]]
163
+ probs = probs[:, self.components[id_]]
164
+
165
+ opt_sel = np.zeros(len(data), dtype='int')
166
+ for i in range(len(data)):
167
+ pp = probs[i] + 1e-6
168
+ pp = pp / sum(pp)
169
+ opt_sel[i] = np.random.choice(np.arange(n_opts), p=pp)
170
+
171
+ idx = np.arange((len(features)))
172
+ features = features[idx, opt_sel].reshape([-1, 1])
173
+ features = np.clip(features, -.99, .99)
174
+ probs_onehot = np.zeros_like(probs)
175
+ probs_onehot[np.arange(len(probs)), opt_sel] = 1
176
+
177
+ re_ordered_phot = np.zeros_like(probs_onehot)
178
+
179
+ col_sums = probs_onehot.sum(axis=0)
180
+
181
+
182
+ n = probs_onehot.shape[1]
183
+ largest_indices = np.argsort(-1*col_sums)[:n]
184
+ self.ordering.append(largest_indices)
185
+ for id,val in enumerate(largest_indices):
186
+ re_ordered_phot[:,id] = probs_onehot[:,val]
187
+
188
+
189
+ values += [features, re_ordered_phot]
190
+
191
+ else:
192
+
193
+ self.ordering.append(None)
194
+
195
+ if id_ in self.non_categorical_columns:
196
+ info['min'] = -1e-3
197
+ info['max'] = info['max'] + 1e-3
198
+
199
+ current = (current - (info['min'])) / (info['max'] - info['min'])
200
+ current = current * 2 - 1
201
+ current = current.reshape([-1, 1])
202
+ values.append(current)
203
+
204
+ elif info['type'] == "mixed":
205
+
206
+ means_0 = self.model[id_][0].means_.reshape([-1])
207
+ stds_0 = np.sqrt(self.model[id_][0].covariances_).reshape([-1])
208
+
209
+ zero_std_list = []
210
+ means_needed = []
211
+ stds_needed = []
212
+
213
+ for mode in info['modal']:
214
+ if mode!=-9999999:
215
+ dist = []
216
+ for idx,val in enumerate(list(means_0.flatten())):
217
+ dist.append(abs(mode-val))
218
+ index_min = np.argmin(np.array(dist))
219
+ zero_std_list.append(index_min)
220
+ else: continue
221
+
222
+ for idx in zero_std_list:
223
+ means_needed.append(means_0[idx])
224
+ stds_needed.append(stds_0[idx])
225
+
226
+
227
+ mode_vals = []
228
+
229
+ for i,j,k in zip(info['modal'],means_needed,stds_needed):
230
+ this_val = np.abs(i - j) / (4*k)
231
+ mode_vals.append(this_val)
232
+
233
+ if -9999999 in info["modal"]:
234
+ mode_vals.append(0)
235
+
236
+ current = current.reshape([-1, 1])
237
+ filter_arr = self.filter_arr[mixed_counter]
238
+ current = current[filter_arr]
239
+
240
+ means = self.model[id_][1].means_.reshape((1, self.n_clusters))
241
+ stds = np.sqrt(self.model[id_][1].covariances_).reshape((1, self.n_clusters))
242
+ features = np.empty(shape=(len(current),self.n_clusters))
243
+ if ispositive == True:
244
+ if id_ in positive_list:
245
+ features = np.abs(current - means) / (4 * stds)
246
+ else:
247
+ features = (current - means) / (4 * stds)
248
+
249
+ probs = self.model[id_][1].predict_proba(current.reshape([-1, 1]))
250
+
251
+ n_opts = sum(self.components[id_]) # 8
252
+ features = features[:, self.components[id_]]
253
+ probs = probs[:, self.components[id_]]
254
+
255
+ opt_sel = np.zeros(len(current), dtype='int')
256
+ for i in range(len(current)):
257
+ pp = probs[i] + 1e-6
258
+ pp = pp / sum(pp)
259
+ opt_sel[i] = np.random.choice(np.arange(n_opts), p=pp)
260
+ idx = np.arange((len(features)))
261
+ features = features[idx, opt_sel].reshape([-1, 1])
262
+ features = np.clip(features, -.99, .99)
263
+ probs_onehot = np.zeros_like(probs)
264
+ probs_onehot[np.arange(len(probs)), opt_sel] = 1
265
+ extra_bits = np.zeros([len(current), len(info['modal'])])
266
+ temp_probs_onehot = np.concatenate([extra_bits,probs_onehot], axis = 1)
267
+ final = np.zeros([len(data), 1 + probs_onehot.shape[1] + len(info['modal'])])
268
+ features_curser = 0
269
+ for idx, val in enumerate(data[:, id_]):
270
+ if val in info['modal']:
271
+ category_ = list(map(info['modal'].index, [val]))[0]
272
+ final[idx, 0] = mode_vals[category_]
273
+ final[idx, (category_+1)] = 1
274
+
275
+ else:
276
+ final[idx, 0] = features[features_curser]
277
+ final[idx, (1+len(info['modal'])):] = temp_probs_onehot[features_curser][len(info['modal']):]
278
+ features_curser = features_curser + 1
279
+
280
+ just_onehot = final[:,1:]
281
+ re_ordered_jhot= np.zeros_like(just_onehot)
282
+ n = just_onehot.shape[1]
283
+ col_sums = just_onehot.sum(axis=0)
284
+ largest_indices = np.argsort(-1*col_sums)[:n]
285
+ self.ordering.append(largest_indices)
286
+ for id,val in enumerate(largest_indices):
287
+ re_ordered_jhot[:,id] = just_onehot[:,val]
288
+ final_features = final[:,0].reshape([-1, 1])
289
+ values += [final_features, re_ordered_jhot]
290
+ mixed_counter = mixed_counter + 1
291
+
292
+ else:
293
+ self.ordering.append(None)
294
+ col_t = np.zeros([len(data), info['size']])
295
+ idx = list(map(info['i2s'].index, current))
296
+ col_t[np.arange(len(data)), idx] = 1
297
+ values.append(col_t)
298
+
299
+ return np.concatenate(values, axis=1)
300
+
301
+ def inverse_transform(self, data):
302
+ data_t = np.zeros([len(data), len(self.meta)])
303
+ invalid_ids = []
304
+ st = 0
305
+ for id_, info in enumerate(self.meta):
306
+ if info['type'] == "continuous":
307
+ if id_ not in self.general_columns:
308
+ u = data[:, st]
309
+ v = data[:, st + 1:st + 1 + np.sum(self.components[id_])]
310
+ order = self.ordering[id_]
311
+ v_re_ordered = np.zeros_like(v)
312
+
313
+ for id,val in enumerate(order):
314
+ v_re_ordered[:,val] = v[:,id]
315
+
316
+ v = v_re_ordered
317
+
318
+ u = np.clip(u, -1, 1)
319
+ v_t = np.ones((data.shape[0], self.n_clusters)) * -100
320
+ v_t[:, self.components[id_]] = v
321
+ v = v_t
322
+ st += 1 + np.sum(self.components[id_])
323
+ means = self.model[id_].means_.reshape([-1])
324
+ stds = np.sqrt(self.model[id_].covariances_).reshape([-1])
325
+ p_argmax = np.argmax(v, axis=1)
326
+ std_t = stds[p_argmax]
327
+ mean_t = means[p_argmax]
328
+ tmp = u * 4 * std_t + mean_t
329
+
330
+ for idx,val in enumerate(tmp):
331
+ if (val < info["min"]) | (val > info['max']):
332
+ invalid_ids.append(idx)
333
+
334
+ if id_ in self.non_categorical_columns:
335
+
336
+ tmp = np.round(tmp)
337
+
338
+ data_t[:, id_] = tmp
339
+
340
+ else:
341
+ u = data[:, st]
342
+ u = (u + 1) / 2
343
+ u = np.clip(u, 0, 1)
344
+ u = u * (info['max'] - info['min']) + info['min']
345
+ if id_ in self.non_categorical_columns:
346
+ data_t[:, id_] = np.round(u)
347
+ else: data_t[:, id_] = u
348
+
349
+ st += 1
350
+
351
+ elif info['type'] == "mixed":
352
+
353
+ u = data[:, st]
354
+ full_v = data[:,(st+1):(st+1)+len(info['modal'])+np.sum(self.components[id_])]
355
+ order = self.ordering[id_]
356
+ full_v_re_ordered = np.zeros_like(full_v)
357
+
358
+ for id,val in enumerate(order):
359
+ full_v_re_ordered[:,val] = full_v[:,id]
360
+
361
+ full_v = full_v_re_ordered
362
+
363
+
364
+ mixed_v = full_v[:,:len(info['modal'])]
365
+ v = full_v[:,-np.sum(self.components[id_]):]
366
+
367
+ u = np.clip(u, -1, 1)
368
+ v_t = np.ones((data.shape[0], self.n_clusters)) * -100
369
+ v_t[:, self.components[id_]] = v
370
+ v = np.concatenate([mixed_v,v_t], axis=1)
371
+
372
+ st += 1 + np.sum(self.components[id_]) + len(info['modal'])
373
+ means = self.model[id_][1].means_.reshape([-1])
374
+ stds = np.sqrt(self.model[id_][1].covariances_).reshape([-1])
375
+ p_argmax = np.argmax(v, axis=1)
376
+
377
+ result = np.zeros_like(u)
378
+
379
+ for idx in range(len(data)):
380
+ if p_argmax[idx] < len(info['modal']):
381
+ argmax_value = p_argmax[idx]
382
+ result[idx] = float(list(map(info['modal'].__getitem__, [argmax_value]))[0])
383
+ else:
384
+ std_t = stds[(p_argmax[idx]-len(info['modal']))]
385
+ mean_t = means[(p_argmax[idx]-len(info['modal']))]
386
+ result[idx] = u[idx] * 4 * std_t + mean_t
387
+
388
+ for idx,val in enumerate(result):
389
+ if (val < info["min"]) | (val > info['max']):
390
+ invalid_ids.append(idx)
391
+
392
+ data_t[:, id_] = result
393
+
394
+ else:
395
+ current = data[:, st:st + info['size']]
396
+ st += info['size']
397
+ idx = np.argmax(current, axis=1)
398
+ data_t[:, id_] = list(map(info['i2s'].__getitem__, idx))
399
+
400
+
401
+ invalid_ids = np.unique(np.array(invalid_ids))
402
+ all_ids = np.arange(0,len(data))
403
+ valid_ids = list(set(all_ids) - set(invalid_ids))
404
+
405
+ return data_t[valid_ids],len(invalid_ids)
406
+
407
+
408
+ class ImageTransformer():
409
+
410
+ def __init__(self, side):
411
+
412
+ self.height = side
413
+
414
+ def transform(self, data):
415
+
416
+ if self.height * self.height > len(data[0]):
417
+
418
+ padding = torch.zeros((len(data), self.height * self.height - len(data[0]))).to(data.device)
419
+ data = torch.cat([data, padding], axis=1)
420
+
421
+ return data.view(-1, 1, self.height, self.height)
422
+
423
+ def inverse_transform(self, data):
424
+
425
+ data = data.view(-1, self.height * self.height)
426
+
427
+ return data
428
+
429
+
syntheticFail/n18/tabddpm/tabddpm-n18-20260511_002808/_tabddpm_runtime/CTAB-GAN-Plus/pipeline_ctabganp.py ADDED
@@ -0,0 +1,81 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ import tomli
2
+ import shutil
3
+ import os
4
+ import argparse
5
+ from train_sample_ctabganp import train_ctabgan, sample_ctabgan
6
+ from scripts.eval_catboost import train_catboost
7
+ import zero
8
+ import lib
9
+ from model.ctabgan import CTABGAN
10
+
11
+ def load_config(path) :
12
+ with open(path, 'rb') as f:
13
+ return tomli.load(f)
14
+
15
+ def save_file(parent_dir, config_path):
16
+ try:
17
+ dst = os.path.join(parent_dir)
18
+ os.makedirs(os.path.dirname(dst), exist_ok=True)
19
+ shutil.copyfile(os.path.abspath(config_path), dst)
20
+ except shutil.SameFileError:
21
+ pass
22
+
23
+ def main():
24
+ parser = argparse.ArgumentParser()
25
+ parser.add_argument('--config', metavar='FILE')
26
+ parser.add_argument('--train', action='store_true', default=False)
27
+ parser.add_argument('--sample', action='store_true', default=False)
28
+ parser.add_argument('--eval', action='store_true', default=False)
29
+ parser.add_argument('--change_val', action='store_true', default=False)
30
+
31
+ args = parser.parse_args()
32
+ raw_config = lib.load_config(args.config)
33
+ timer = zero.Timer()
34
+ timer.run()
35
+ save_file(os.path.join(raw_config['parent_dir'], 'config.toml'), args.config)
36
+ ctabgan = None
37
+ if args.train:
38
+ ctabgan = train_ctabgan(
39
+ parent_dir=raw_config['parent_dir'],
40
+ real_data_path=raw_config['real_data_path'],
41
+ train_params=raw_config['train_params'],
42
+ change_val=args.change_val,
43
+ device=raw_config['device']
44
+ )
45
+ if args.sample:
46
+ sample_ctabgan(
47
+ synthesizer=ctabgan,
48
+ parent_dir=raw_config['parent_dir'],
49
+ real_data_path=raw_config['real_data_path'],
50
+ num_samples=raw_config['sample']['num_samples'],
51
+ train_params=raw_config['train_params'],
52
+ change_val=args.change_val,
53
+ seed=raw_config['sample']['seed'],
54
+ device=raw_config['device']
55
+ )
56
+
57
+ save_file(os.path.join(raw_config['parent_dir'], 'info.json'), os.path.join(raw_config['real_data_path'], 'info.json'))
58
+ if args.eval:
59
+ if raw_config['eval']['type']['eval_model'] == 'catboost':
60
+ train_catboost(
61
+ parent_dir=raw_config['parent_dir'],
62
+ real_data_path=raw_config['real_data_path'],
63
+ eval_type=raw_config['eval']['type']['eval_type'],
64
+ T_dict=raw_config['eval']['T'],
65
+ seed=raw_config['seed'],
66
+ change_val=args.change_val
67
+ )
68
+ # elif raw_config['eval']['type']['eval_model'] == 'mlp':
69
+ # train_mlp(
70
+ # parent_dir=raw_config['parent_dir'],
71
+ # real_data_path=raw_config['real_data_path'],
72
+ # eval_type=raw_config['eval']['type']['eval_type'],
73
+ # T_dict=raw_config['eval']['T'],
74
+ # seed=raw_config['seed'],
75
+ # change_val=args.change_val
76
+ # )
77
+
78
+ print(f'Elapsed time: {str(timer)}')
79
+
80
+ if __name__ == '__main__':
81
+ main()
syntheticFail/n18/tabddpm/tabddpm-n18-20260511_002808/_tabddpm_runtime/CTAB-GAN-Plus/train_sample_ctabganp.py ADDED
@@ -0,0 +1,110 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ import lib
2
+ import os
3
+ import numpy as np
4
+ import argparse
5
+ from model.ctabgan import CTABGAN
6
+ from pathlib import Path
7
+ import torch
8
+ import pickle
9
+
10
+
11
+ def train_ctabgan(
12
+ parent_dir,
13
+ real_data_path,
14
+ train_params = {"batch_size": 512},
15
+ change_val=False,
16
+ device = "cpu"
17
+ ):
18
+ real_data_path = Path(real_data_path)
19
+ parent_dir = Path(parent_dir)
20
+ device = torch.device(device)
21
+
22
+ if change_val:
23
+ X_num_train, X_cat_train, y_train, _, _, _ = lib.read_changed_val(real_data_path)
24
+ else:
25
+ X_num_train, X_cat_train, y_train = lib.read_pure_data(real_data_path, 'train')
26
+
27
+ X = lib.concat_to_pd(X_num_train, X_cat_train, y_train)
28
+
29
+ X.columns = [str(_) for _ in X.columns]
30
+
31
+ ctabgan_params = lib.load_json("CTAB-GAN-Plus/columns.json")[real_data_path.name]
32
+ train_params["batch_size"] = min(y_train.shape[0], train_params["batch_size"])
33
+
34
+ print(train_params)
35
+ synthesizer = CTABGAN(
36
+ df = X,
37
+ test_ratio = 0.0,
38
+ **ctabgan_params,
39
+ **train_params,
40
+ device=device
41
+ )
42
+
43
+ synthesizer.fit()
44
+
45
+ # save_ctabgan(synthesizer, parent_dir)
46
+ with open(parent_dir / "ctabgan.obj", "wb") as f:
47
+ pickle.dump(synthesizer, f)
48
+
49
+ return synthesizer
50
+
51
+ def sample_ctabgan(
52
+ synthesizer,
53
+ parent_dir,
54
+ real_data_path,
55
+ num_samples,
56
+ train_params = {"batch_size": 512},
57
+ change_val=False,
58
+ device="cpu",
59
+ seed=0
60
+ ):
61
+ real_data_path = Path(real_data_path)
62
+ parent_dir = Path(parent_dir)
63
+ device = torch.device(device)
64
+
65
+ if change_val:
66
+ X_num_train, X_cat_train, y_train, _, _, _ = lib.read_changed_val(real_data_path)
67
+ else:
68
+ X_num_train, X_cat_train, y_train = lib.read_pure_data(real_data_path, 'train')
69
+
70
+ X = lib.concat_to_pd(X_num_train, X_cat_train, y_train)
71
+
72
+ X.columns = [str(_) for _ in X.columns]
73
+
74
+ ctabgan_params = lib.load_json("CTAB-GAN-Plus/columns.json")[real_data_path.name]
75
+
76
+ cat_features = ctabgan_params["categorical_columns"]
77
+ # if synthesizer is None:
78
+ # synthesizer = load_ctabgan(X, ctabgan_params, train_params, parent_dir)
79
+ with open(parent_dir / "ctabgan.obj", 'rb') as f:
80
+ synthesizer = pickle.load(f)
81
+ synthesizer.synthesizer.generator = synthesizer.synthesizer.generator.to(device)
82
+ gen_data = synthesizer.generate_samples(num_samples, seed)
83
+
84
+ y = gen_data['y'].values
85
+ if len(np.unique(y)) == 1:
86
+ y[0] = 0
87
+ y[1] = 1
88
+
89
+ X_cat = gen_data[cat_features].drop('y', axis=1, errors="ignore").values if len(cat_features) else None
90
+ X_num = gen_data.values[:, :X_num_train.shape[1]] if X_num_train is not None else None
91
+
92
+ if X_num_train is not None:
93
+ np.save(parent_dir / 'X_num_train', X_num.astype(float))
94
+ if X_cat_train is not None:
95
+ np.save(parent_dir / 'X_cat_train', X_cat.astype(str))
96
+ np.save(parent_dir / 'y_train', y.astype(float).astype(int)) # only clf !!!
97
+
98
+ def main():
99
+ parser = argparse.ArgumentParser()
100
+ parser.add_argument('real_data_path', type=str)
101
+ parser.add_argument('parent_dir', type=str)
102
+ parser.add_argument('train_size', type=int)
103
+ args = parser.parse_args()
104
+
105
+ ctabgan = train_ctabgan(args.parent_dir, args.real_data_path, change_val=True)
106
+ sample_ctabgan(ctabgan, args.parent_dir, args.real_data_path, args.train_size, change_val=True)
107
+
108
+
109
+ if __name__ == '__main__':
110
+ main()
syntheticFail/n18/tabddpm/tabddpm-n18-20260511_002808/_tabddpm_runtime/CTAB-GAN-Plus/tune_ctabgan.py ADDED
@@ -0,0 +1,153 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ from multiprocessing.sharedctypes import RawValue
2
+ from random import random
3
+ import tempfile
4
+ import subprocess
5
+ import lib
6
+ import os
7
+ import optuna
8
+ import argparse
9
+ from pathlib import Path
10
+ from train_sample_ctabganp import train_ctabgan, sample_ctabgan
11
+ from scripts.eval_catboost import train_catboost
12
+
13
+ parser = argparse.ArgumentParser()
14
+ parser.add_argument('data_path', type=str)
15
+ parser.add_argument('train_size', type=int)
16
+ parser.add_argument('eval_type', type=str)
17
+ parser.add_argument('device', type=str)
18
+
19
+ args = parser.parse_args()
20
+ real_data_path = args.data_path
21
+ eval_type = args.eval_type
22
+ train_size = args.train_size
23
+ device = args.device
24
+ assert eval_type in ('merged', 'synthetic')
25
+
26
+ def objective(trial):
27
+
28
+ lr = trial.suggest_loguniform('lr', 0.00001, 0.003)
29
+
30
+ def suggest_dim(name):
31
+ t = trial.suggest_int(name, d_min, d_max)
32
+ return 2 ** t
33
+
34
+ # construct model
35
+ min_n_layers, max_n_layers, d_min, d_max = 1, 4, 6, 8
36
+ n_layers = trial.suggest_int('n_layers', min_n_layers, max_n_layers)
37
+ d_first = [suggest_dim('d_first')] if n_layers else []
38
+ d_middle = (
39
+ [suggest_dim('d_middle')] * (n_layers - 2)
40
+ if n_layers > 2
41
+ else []
42
+ )
43
+ d_last = [suggest_dim('d_last')] if n_layers > 1 else []
44
+ d_layers = d_first + d_middle + d_last
45
+ ####
46
+
47
+ steps = trial.suggest_categorical('steps', [1000, 5000, 10000])
48
+ # steps = trial.suggest_categorical('steps', [10])
49
+ batch_size = 2 ** trial.suggest_int('batch_size', 9, 11)
50
+ random_dim = 2 ** trial.suggest_int('random_dim', 4, 7)
51
+ num_channels = 2 ** trial.suggest_int('num_channels', 4, 6)
52
+
53
+ # steps = trial.suggest_categorical('steps', [1000])
54
+
55
+ num_samples = int(train_size * (2 ** trial.suggest_int('frac_samples', -2, 3)))
56
+
57
+ train_params = {
58
+ "lr": lr,
59
+ "epochs": steps,
60
+ "class_dim": d_layers,
61
+ "batch_size": batch_size,
62
+ "random_dim": random_dim,
63
+ "num_channels": num_channels
64
+ }
65
+ trial.set_user_attr("train_params", train_params)
66
+ trial.set_user_attr("num_samples", num_samples)
67
+
68
+ score = 0.0
69
+ with tempfile.TemporaryDirectory() as dir_:
70
+ dir_ = Path(dir_)
71
+ ctabgan = train_ctabgan(
72
+ parent_dir=dir_,
73
+ real_data_path=real_data_path,
74
+ train_params=train_params,
75
+ change_val=True,
76
+ device=device
77
+ )
78
+
79
+ for sample_seed in range(5):
80
+ sample_ctabgan(
81
+ ctabgan,
82
+ parent_dir=dir_,
83
+ real_data_path=real_data_path,
84
+ num_samples=num_samples,
85
+ train_params=train_params,
86
+ change_val=True,
87
+ seed=sample_seed,
88
+ device=device
89
+ )
90
+
91
+ T_dict = {
92
+ "seed": 0,
93
+ "normalization": None,
94
+ "num_nan_policy": None,
95
+ "cat_nan_policy": None,
96
+ "cat_min_frequency": None,
97
+ "cat_encoding": None,
98
+ "y_policy": "default"
99
+ }
100
+ metrics = train_catboost(
101
+ parent_dir=dir_,
102
+ real_data_path=real_data_path,
103
+ eval_type=eval_type,
104
+ T_dict=T_dict,
105
+ change_val=True,
106
+ seed = 0
107
+ )
108
+
109
+ score += metrics.get_val_score()
110
+ return score / 5
111
+
112
+
113
+ study = optuna.create_study(
114
+ direction='maximize',
115
+ sampler=optuna.samplers.TPESampler(seed=0),
116
+ )
117
+
118
+ study.optimize(objective, n_trials=35, show_progress_bar=True)
119
+
120
+ os.makedirs(f"exp/{Path(real_data_path).name}/ctabgan-plus/", exist_ok=True)
121
+ config = {
122
+ "parent_dir": f"exp/{Path(real_data_path).name}/ctabgan-plus/",
123
+ "real_data_path": real_data_path,
124
+ "seed": 0,
125
+ "device": args.device,
126
+ "train_params": study.best_trial.user_attrs["train_params"],
127
+ "sample": {"seed": 0, "num_samples": study.best_trial.user_attrs["num_samples"]},
128
+ "eval": {
129
+ "type": {"eval_model": "catboost", "eval_type": eval_type},
130
+ "T": {
131
+ "seed": 0,
132
+ "normalization": None,
133
+ "num_nan_policy": None,
134
+ "cat_nan_policy": None,
135
+ "cat_min_frequency": None,
136
+ "cat_encoding": None,
137
+ "y_policy": "default"
138
+ },
139
+ }
140
+ }
141
+
142
+ train_ctabgan(
143
+ parent_dir=f"exp/{Path(real_data_path).name}/ctabgan-plus/",
144
+ real_data_path=real_data_path,
145
+ train_params=study.best_trial.user_attrs["train_params"],
146
+ change_val=False,
147
+ device=device
148
+ )
149
+
150
+ lib.dump_config(config, config["parent_dir"]+"config.toml")
151
+
152
+ subprocess.run(['python3.9', "scripts/eval_seeds.py", '--config', f'{config["parent_dir"]+"config.toml"}',
153
+ '10', "ctabgan-plus", eval_type, "catboost", "5"], check=True)
syntheticFail/n18/tabddpm/tabddpm-n18-20260511_002808/_tabddpm_runtime/CTAB-GAN/.gitignore ADDED
@@ -0,0 +1 @@
 
 
1
+ **/**.csv
syntheticFail/n18/tabddpm/tabddpm-n18-20260511_002808/_tabddpm_runtime/CTAB-GAN/LICENSE ADDED
@@ -0,0 +1,201 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ Apache License
2
+ Version 2.0, January 2004
3
+ http://www.apache.org/licenses/
4
+
5
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
6
+
7
+ 1. Definitions.
8
+
9
+ "License" shall mean the terms and conditions for use, reproduction,
10
+ and distribution as defined by Sections 1 through 9 of this document.
11
+
12
+ "Licensor" shall mean the copyright owner or entity authorized by
13
+ the copyright owner that is granting the License.
14
+
15
+ "Legal Entity" shall mean the union of the acting entity and all
16
+ other entities that control, are controlled by, or are under common
17
+ control with that entity. For the purposes of this definition,
18
+ "control" means (i) the power, direct or indirect, to cause the
19
+ direction or management of such entity, whether by contract or
20
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
21
+ outstanding shares, or (iii) beneficial ownership of such entity.
22
+
23
+ "You" (or "Your") shall mean an individual or Legal Entity
24
+ exercising permissions granted by this License.
25
+
26
+ "Source" form shall mean the preferred form for making modifications,
27
+ including but not limited to software source code, documentation
28
+ source, and configuration files.
29
+
30
+ "Object" form shall mean any form resulting from mechanical
31
+ transformation or translation of a Source form, including but
32
+ not limited to compiled object code, generated documentation,
33
+ and conversions to other media types.
34
+
35
+ "Work" shall mean the work of authorship, whether in Source or
36
+ Object form, made available under the License, as indicated by a
37
+ copyright notice that is included in or attached to the work
38
+ (an example is provided in the Appendix below).
39
+
40
+ "Derivative Works" shall mean any work, whether in Source or Object
41
+ form, that is based on (or derived from) the Work and for which the
42
+ editorial revisions, annotations, elaborations, or other modifications
43
+ represent, as a whole, an original work of authorship. For the purposes
44
+ of this License, Derivative Works shall not include works that remain
45
+ separable from, or merely link (or bind by name) to the interfaces of,
46
+ the Work and Derivative Works thereof.
47
+
48
+ "Contribution" shall mean any work of authorship, including
49
+ the original version of the Work and any modifications or additions
50
+ to that Work or Derivative Works thereof, that is intentionally
51
+ submitted to Licensor for inclusion in the Work by the copyright owner
52
+ or by an individual or Legal Entity authorized to submit on behalf of
53
+ the copyright owner. For the purposes of this definition, "submitted"
54
+ means any form of electronic, verbal, or written communication sent
55
+ to the Licensor or its representatives, including but not limited to
56
+ communication on electronic mailing lists, source code control systems,
57
+ and issue tracking systems that are managed by, or on behalf of, the
58
+ Licensor for the purpose of discussing and improving the Work, but
59
+ excluding communication that is conspicuously marked or otherwise
60
+ designated in writing by the copyright owner as "Not a Contribution."
61
+
62
+ "Contributor" shall mean Licensor and any individual or Legal Entity
63
+ on behalf of whom a Contribution has been received by Licensor and
64
+ subsequently incorporated within the Work.
65
+
66
+ 2. Grant of Copyright License. Subject to the terms and conditions of
67
+ this License, each Contributor hereby grants to You a perpetual,
68
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
69
+ copyright license to reproduce, prepare Derivative Works of,
70
+ publicly display, publicly perform, sublicense, and distribute the
71
+ Work and such Derivative Works in Source or Object form.
72
+
73
+ 3. Grant of Patent License. Subject to the terms and conditions of
74
+ this License, each Contributor hereby grants to You a perpetual,
75
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
76
+ (except as stated in this section) patent license to make, have made,
77
+ use, offer to sell, sell, import, and otherwise transfer the Work,
78
+ where such license applies only to those patent claims licensable
79
+ by such Contributor that are necessarily infringed by their
80
+ Contribution(s) alone or by combination of their Contribution(s)
81
+ with the Work to which such Contribution(s) was submitted. If You
82
+ institute patent litigation against any entity (including a
83
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
84
+ or a Contribution incorporated within the Work constitutes direct
85
+ or contributory patent infringement, then any patent licenses
86
+ granted to You under this License for that Work shall terminate
87
+ as of the date such litigation is filed.
88
+
89
+ 4. Redistribution. You may reproduce and distribute copies of the
90
+ Work or Derivative Works thereof in any medium, with or without
91
+ modifications, and in Source or Object form, provided that You
92
+ meet the following conditions:
93
+
94
+ (a) You must give any other recipients of the Work or
95
+ Derivative Works a copy of this License; and
96
+
97
+ (b) You must cause any modified files to carry prominent notices
98
+ stating that You changed the files; and
99
+
100
+ (c) You must retain, in the Source form of any Derivative Works
101
+ that You distribute, all copyright, patent, trademark, and
102
+ attribution notices from the Source form of the Work,
103
+ excluding those notices that do not pertain to any part of
104
+ the Derivative Works; and
105
+
106
+ (d) If the Work includes a "NOTICE" text file as part of its
107
+ distribution, then any Derivative Works that You distribute must
108
+ include a readable copy of the attribution notices contained
109
+ within such NOTICE file, excluding those notices that do not
110
+ pertain to any part of the Derivative Works, in at least one
111
+ of the following places: within a NOTICE text file distributed
112
+ as part of the Derivative Works; within the Source form or
113
+ documentation, if provided along with the Derivative Works; or,
114
+ within a display generated by the Derivative Works, if and
115
+ wherever such third-party notices normally appear. The contents
116
+ of the NOTICE file are for informational purposes only and
117
+ do not modify the License. You may add Your own attribution
118
+ notices within Derivative Works that You distribute, alongside
119
+ or as an addendum to the NOTICE text from the Work, provided
120
+ that such additional attribution notices cannot be construed
121
+ as modifying the License.
122
+
123
+ You may add Your own copyright statement to Your modifications and
124
+ may provide additional or different license terms and conditions
125
+ for use, reproduction, or distribution of Your modifications, or
126
+ for any such Derivative Works as a whole, provided Your use,
127
+ reproduction, and distribution of the Work otherwise complies with
128
+ the conditions stated in this License.
129
+
130
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
131
+ any Contribution intentionally submitted for inclusion in the Work
132
+ by You to the Licensor shall be under the terms and conditions of
133
+ this License, without any additional terms or conditions.
134
+ Notwithstanding the above, nothing herein shall supersede or modify
135
+ the terms of any separate license agreement you may have executed
136
+ with Licensor regarding such Contributions.
137
+
138
+ 6. Trademarks. This License does not grant permission to use the trade
139
+ names, trademarks, service marks, or product names of the Licensor,
140
+ except as required for reasonable and customary use in describing the
141
+ origin of the Work and reproducing the content of the NOTICE file.
142
+
143
+ 7. Disclaimer of Warranty. Unless required by applicable law or
144
+ agreed to in writing, Licensor provides the Work (and each
145
+ Contributor provides its Contributions) on an "AS IS" BASIS,
146
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
147
+ implied, including, without limitation, any warranties or conditions
148
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
149
+ PARTICULAR PURPOSE. You are solely responsible for determining the
150
+ appropriateness of using or redistributing the Work and assume any
151
+ risks associated with Your exercise of permissions under this License.
152
+
153
+ 8. Limitation of Liability. In no event and under no legal theory,
154
+ whether in tort (including negligence), contract, or otherwise,
155
+ unless required by applicable law (such as deliberate and grossly
156
+ negligent acts) or agreed to in writing, shall any Contributor be
157
+ liable to You for damages, including any direct, indirect, special,
158
+ incidental, or consequential damages of any character arising as a
159
+ result of this License or out of the use or inability to use the
160
+ Work (including but not limited to damages for loss of goodwill,
161
+ work stoppage, computer failure or malfunction, or any and all
162
+ other commercial damages or losses), even if such Contributor
163
+ has been advised of the possibility of such damages.
164
+
165
+ 9. Accepting Warranty or Additional Liability. While redistributing
166
+ the Work or Derivative Works thereof, You may choose to offer,
167
+ and charge a fee for, acceptance of support, warranty, indemnity,
168
+ or other liability obligations and/or rights consistent with this
169
+ License. However, in accepting such obligations, You may act only
170
+ on Your own behalf and on Your sole responsibility, not on behalf
171
+ of any other Contributor, and only if You agree to indemnify,
172
+ defend, and hold each Contributor harmless for any liability
173
+ incurred by, or claims asserted against, such Contributor by reason
174
+ of your accepting any such warranty or additional liability.
175
+
176
+ END OF TERMS AND CONDITIONS
177
+
178
+ APPENDIX: How to apply the Apache License to your work.
179
+
180
+ To apply the Apache License to your work, attach the following
181
+ boilerplate notice, with the fields enclosed by brackets "[]"
182
+ replaced with your own identifying information. (Don't include
183
+ the brackets!) The text should be enclosed in the appropriate
184
+ comment syntax for the file format. We also recommend that a
185
+ file or class name and description of purpose be included on the
186
+ same "printed page" as the copyright notice for easier
187
+ identification within third-party archives.
188
+
189
+ Copyright [yyyy] [name of copyright owner]
190
+
191
+ Licensed under the Apache License, Version 2.0 (the "License");
192
+ you may not use this file except in compliance with the License.
193
+ You may obtain a copy of the License at
194
+
195
+ http://www.apache.org/licenses/LICENSE-2.0
196
+
197
+ Unless required by applicable law or agreed to in writing, software
198
+ distributed under the License is distributed on an "AS IS" BASIS,
199
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
200
+ See the License for the specific language governing permissions and
201
+ limitations under the License.
syntheticFail/n18/tabddpm/tabddpm-n18-20260511_002808/_tabddpm_runtime/CTAB-GAN/License.txt ADDED
@@ -0,0 +1,15 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ Distributed learning systems Lab at TU Delft & Generatrix, hereby disclaims all copyright interest in the program "CTAB-GAN" (which synthesizes tabular data)
2
+
3
+ Copyright 2020-2022 Distributed learning systems Lab at TU Delft & Generatrix.
4
+
5
+ Licensed under the Apache License, Version 2.0 (the "License");
6
+ you may not use this file except in compliance with the License.
7
+ You may obtain a copy of the License at
8
+
9
+ https://www.apache.org/licenses/LICENSE-2.0
10
+
11
+ Unless required by applicable law or agreed to in writing, software
12
+ distributed under the License is distributed on an "AS IS" BASIS,
13
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14
+ See the License for the specific language governing permissions and
15
+ limitations under the License.
syntheticFail/n18/tabddpm/tabddpm-n18-20260511_002808/_tabddpm_runtime/CTAB-GAN/README.md ADDED
@@ -0,0 +1,50 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # CTAB-GAN
2
+ 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.
3
+
4
+
5
+ ## Prerequisite
6
+
7
+ The required package version
8
+ ```
9
+ numpy==1.21.0
10
+ torch==1.9.1
11
+ pandas==1.2.4
12
+ sklearn==0.24.1
13
+ dython==0.6.4.post1
14
+ scipy==1.4.1
15
+ ```
16
+
17
+ ## Example
18
+ `Experiment_Script_Adult.ipynb` is an example notebook for training CTAB-GAN with Adult dataset. The dataset is alread under `Real_Datasets` folder.
19
+ The evaluation code is also provided.
20
+
21
+ ## For large dataset
22
+
23
+ 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
24
+ ```
25
+ sides = [4, 8, 16, 24, 32]
26
+ ```
27
+ 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.
28
+
29
+ ## Bibtex
30
+
31
+ To cite this paper, you could use this bibtex
32
+
33
+ ```
34
+ @InProceedings{zhao21,
35
+ title = {CTAB-GAN: Effective Table Data Synthesizing},
36
+ author = {Zhao, Zilong and Kunar, Aditya and Birke, Robert and Chen, Lydia Y.},
37
+ booktitle = {Proceedings of The 13th Asian Conference on Machine Learning},
38
+ pages = {97--112},
39
+ year = {2021},
40
+ editor = {Balasubramanian, Vineeth N. and Tsang, Ivor},
41
+ volume = {157},
42
+ series = {Proceedings of Machine Learning Research},
43
+ month = {17--19 Nov},
44
+ publisher = {PMLR},
45
+ pdf = {https://proceedings.mlr.press/v157/zhao21a/zhao21a.pdf},
46
+ url = {https://proceedings.mlr.press/v157/zhao21a.html}
47
+ }
48
+
49
+
50
+ ```
syntheticFail/n18/tabddpm/tabddpm-n18-20260511_002808/_tabddpm_runtime/CTAB-GAN/columns.json ADDED
@@ -0,0 +1,74 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "churn2": {
3
+ "categorical_columns": ["7", "8", "9", "10", "y"],
4
+ "mixed_columns": {"0": [850.0], "3": [0.0]},
5
+ "integer_columns": ["1", "2", "4"],
6
+ "problem_type": {"Classification": "y"}
7
+ },
8
+ "adult": {
9
+ "categorical_columns": ["6", "7", "8", "9", "10", "11", "12", "13", "y"],
10
+ "mixed_columns": {"3": [0.0], "4": [0.0]},
11
+ "integer_columns": ["0", "2", "5"],
12
+ "problem_type": {"Classification": "y"}
13
+ },
14
+ "buddy": {
15
+ "categorical_columns": ["4", "5", "6", "7", "8", "y"],
16
+ "mixed_columns": {},
17
+ "integer_columns": ["0", "1"],
18
+ "problem_type": {"Classification": "y"}
19
+ },
20
+ "gesture": {
21
+ "categorical_columns": ["y"],
22
+ "mixed_columns": {},
23
+ "integer_columns": [],
24
+ "problem_type": {"Classification": "y"}
25
+ },
26
+ "wilt": {
27
+ "categorical_columns": ["y"],
28
+ "mixed_columns": {},
29
+ "integer_columns": [],
30
+ "problem_type": {"Classification": "y"}
31
+ },
32
+ "satellite": {
33
+ "categorical_columns": ["y"],
34
+ "mixed_columns": {},
35
+ "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
+ "problem_type": {"Classification": "y"}
37
+ },
38
+ "higgs-small": {
39
+ "categorical_columns": ["y"],
40
+ "mixed_columns": {},
41
+ "integer_columns": [],
42
+ "problem_type": {"Classification": "y"}
43
+ },
44
+ "diabetes": {
45
+ "categorical_columns": ["y"],
46
+ "mixed_columns": {"3": [0.0], "4": [0.0]},
47
+ "integer_columns": ["0", "1", "2", "5", "7"],
48
+ "problem_type": {"Classification": "y"}
49
+ },
50
+ "default": {
51
+ "categorical_columns": ["20", "21", "22", "y"],
52
+ "mixed_columns": {},
53
+ "integer_columns": ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19"],
54
+ "problem_type": {"Classification": "y"}
55
+ },
56
+ "otto": {
57
+ "categorical_columns": ["y"],
58
+ "mixed_columns": {},
59
+ "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"],
60
+ "problem_type": {"Classification": "y"}
61
+ },
62
+ "cardio": {
63
+ "categorical_columns": ["5", "6", "7", "8", "9", "10", "y"],
64
+ "mixed_columns": {},
65
+ "integer_columns": ["0", "1", "3", "4"],
66
+ "problem_type": {"Classification": "y"}
67
+ },
68
+ "miniboone": {
69
+ "categorical_columns": ["y"],
70
+ "mixed_columns": {},
71
+ "integer_columns": [],
72
+ "problem_type": {"Classification": "y"}
73
+ }
74
+ }
syntheticFail/n18/tabddpm/tabddpm-n18-20260511_002808/_tabddpm_runtime/CTAB-GAN/model/__init__.py ADDED
File without changes
syntheticFail/n18/tabddpm/tabddpm-n18-20260511_002808/_tabddpm_runtime/CTAB-GAN/model/ctabgan.py ADDED
@@ -0,0 +1,58 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ """
2
+ Generative model training algorithm based on the CTABGANSynthesiser
3
+
4
+ """
5
+ import pandas as pd
6
+ import time
7
+ from model.pipeline.data_preparation import DataPrep
8
+ from model.synthesizer.ctabgan_synthesizer import CTABGANSynthesizer
9
+
10
+ import warnings
11
+
12
+ warnings.filterwarnings("ignore")
13
+
14
+ class CTABGAN():
15
+
16
+ def __init__(self,
17
+ df,
18
+ test_ratio = 0.20,
19
+ categorical_columns = [ 'workclass', 'education', 'marital-status', 'occupation', 'relationship', 'race', 'gender', 'native-country', 'income'],
20
+ log_columns = [],
21
+ mixed_columns= {'capital-loss':[0.0],'capital-gain':[0.0]},
22
+ integer_columns = ['age', 'fnlwgt','capital-gain', 'capital-loss','hours-per-week'],
23
+ problem_type= {"Classification": 'income'},
24
+ batch_size = 512,
25
+ class_dim = (256, 256, 256, 256),
26
+ lr = 2e-4,
27
+ epochs = 10,
28
+ device=None):
29
+
30
+ self.__name__ = 'CTABGAN'
31
+
32
+ self.synthesizer = CTABGANSynthesizer(lr = lr, epochs = epochs, batch_size = batch_size, class_dim = class_dim, device = device)
33
+ self.raw_df = df
34
+ print(self.raw_df.shape)
35
+ self.test_ratio = test_ratio
36
+ self.categorical_columns = categorical_columns
37
+ self.log_columns = log_columns
38
+ self.mixed_columns = mixed_columns
39
+ self.integer_columns = integer_columns
40
+ self.problem_type = problem_type
41
+
42
+ def fit(self, no_train=False):
43
+ print("-"*100)
44
+ start_time = time.time()
45
+ 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)
46
+ self.synthesizer.fit(train_data=self.data_prep.df, categorical = self.data_prep.column_types["categorical"],
47
+ mixed = self.data_prep.column_types["mixed"],type=self.problem_type, no_train=no_train)
48
+ end_time = time.time()
49
+ print('Finished training in',end_time-start_time," seconds.")
50
+ print("-"*100)
51
+
52
+
53
+ def generate_samples(self, num_samples, seed=0):
54
+
55
+ sample = self.synthesizer.sample(num_samples, seed)
56
+ sample_df = self.data_prep.inverse_prep(sample)
57
+
58
+ return sample_df
syntheticFail/n18/tabddpm/tabddpm-n18-20260511_002808/_tabddpm_runtime/CTAB-GAN/model/eval/evaluation.py ADDED
@@ -0,0 +1,191 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ import numpy as np
2
+ import pandas as pd
3
+ from sklearn import metrics
4
+ from sklearn import model_selection
5
+ from sklearn.preprocessing import MinMaxScaler,StandardScaler
6
+ from sklearn.neural_network import MLPClassifier
7
+ from sklearn.linear_model import LogisticRegression
8
+ from sklearn import svm,tree
9
+ from sklearn.ensemble import RandomForestClassifier
10
+ from dython.nominal import compute_associations
11
+ from scipy.stats import wasserstein_distance
12
+ from scipy.spatial import distance
13
+ import warnings
14
+
15
+ warnings.filterwarnings("ignore")
16
+
17
+ def supervised_model_training(x_train, y_train, x_test,
18
+ y_test, model_name):
19
+
20
+ if model_name == 'lr':
21
+ model = LogisticRegression(random_state=42,max_iter=500)
22
+ elif model_name == 'svm':
23
+ model = svm.SVC(random_state=42,probability=True)
24
+ elif model_name == 'dt':
25
+ model = tree.DecisionTreeClassifier(random_state=42)
26
+ elif model_name == 'rf':
27
+ model = RandomForestClassifier(random_state=42)
28
+ elif model_name == "mlp":
29
+ model = MLPClassifier(random_state=42,max_iter=100)
30
+
31
+ model.fit(x_train, y_train)
32
+ pred = model.predict(x_test)
33
+
34
+ if len(np.unique(y_train))>2:
35
+ predict = model.predict_proba(x_test)
36
+ acc = metrics.accuracy_score(y_test,pred)*100
37
+ auc = metrics.roc_auc_score(y_test, predict,average="weighted",multi_class="ovr")
38
+ f1_score = metrics.precision_recall_fscore_support(y_test, pred,average="weighted")[2]
39
+ return [acc, auc,f1_score]
40
+
41
+ else:
42
+ predict = model.predict_proba(x_test)[:,1]
43
+ acc = metrics.accuracy_score(y_test,pred)*100
44
+ auc = metrics.roc_auc_score(y_test, predict)
45
+ f1_score = metrics.precision_recall_fscore_support(y_test,pred)[2].mean()
46
+ return [acc, auc,f1_score]
47
+
48
+
49
+ def get_utility_metrics(real_path,fake_paths,scaler="MinMax",classifiers=["lr","dt","rf","mlp"],test_ratio=.20):
50
+
51
+ data_real = pd.read_csv(real_path).to_numpy()
52
+ data_dim = data_real.shape[1]
53
+
54
+ data_real_y = data_real[:,-1]
55
+ data_real_X = data_real[:,:data_dim-1]
56
+ 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)
57
+
58
+ if scaler=="MinMax":
59
+ scaler_real = MinMaxScaler()
60
+ else:
61
+ scaler_real = StandardScaler()
62
+
63
+ scaler_real.fit(X_train_real)
64
+ X_train_real_scaled = scaler_real.transform(X_train_real)
65
+ X_test_real_scaled = scaler_real.transform(X_test_real)
66
+
67
+ all_real_results = []
68
+ for classifier in classifiers:
69
+ real_results = supervised_model_training(X_train_real_scaled,y_train_real,X_test_real_scaled,y_test_real,classifier)
70
+ all_real_results.append(real_results)
71
+
72
+ all_fake_results_avg = []
73
+
74
+ for fake_path in fake_paths:
75
+ data_fake = pd.read_csv(fake_path).to_numpy()
76
+ data_fake_y = data_fake[:,-1]
77
+ data_fake_X = data_fake[:,:data_dim-1]
78
+ 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)
79
+
80
+ if scaler=="MinMax":
81
+ scaler_fake = MinMaxScaler()
82
+ else:
83
+ scaler_fake = StandardScaler()
84
+
85
+ scaler_fake.fit(data_fake_X)
86
+
87
+ X_train_fake_scaled = scaler_fake.transform(X_train_fake)
88
+
89
+ all_fake_results = []
90
+ for classifier in classifiers:
91
+ fake_results = supervised_model_training(X_train_fake_scaled,y_train_fake,X_test_real_scaled,y_test_real,classifier)
92
+ all_fake_results.append(fake_results)
93
+
94
+ all_fake_results_avg.append(all_fake_results)
95
+
96
+ diff_results = np.array(all_real_results)- np.array(all_fake_results_avg).mean(axis=0)
97
+
98
+ return diff_results
99
+
100
+ def stat_sim(real_path,fake_path,cat_cols=None):
101
+
102
+ Stat_dict={}
103
+
104
+ real = pd.read_csv(real_path)
105
+ fake = pd.read_csv(fake_path)
106
+
107
+ really = real.copy()
108
+ fakey = fake.copy()
109
+
110
+ real_corr = compute_associations(real, nominal_columns=cat_cols)
111
+
112
+ fake_corr = compute_associations(fake, nominal_columns=cat_cols)
113
+
114
+ corr_dist = np.linalg.norm(real_corr - fake_corr)
115
+
116
+ cat_stat = []
117
+ num_stat = []
118
+
119
+ for column in real.columns:
120
+
121
+ if column in cat_cols:
122
+ real_pdf=(really[column].value_counts()/really[column].value_counts().sum())
123
+ fake_pdf=(fakey[column].value_counts()/fakey[column].value_counts().sum())
124
+ categories = (fakey[column].value_counts()/fakey[column].value_counts().sum()).keys().tolist()
125
+ sorted_categories = sorted(categories)
126
+
127
+ real_pdf_values = []
128
+ fake_pdf_values = []
129
+
130
+ for i in sorted_categories:
131
+ real_pdf_values.append(real_pdf[i])
132
+ fake_pdf_values.append(fake_pdf[i])
133
+
134
+ if len(real_pdf)!=len(fake_pdf):
135
+ zero_cats = set(really[column].value_counts().keys())-set(fakey[column].value_counts().keys())
136
+ for z in zero_cats:
137
+ real_pdf_values.append(real_pdf[z])
138
+ fake_pdf_values.append(0)
139
+ Stat_dict[column]=(distance.jensenshannon(real_pdf_values,fake_pdf_values, 2.0))
140
+ cat_stat.append(Stat_dict[column])
141
+ else:
142
+ scaler = MinMaxScaler()
143
+ scaler.fit(real[column].values.reshape(-1,1))
144
+ l1 = scaler.transform(real[column].values.reshape(-1,1)).flatten()
145
+ l2 = scaler.transform(fake[column].values.reshape(-1,1)).flatten()
146
+ Stat_dict[column]= (wasserstein_distance(l1,l2))
147
+ num_stat.append(Stat_dict[column])
148
+
149
+ return [np.mean(num_stat),np.mean(cat_stat),corr_dist]
150
+
151
+ def privacy_metrics(real_path,fake_path,data_percent=15):
152
+
153
+ real = pd.read_csv(real_path).drop_duplicates(keep=False)
154
+ fake = pd.read_csv(fake_path).drop_duplicates(keep=False)
155
+
156
+ real_refined = real.sample(n=int(len(real)*(.01*data_percent)), random_state=42).to_numpy()
157
+ fake_refined = fake.sample(n=int(len(fake)*(.01*data_percent)), random_state=42).to_numpy()
158
+
159
+ scalerR = StandardScaler()
160
+ scalerR.fit(real_refined)
161
+ scalerF = StandardScaler()
162
+ scalerF.fit(fake_refined)
163
+ df_real_scaled = scalerR.transform(real_refined)
164
+ df_fake_scaled = scalerF.transform(fake_refined)
165
+
166
+ dist_rf = metrics.pairwise_distances(df_real_scaled, Y=df_fake_scaled, metric='minkowski', n_jobs=-1)
167
+ dist_rr = metrics.pairwise_distances(df_real_scaled, Y=None, metric='minkowski', n_jobs=-1)
168
+ rd_dist_rr = dist_rr[~np.eye(dist_rr.shape[0],dtype=bool)].reshape(dist_rr.shape[0],-1)
169
+ dist_ff = metrics.pairwise_distances(df_fake_scaled, Y=None, metric='minkowski', n_jobs=-1)
170
+ rd_dist_ff = dist_ff[~np.eye(dist_ff.shape[0],dtype=bool)].reshape(dist_ff.shape[0],-1)
171
+ smallest_two_indexes_rf = [dist_rf[i].argsort()[:2] for i in range(len(dist_rf))]
172
+ smallest_two_rf = [dist_rf[i][smallest_two_indexes_rf[i]] for i in range(len(dist_rf))]
173
+ smallest_two_indexes_rr = [rd_dist_rr[i].argsort()[:2] for i in range(len(rd_dist_rr))]
174
+ smallest_two_rr = [rd_dist_rr[i][smallest_two_indexes_rr[i]] for i in range(len(rd_dist_rr))]
175
+ smallest_two_indexes_ff = [rd_dist_ff[i].argsort()[:2] for i in range(len(rd_dist_ff))]
176
+ smallest_two_ff = [rd_dist_ff[i][smallest_two_indexes_ff[i]] for i in range(len(rd_dist_ff))]
177
+ nn_ratio_rr = np.array([i[0]/i[1] for i in smallest_two_rr])
178
+ nn_ratio_ff = np.array([i[0]/i[1] for i in smallest_two_ff])
179
+ nn_ratio_rf = np.array([i[0]/i[1] for i in smallest_two_rf])
180
+ nn_fifth_perc_rr = np.percentile(nn_ratio_rr,5)
181
+ nn_fifth_perc_ff = np.percentile(nn_ratio_ff,5)
182
+ nn_fifth_perc_rf = np.percentile(nn_ratio_rf,5)
183
+
184
+ min_dist_rf = np.array([i[0] for i in smallest_two_rf])
185
+ fifth_perc_rf = np.percentile(min_dist_rf,5)
186
+ min_dist_rr = np.array([i[0] for i in smallest_two_rr])
187
+ fifth_perc_rr = np.percentile(min_dist_rr,5)
188
+ min_dist_ff = np.array([i[0] for i in smallest_two_ff])
189
+ fifth_perc_ff = np.percentile(min_dist_ff,5)
190
+
191
+ 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)