diff --git a/.gitattributes b/.gitattributes index 2b0347be8d2de7f738c606a413a821e1ec2ceec2..86a43df8e4c3e39f7380a53edeb656de1372aea8 100644 --- a/.gitattributes +++ b/.gitattributes @@ -5249,3 +5249,25 @@ SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wi SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/ctabgan/privacies.json filter=lfs diff=lfs merge=lfs -text SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/ddpm_cb_best/config.toml filter=lfs diff=lfs merge=lfs -text SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/ddpm_cb_best/eval_catboost.json filter=lfs diff=lfs merge=lfs -text +SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/ddpm_cb_best/eval_mlp.json filter=lfs diff=lfs merge=lfs -text +SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/ddpm_cb_best/eval_simple.json filter=lfs diff=lfs merge=lfs -text +SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/ddpm_cb_best/importance.json filter=lfs diff=lfs merge=lfs -text +SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/ddpm_cb_best/info.json filter=lfs diff=lfs merge=lfs -text +SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/ddpm_cb_best/privacies.json filter=lfs diff=lfs merge=lfs -text +SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/ddpm_cb_best/privacy.json filter=lfs diff=lfs merge=lfs -text +SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/ddpm_mlp_best/config.toml filter=lfs diff=lfs merge=lfs -text +SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/ddpm_mlp_best/eval_catboost.json filter=lfs diff=lfs merge=lfs -text +SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/ddpm_mlp_best/eval_mlp.json filter=lfs diff=lfs merge=lfs -text +SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/ddpm_mlp_best/importance.json filter=lfs diff=lfs merge=lfs -text +SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/ddpm_mlp_best/info.json filter=lfs diff=lfs merge=lfs -text +SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/smote/config.toml filter=lfs diff=lfs merge=lfs -text +SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/smote/eval_catboost.json filter=lfs diff=lfs merge=lfs -text +SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/smote/eval_mlp.json filter=lfs diff=lfs merge=lfs -text +SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/smote/eval_simple.json filter=lfs diff=lfs merge=lfs -text +SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/smote/info.json filter=lfs diff=lfs merge=lfs -text +SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/smote/privacies.json filter=lfs diff=lfs merge=lfs -text +SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/smote/privacy.json filter=lfs diff=lfs merge=lfs -text +SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/tvae/config.toml filter=lfs diff=lfs merge=lfs -text +SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/tvae/eval_catboost.json filter=lfs diff=lfs merge=lfs -text +SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/tvae/eval_simple.json filter=lfs diff=lfs merge=lfs -text +SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/tvae/info.json filter=lfs diff=lfs merge=lfs -text diff --git a/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/ddpm_cb_best/eval_mlp.json b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/ddpm_cb_best/eval_mlp.json new file mode 100644 index 0000000000000000000000000000000000000000..360331f72e267548c985238e8dddb33ecf33efa7 --- /dev/null +++ b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/ddpm_cb_best/eval_mlp.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2df86c0b6c8fc0e216a53438e3f26bd9e46670c1f5b3dc77426259c971d210f3 +size 1319 diff --git a/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/ddpm_cb_best/eval_simple.json b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/ddpm_cb_best/eval_simple.json new file mode 100644 index 0000000000000000000000000000000000000000..15b6cea0fb960e83bce61a19c94bef54ea0aaecb --- /dev/null +++ b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/ddpm_cb_best/eval_simple.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2f8ca0f43e784616f459b84a576d98839d9abe41af934709640dc8e81efb4e98 +size 6621 diff --git a/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/ddpm_cb_best/importance.json b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/ddpm_cb_best/importance.json new file mode 100644 index 0000000000000000000000000000000000000000..6e1b013baf19c0e01499e397492cadb90ffd0cf8 --- /dev/null +++ b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/ddpm_cb_best/importance.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:04f31ef7049dee20af09577fe45fb41d805af0907e8e137ee3516d0e90d2554f +size 301 diff --git a/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/ddpm_cb_best/info.json b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/ddpm_cb_best/info.json new file mode 100644 index 0000000000000000000000000000000000000000..5a28531bbb83ea1a737c9159d19f13501a54adc0 --- /dev/null +++ b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/ddpm_cb_best/info.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:511a0dc9860b7587f2382407ae286e4160a320f28a3b2bff6bd85ce88a6550e4 +size 191 diff --git a/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/ddpm_cb_best/privacies.json b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/ddpm_cb_best/privacies.json new file mode 100644 index 0000000000000000000000000000000000000000..1a8fd05bfd33b99eb361fba9b6bc1c00e7fa7d35 --- /dev/null +++ b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/ddpm_cb_best/privacies.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f42ff2e01094cd2102a388e7fd6124eb7b7cbf899b465cacf0860127e4c99e78 +size 223 diff --git a/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/ddpm_cb_best/privacy.json b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/ddpm_cb_best/privacy.json new file mode 100644 index 0000000000000000000000000000000000000000..6c0fa171f2c97dde10256df4376995c3177a281e --- /dev/null +++ b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/ddpm_cb_best/privacy.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c87fcede2165d9a1cc54de5f114c0cfdaa21c0dc8a1dbe6ed1232e8e930df025 +size 40 diff --git a/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/ddpm_mlp_best/config.toml b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/ddpm_mlp_best/config.toml new file mode 100644 index 0000000000000000000000000000000000000000..533af56ce20919d8164fa0093972d0f1209ac88e --- /dev/null +++ b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/ddpm_mlp_best/config.toml @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:636b5d5b2495c4c123f00fead30911369c615118fbffa66f12610fcfc4c730ba +size 936 diff --git a/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/ddpm_mlp_best/eval_catboost.json b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/ddpm_mlp_best/eval_catboost.json new file mode 100644 index 0000000000000000000000000000000000000000..88505d5882f86ee3507f9e953138a818dc57caa6 --- /dev/null +++ b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/ddpm_mlp_best/eval_catboost.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:722b3ac7a315c79a1bc37fe46cec8ac815bef9599406c0734cb78c095698f0f8 +size 1318 diff --git a/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/ddpm_mlp_best/eval_mlp.json b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/ddpm_mlp_best/eval_mlp.json new file mode 100644 index 0000000000000000000000000000000000000000..a718382837cf353aa21a2455e5519c638b6aeac8 --- /dev/null +++ b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/ddpm_mlp_best/eval_mlp.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8e04b6d0b94b457eacd407d0338fa99146f6749339d4b64b48001287daa5b7b5 +size 664 diff --git a/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/ddpm_mlp_best/importance.json b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/ddpm_mlp_best/importance.json new file mode 100644 index 0000000000000000000000000000000000000000..a036f5707506ec7bfea76a21e2ee20a931c05065 --- /dev/null +++ b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/ddpm_mlp_best/importance.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9cc24aa23a4db246ab5dfe17125252a50009917323d54e5677507aba6b7f0a38 +size 298 diff --git a/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/ddpm_mlp_best/info.json b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/ddpm_mlp_best/info.json new file mode 100644 index 0000000000000000000000000000000000000000..5a28531bbb83ea1a737c9159d19f13501a54adc0 --- /dev/null +++ b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/ddpm_mlp_best/info.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:511a0dc9860b7587f2382407ae286e4160a320f28a3b2bff6bd85ce88a6550e4 +size 191 diff --git a/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/smote/config.toml b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/smote/config.toml new file mode 100644 index 0000000000000000000000000000000000000000..66c9afda1050096fedb7688d56a9a03ea9926b47 --- /dev/null +++ b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/smote/config.toml @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e161c1def56ea993fc1e643c986456388df3cabfae0c4213cb15565a17e0dcd2 +size 400 diff --git a/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/smote/eval_catboost.json b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/smote/eval_catboost.json new file mode 100644 index 0000000000000000000000000000000000000000..da1d999c49a6040603a6b508b4baa2b9a6719090 --- /dev/null +++ b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/smote/eval_catboost.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4712ec1d5d364761ad171d82d98b083e0e8b567649793dfa488478beef453c08 +size 664 diff --git a/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/smote/eval_mlp.json b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/smote/eval_mlp.json new file mode 100644 index 0000000000000000000000000000000000000000..956bfdeffb7135603d0fabdaa6c8879918cb2384 --- /dev/null +++ b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/smote/eval_mlp.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9063998cac822118a02b7b2d2a568d909c04fc994db129345a81a481a4fd0956 +size 1315 diff --git a/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/smote/eval_simple.json b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/smote/eval_simple.json new file mode 100644 index 0000000000000000000000000000000000000000..36dc119e8917134f5fe5bed0b6ea84ccba3c2ad8 --- /dev/null +++ b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/smote/eval_simple.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:61fe10a9440af4534e2826cbc566e5192f7ae8947c598d2e84fe619b37a359ac +size 3319 diff --git a/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/smote/info.json b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/smote/info.json new file mode 100644 index 0000000000000000000000000000000000000000..5a28531bbb83ea1a737c9159d19f13501a54adc0 --- /dev/null +++ b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/smote/info.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:511a0dc9860b7587f2382407ae286e4160a320f28a3b2bff6bd85ce88a6550e4 +size 191 diff --git a/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/smote/privacies.json b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/smote/privacies.json new file mode 100644 index 0000000000000000000000000000000000000000..188742f3a544abe1953ff5dbd12f1238d1b9ce41 --- /dev/null +++ b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/smote/privacies.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a5b6a5e9214b8d7e50524a5e9177419661add5dc4d3b06ecffe68c7cb4c5f392 +size 223 diff --git a/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/smote/privacy.json b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/smote/privacy.json new file mode 100644 index 0000000000000000000000000000000000000000..f3e143c3c192cbda659bcd16a90b1d26c7f3d2e6 --- /dev/null +++ b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/smote/privacy.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4aa03c0df6c8ca6742c1489e8e37ac08f68c342c863bddf7ca3143426920c576 +size 40 diff --git a/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/tvae/config.toml b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/tvae/config.toml new file mode 100644 index 0000000000000000000000000000000000000000..cc8427f26ad1f9ca2dcb4cc6943fab932096ffc8 --- /dev/null +++ b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/tvae/config.toml @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:50edc7be21196e9e790fe8990bc332150d0550db1b2c46e60d19810e875a3ece +size 605 diff --git a/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/tvae/eval_catboost.json b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/tvae/eval_catboost.json new file mode 100644 index 0000000000000000000000000000000000000000..021c8067d431ea8362123e590cc238472e801ae5 --- /dev/null +++ b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/tvae/eval_catboost.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:36cf4c644fe1879a25693cfb68d88db11c3afb7a9c075e3f4d2d1ea201ca67c5 +size 664 diff --git a/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/tvae/eval_simple.json b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/tvae/eval_simple.json new file mode 100644 index 0000000000000000000000000000000000000000..bd44eefcc1486f6bd4d79b60858ec5796da81e78 --- /dev/null +++ b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/tvae/eval_simple.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b55d374b6630709cb9d4c5814d856dd2520386b992937a3b24d80d71eb2e035c +size 3307 diff --git a/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/tvae/info.json b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/tvae/info.json new file mode 100644 index 0000000000000000000000000000000000000000..5a28531bbb83ea1a737c9159d19f13501a54adc0 --- /dev/null +++ b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/exp/wilt/tvae/info.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:511a0dc9860b7587f2382407ae286e4160a320f28a3b2bff6bd85ce88a6550e4 +size 191 diff --git a/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/lib/__init__.py b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/lib/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..54d6f6bbd104c00418af09162967e1fde1dea4fc --- /dev/null +++ b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/lib/__init__.py @@ -0,0 +1,12 @@ +import torch +from icecream import install + +torch.set_num_threads(1) +install() + +from . import env # noqa +from .data import * # noqa +from .deep import * # noqa +from .env import * # noqa +from .metrics import * # noqa +from .util import * # noqa diff --git a/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/lib/__pycache__/__init__.cpython-311.pyc b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/lib/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1604250c3d8e6c8c288bcc2d9d48fae4cd84030d Binary files /dev/null and b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/lib/__pycache__/__init__.cpython-311.pyc differ diff --git a/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/lib/__pycache__/data.cpython-311.pyc b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/lib/__pycache__/data.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a2e249ac45b9f949833ee23b6b41550d798ba61d Binary files /dev/null and b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/lib/__pycache__/data.cpython-311.pyc differ diff --git a/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/lib/__pycache__/deep.cpython-311.pyc b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/lib/__pycache__/deep.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..768685a4a160085dacce8e40229d93ae06a136be Binary files /dev/null and b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/lib/__pycache__/deep.cpython-311.pyc differ diff --git a/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/lib/__pycache__/env.cpython-311.pyc b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/lib/__pycache__/env.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a95b6ed55bba434311c8309b671d2020d365c1eb Binary files /dev/null and b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/lib/__pycache__/env.cpython-311.pyc differ diff --git a/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/lib/__pycache__/metrics.cpython-311.pyc b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/lib/__pycache__/metrics.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fbb8460fc066e4f58e29954619dd7f7d07a4f4b4 Binary files /dev/null and b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/lib/__pycache__/metrics.cpython-311.pyc differ diff --git a/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/lib/__pycache__/util.cpython-311.pyc b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/lib/__pycache__/util.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..119e2870726ef75764ee4e7870748bb355dc9a8c Binary files /dev/null and b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/lib/__pycache__/util.cpython-311.pyc differ diff --git a/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/lib/data.py b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/lib/data.py new file mode 100644 index 0000000000000000000000000000000000000000..de47f283d607c411a23df48a364f19f43d2727d1 --- /dev/null +++ b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/lib/data.py @@ -0,0 +1,719 @@ +import hashlib +from collections import Counter +from copy import deepcopy +from dataclasses import astuple, dataclass, replace +from importlib.resources import path +from pathlib import Path +from typing import Any, Literal, Optional, Union, cast, Tuple, Dict, List + +import numpy as np +import pandas as pd +from sklearn.model_selection import train_test_split +from sklearn.pipeline import make_pipeline +import sklearn.preprocessing +import torch +import os +from category_encoders import LeaveOneOutEncoder +from sklearn.impute import SimpleImputer +from sklearn.preprocessing import StandardScaler +from scipy.spatial.distance import cdist + +from . import env, util +from .metrics import calculate_metrics as calculate_metrics_ +from .util import TaskType, load_json + +ArrayDict = Dict[str, np.ndarray] +TensorDict = Dict[str, torch.Tensor] + + +CAT_MISSING_VALUE = '__nan__' +CAT_RARE_VALUE = '__rare__' +Normalization = Literal['standard', 'quantile', 'minmax'] +NumNanPolicy = Literal['drop-rows', 'mean'] +CatNanPolicy = Literal['most_frequent'] +CatEncoding = Literal['one-hot', 'counter'] +YPolicy = Literal['default'] + + +class StandardScaler1d(StandardScaler): + def partial_fit(self, X, *args, **kwargs): + assert X.ndim == 1 + return super().partial_fit(X[:, None], *args, **kwargs) + + def transform(self, X, *args, **kwargs): + assert X.ndim == 1 + return super().transform(X[:, None], *args, **kwargs).squeeze(1) + + def inverse_transform(self, X, *args, **kwargs): + assert X.ndim == 1 + return super().inverse_transform(X[:, None], *args, **kwargs).squeeze(1) + + +def get_category_sizes(X: Union[torch.Tensor, np.ndarray]) -> List[int]: + """Return K[i] s.t. F.one_hot(x[:,i], K[i]) is valid. Requires K[i] > max(x[:,i]).""" + XT = X.T.cpu().tolist() if isinstance(X, torch.Tensor) else X.T.tolist() + return [int(np.max(x)) + 1 if len(x) > 0 else 0 for x in XT] + + +@dataclass(frozen=False) +class Dataset: + X_num: Optional[ArrayDict] + X_cat: Optional[ArrayDict] + y: ArrayDict + y_info: Dict[str, Any] + task_type: TaskType + n_classes: Optional[int] + + @classmethod + def from_dir(cls, dir_: Union[Path, str]) -> 'Dataset': + dir_ = Path(dir_) + splits = [k for k in ['train', 'val', 'test'] if dir_.joinpath(f'y_{k}.npy').exists()] + + def load(item) -> ArrayDict: + return { + x: cast(np.ndarray, np.load(dir_ / f'{item}_{x}.npy', allow_pickle=True)) # type: ignore[code] + for x in splits + } + + if Path(dir_ / 'info.json').exists(): + info = util.load_json(dir_ / 'info.json') + else: + info = None + return Dataset( + load('X_num') if dir_.joinpath('X_num_train.npy').exists() else None, + load('X_cat') if dir_.joinpath('X_cat_train.npy').exists() else None, + load('y'), + {}, + TaskType(info['task_type']), + info.get('n_classes'), + ) + + @property + def is_binclass(self) -> bool: + return self.task_type == TaskType.BINCLASS + + @property + def is_multiclass(self) -> bool: + return self.task_type == TaskType.MULTICLASS + + @property + def is_regression(self) -> bool: + return self.task_type == TaskType.REGRESSION + + @property + def n_num_features(self) -> int: + return 0 if self.X_num is None else self.X_num['train'].shape[1] + + @property + def n_cat_features(self) -> int: + return 0 if self.X_cat is None else self.X_cat['train'].shape[1] + + @property + def n_features(self) -> int: + return self.n_num_features + self.n_cat_features + + def size(self, part: Optional[str]) -> int: + return sum(map(len, self.y.values())) if part is None else len(self.y[part]) + + @property + def nn_output_dim(self) -> int: + if self.is_multiclass: + assert self.n_classes is not None + return self.n_classes + else: + return 1 + + def get_category_sizes(self, part: str) -> List[int]: + return [] if self.X_cat is None else get_category_sizes(self.X_cat[part]) + + def calculate_metrics( + self, + predictions: Dict[str, np.ndarray], + prediction_type: Optional[str], + ) -> Dict[str, Any]: + metrics = { + x: calculate_metrics_( + self.y[x], predictions[x], self.task_type, prediction_type, self.y_info + ) + for x in predictions + } + if self.task_type == TaskType.REGRESSION: + score_key = 'rmse' + score_sign = -1 + else: + score_key = 'accuracy' + score_sign = 1 + for part_metrics in metrics.values(): + part_metrics['score'] = score_sign * part_metrics[score_key] + return metrics + +def change_val(dataset: Dataset, val_size: float = 0.2): + # should be done before transformations + + y = np.concatenate([dataset.y['train'], dataset.y['val']], axis=0) + + ixs = np.arange(y.shape[0]) + if dataset.is_regression: + train_ixs, val_ixs = train_test_split(ixs, test_size=val_size, random_state=777) + else: + train_ixs, val_ixs = train_test_split(ixs, test_size=val_size, random_state=777, stratify=y) + + dataset.y['train'] = y[train_ixs] + dataset.y['val'] = y[val_ixs] + + if dataset.X_num is not None: + X_num = np.concatenate([dataset.X_num['train'], dataset.X_num['val']], axis=0) + dataset.X_num['train'] = X_num[train_ixs] + dataset.X_num['val'] = X_num[val_ixs] + + if dataset.X_cat is not None: + X_cat = np.concatenate([dataset.X_cat['train'], dataset.X_cat['val']], axis=0) + dataset.X_cat['train'] = X_cat[train_ixs] + dataset.X_cat['val'] = X_cat[val_ixs] + + return dataset + +def num_process_nans(dataset: Dataset, policy: Optional[NumNanPolicy]) -> Dataset: + assert dataset.X_num is not None + nan_masks = {k: np.isnan(v) for k, v in dataset.X_num.items()} + if not any(x.any() for x in nan_masks.values()): # type: ignore[code] + assert policy is None + return dataset + + assert policy is not None + if policy == 'drop-rows': + valid_masks = {k: ~v.any(1) for k, v in nan_masks.items()} + assert valid_masks[ + 'test' + ].all(), 'Cannot drop test rows, since this will affect the final metrics.' + new_data = {} + for data_name in ['X_num', 'X_cat', 'y']: + data_dict = getattr(dataset, data_name) + if data_dict is not None: + new_data[data_name] = { + k: v[valid_masks[k]] for k, v in data_dict.items() + } + dataset = replace(dataset, **new_data) + elif policy == 'mean': + new_values = np.nanmean(dataset.X_num['train'], axis=0) + X_num = deepcopy(dataset.X_num) + for k, v in X_num.items(): + num_nan_indices = np.where(nan_masks[k]) + v[num_nan_indices] = np.take(new_values, num_nan_indices[1]) + dataset = replace(dataset, X_num=X_num) + else: + assert util.raise_unknown('policy', policy) + return dataset + + +# Inspired by: https://github.com/yandex-research/rtdl/blob/a4c93a32b334ef55d2a0559a4407c8306ffeeaee/lib/data.py#L20 +def normalize( + X: ArrayDict, normalization: Normalization, seed: Optional[int], return_normalizer : bool = False +) -> ArrayDict: + X_train = X['train'] + if normalization == 'standard': + normalizer = sklearn.preprocessing.StandardScaler() + elif normalization == 'minmax': + normalizer = sklearn.preprocessing.MinMaxScaler() + elif normalization == 'quantile': + normalizer = sklearn.preprocessing.QuantileTransformer( + output_distribution='normal', + n_quantiles=max(min(X['train'].shape[0] // 30, 1000), 10), + subsample=int(1e9), + random_state=seed, + ) + # noise = 1e-3 + # if noise > 0: + # assert seed is not None + # stds = np.std(X_train, axis=0, keepdims=True) + # noise_std = noise / np.maximum(stds, noise) # type: ignore[code] + # X_train = X_train + noise_std * np.random.default_rng(seed).standard_normal( + # X_train.shape + # ) + else: + util.raise_unknown('normalization', normalization) + normalizer.fit(X_train) + if return_normalizer: + return {k: normalizer.transform(v) for k, v in X.items()}, normalizer + return {k: normalizer.transform(v) for k, v in X.items()} + + +def cat_process_nans(X: ArrayDict, policy: Optional[CatNanPolicy]) -> ArrayDict: + assert X is not None + nan_masks = {k: np.asarray(v == CAT_MISSING_VALUE) for k, v in X.items()} + if any(np.asarray(x).any() for x in nan_masks.values()): # type: ignore[code] + if policy is None: + X_new = X + elif policy == 'most_frequent': + imputer = SimpleImputer(missing_values=CAT_MISSING_VALUE, strategy=policy) # type: ignore[code] + imputer.fit(X['train']) + X_new = {k: cast(np.ndarray, imputer.transform(v)) for k, v in X.items()} + else: + util.raise_unknown('categorical NaN policy', policy) + else: + assert policy is None + X_new = X + return X_new + + +def cat_drop_rare(X: ArrayDict, min_frequency: float) -> ArrayDict: + assert 0.0 < min_frequency < 1.0 + min_count = round(len(X['train']) * min_frequency) + X_new = {x: [] for x in X} + for column_idx in range(X['train'].shape[1]): + counter = Counter(X['train'][:, column_idx].tolist()) + popular_categories = {k for k, v in counter.items() if v >= min_count} + for part in X_new: + X_new[part].append( + [ + (x if x in popular_categories else CAT_RARE_VALUE) + for x in X[part][:, column_idx].tolist() + ] + ) + return {k: np.array(v).T for k, v in X_new.items()} + + +def cat_encode( + X: ArrayDict, + encoding: Optional[CatEncoding], + y_train: Optional[np.ndarray], + seed: Optional[int], + return_encoder : bool = False +) -> Tuple[ArrayDict, bool, Optional[Any]]: # (X, is_converted_to_numerical) + if encoding != 'counter': + y_train = None + + # Step 1. Map strings to 0-based ranges + + if encoding is None: + unknown_value = np.iinfo('int64').max - 3 + oe = sklearn.preprocessing.OrdinalEncoder( + handle_unknown='use_encoded_value', # type: ignore[code] + unknown_value=unknown_value, # type: ignore[code] + dtype='int64', # type: ignore[code] + ).fit(X['train']) + encoder = make_pipeline(oe) + encoder.fit(X['train']) + X = {k: encoder.transform(v) for k, v in X.items()} + max_values = X['train'].max(axis=0) + for part in X.keys(): + if part == 'train': continue + for column_idx in range(X[part].shape[1]): + X[part][X[part][:, column_idx] == unknown_value, column_idx] = ( + max_values[column_idx] + 1 + ) + if return_encoder: + return (X, False, encoder) + return (X, False) + + # Step 2. Encode. + + elif encoding == 'one-hot': + ohe = sklearn.preprocessing.OneHotEncoder( + handle_unknown='ignore', sparse=False, dtype=np.float32 # type: ignore[code] + ) + encoder = make_pipeline(ohe) + + # encoder.steps.append(('ohe', ohe)) + encoder.fit(X['train']) + X = {k: encoder.transform(v) for k, v in X.items()} + elif encoding == 'counter': + assert y_train is not None + assert seed is not None + loe = LeaveOneOutEncoder(sigma=0.1, random_state=seed, return_df=False) + encoder.steps.append(('loe', loe)) + encoder.fit(X['train'], y_train) + X = {k: encoder.transform(v).astype('float32') for k, v in X.items()} # type: ignore[code] + if not isinstance(X['train'], pd.DataFrame): + X = {k: v.values for k, v in X.items()} # type: ignore[code] + else: + util.raise_unknown('encoding', encoding) + + if return_encoder: + return X, True, encoder # type: ignore[code] + return (X, True) + + +def build_target( + y: ArrayDict, policy: Optional[YPolicy], task_type: TaskType +) -> Tuple[ArrayDict, Dict[str, Any]]: + info: Dict[str, Any] = {'policy': policy} + if policy is None: + pass + elif policy == 'default': + if task_type == TaskType.REGRESSION: + mean, std = float(y['train'].mean()), float(y['train'].std()) + y = {k: (v - mean) / std for k, v in y.items()} + info['mean'] = mean + info['std'] = std + else: + util.raise_unknown('policy', policy) + return y, info + + +@dataclass(frozen=True) +class Transformations: + seed: int = 0 + normalization: Optional[Normalization] = None + num_nan_policy: Optional[NumNanPolicy] = None + cat_nan_policy: Optional[CatNanPolicy] = None + cat_min_frequency: Optional[float] = None + cat_encoding: Optional[CatEncoding] = None + y_policy: Optional[YPolicy] = 'default' + + +def transform_dataset( + dataset: Dataset, + transformations: Transformations, + cache_dir: Optional[Path], + return_transforms: bool = False +) -> Dataset: + # WARNING: the order of transformations matters. Moreover, the current + # implementation is not ideal in that sense. + if cache_dir is not None: + transformations_md5 = hashlib.md5( + str(transformations).encode('utf-8') + ).hexdigest() + transformations_str = '__'.join(map(str, astuple(transformations))) + cache_path = ( + cache_dir / f'cache__{transformations_str}__{transformations_md5}.pickle' + ) + if cache_path.exists(): + cache_transformations, value = util.load_pickle(cache_path) + if transformations == cache_transformations: + print( + f"Using cached features: {cache_dir.name + '/' + cache_path.name}" + ) + return value + else: + raise RuntimeError(f'Hash collision for {cache_path}') + else: + cache_path = None + + if dataset.X_num is not None: + dataset = num_process_nans(dataset, transformations.num_nan_policy) + + num_transform = None + cat_transform = None + X_num = dataset.X_num + + if X_num is not None and transformations.normalization is not None: + X_num, num_transform = normalize( + X_num, + transformations.normalization, + transformations.seed, + return_normalizer=True + ) + num_transform = num_transform + + if dataset.X_cat is None: + assert transformations.cat_nan_policy is None + assert transformations.cat_min_frequency is None + # assert transformations.cat_encoding is None + X_cat = None + else: + X_cat = cat_process_nans(dataset.X_cat, transformations.cat_nan_policy) + if transformations.cat_min_frequency is not None: + X_cat = cat_drop_rare(X_cat, transformations.cat_min_frequency) + X_cat, is_num, cat_transform = cat_encode( + X_cat, + transformations.cat_encoding, + dataset.y['train'], + transformations.seed, + return_encoder=True + ) + if is_num: + X_num = ( + X_cat + if X_num is None + else {x: np.hstack([X_num[x], X_cat[x]]) for x in X_num} + ) + X_cat = None + + y, y_info = build_target(dataset.y, transformations.y_policy, dataset.task_type) + + dataset = replace(dataset, X_num=X_num, X_cat=X_cat, y=y, y_info=y_info) + dataset.num_transform = num_transform + dataset.cat_transform = cat_transform + + if cache_path is not None: + util.dump_pickle((transformations, dataset), cache_path) + # if return_transforms: + # return dataset, num_transform, cat_transform + return dataset + + +def build_dataset( + path: Union[str, Path], + transformations: Transformations, + cache: bool +) -> Dataset: + path = Path(path) + dataset = Dataset.from_dir(path) + return transform_dataset(dataset, transformations, path if cache else None) + + +def prepare_tensors( + dataset: Dataset, device: Union[str, torch.device] +) -> Tuple[Optional[TensorDict], Optional[TensorDict], TensorDict]: + X_num, X_cat, Y = ( + None if x is None else {k: torch.as_tensor(v) for k, v in x.items()} + for x in [dataset.X_num, dataset.X_cat, dataset.y] + ) + if device.type != 'cpu': + X_num, X_cat, Y = ( + None if x is None else {k: v.to(device) for k, v in x.items()} + for x in [X_num, X_cat, Y] + ) + assert X_num is not None + assert Y is not None + if not dataset.is_multiclass: + Y = {k: v.float() for k, v in Y.items()} + return X_num, X_cat, Y + +############### +## DataLoader## +############### + +class TabDataset(torch.utils.data.Dataset): + def __init__( + self, dataset : Dataset, split : Literal['train', 'val', 'test'] + ): + super().__init__() + + self.X_num = torch.from_numpy(dataset.X_num[split]) if dataset.X_num is not None else None + self.X_cat = torch.from_numpy(dataset.X_cat[split]) if dataset.X_cat is not None else None + self.y = torch.from_numpy(dataset.y[split]) + + assert self.y is not None + assert self.X_num is not None or self.X_cat is not None + + def __len__(self): + return len(self.y) + + def __getitem__(self, idx): + out_dict = { + 'y': self.y[idx].long() if self.y is not None else None, + } + + x = np.empty((0,)) + if self.X_num is not None: + x = self.X_num[idx] + if self.X_cat is not None: + x = torch.cat([x, self.X_cat[idx]], dim=0) + return x.float(), out_dict + +def prepare_dataloader( + dataset : Dataset, + split : str, + batch_size: int, +): + + torch_dataset = TabDataset(dataset, split) + loader = torch.utils.data.DataLoader( + torch_dataset, + batch_size=batch_size, + shuffle=(split == 'train'), + num_workers=1, + ) + while True: + yield from loader + +def prepare_torch_dataloader( + dataset : Dataset, + split : str, + shuffle : bool, + batch_size: int, +) -> torch.utils.data.DataLoader: + + torch_dataset = TabDataset(dataset, split) + loader = torch.utils.data.DataLoader(torch_dataset, batch_size=batch_size, shuffle=shuffle, num_workers=1) + + return loader + +def dataset_from_csv(paths : Dict[str, str], cat_features, target, T): + assert 'train' in paths + y = {} + X_num = {} + X_cat = {} if len(cat_features) else None + for split in paths.keys(): + df = pd.read_csv(paths[split]) + y[split] = df[target].to_numpy().astype(float) + if X_cat is not None: + X_cat[split] = df[cat_features].to_numpy().astype(str) + X_num[split] = df.drop(cat_features + [target], axis=1).to_numpy().astype(float) + + dataset = Dataset(X_num, X_cat, y, {}, None, len(np.unique(y['train']))) + return transform_dataset(dataset, T, None) + +class FastTensorDataLoader: + """ + A DataLoader-like object for a set of tensors that can be much faster than + TensorDataset + DataLoader because dataloader grabs individual indices of + the dataset and calls cat (slow). + Source: https://discuss.pytorch.org/t/dataloader-much-slower-than-manual-batching/27014/6 + """ + def __init__(self, *tensors, batch_size=32, shuffle=False): + """ + Initialize a FastTensorDataLoader. + :param *tensors: tensors to store. Must have the same length @ dim 0. + :param batch_size: batch size to load. + :param shuffle: if True, shuffle the data *in-place* whenever an + iterator is created out of this object. + :returns: A FastTensorDataLoader. + """ + assert all(t.shape[0] == tensors[0].shape[0] for t in tensors) + self.tensors = tensors + + self.dataset_len = self.tensors[0].shape[0] + self.batch_size = batch_size + self.shuffle = shuffle + + # Calculate # batches + n_batches, remainder = divmod(self.dataset_len, self.batch_size) + if remainder > 0: + n_batches += 1 + self.n_batches = n_batches + def __iter__(self): + if self.shuffle: + r = torch.randperm(self.dataset_len) + self.tensors = [t[r] for t in self.tensors] + self.i = 0 + return self + + def __next__(self): + if self.i >= self.dataset_len: + raise StopIteration + batch = tuple(t[self.i:self.i+self.batch_size] for t in self.tensors) + self.i += self.batch_size + return batch + + def __len__(self): + return self.n_batches + +def prepare_fast_dataloader( + D : Dataset, + split : str, + batch_size: int +): + if D.X_cat is not None: + if D.X_num is not None: + X = torch.from_numpy(np.concatenate([D.X_num[split], D.X_cat[split]], axis=1)).float() + else: + X = torch.from_numpy(D.X_cat[split]).float() + else: + X = torch.from_numpy(D.X_num[split]).float() + y = torch.from_numpy(D.y[split]) + dataloader = FastTensorDataLoader(X, y, batch_size=batch_size, shuffle=(split=='train')) + while True: + yield from dataloader + +def prepare_fast_torch_dataloader( + D : Dataset, + split : str, + batch_size: int +): + if D.X_cat is not None: + X = torch.from_numpy(np.concatenate([D.X_num[split], D.X_cat[split]], axis=1)).float() + else: + X = torch.from_numpy(D.X_num[split]).float() + y = torch.from_numpy(D.y[split]) + dataloader = FastTensorDataLoader(X, y, batch_size=batch_size, shuffle=(split=='train')) + return dataloader + +def round_columns(X_real, X_synth, columns): + for col in columns: + uniq = np.unique(X_real[:,col]) + dist = cdist(X_synth[:, col][:, np.newaxis].astype(float), uniq[:, np.newaxis].astype(float)) + X_synth[:, col] = uniq[dist.argmin(axis=1)] + return X_synth + +def concat_features(D : Dataset): + if D.X_num is None: + assert D.X_cat is not None + X = {k: pd.DataFrame(v, columns=range(D.n_features)) for k, v in D.X_cat.items()} + elif D.X_cat is None: + assert D.X_num is not None + X = {k: pd.DataFrame(v, columns=range(D.n_features)) for k, v in D.X_num.items()} + else: + X = { + part: pd.concat( + [ + pd.DataFrame(D.X_num[part], columns=range(D.n_num_features)), + pd.DataFrame( + D.X_cat[part], + columns=range(D.n_num_features, D.n_features), + ), + ], + axis=1, + ) + for part in D.y.keys() + } + + return X + +def concat_to_pd(X_num, X_cat, y): + if X_num is None: + return pd.concat([ + pd.DataFrame(X_cat, columns=list(range(X_cat.shape[1]))), + pd.DataFrame(y, columns=['y']) + ], axis=1) + if X_cat is not None: + return pd.concat([ + pd.DataFrame(X_num, columns=list(range(X_num.shape[1]))), + pd.DataFrame(X_cat, columns=list(range(X_num.shape[1], X_num.shape[1] + X_cat.shape[1]))), + pd.DataFrame(y, columns=['y']) + ], axis=1) + return pd.concat([ + pd.DataFrame(X_num, columns=list(range(X_num.shape[1]))), + pd.DataFrame(y, columns=['y']) + ], axis=1) + +def read_pure_data(path, split='train'): + y = np.load(os.path.join(path, f'y_{split}.npy'), allow_pickle=True) + X_num = None + X_cat = None + if os.path.exists(os.path.join(path, f'X_num_{split}.npy')): + X_num = np.load(os.path.join(path, f'X_num_{split}.npy'), allow_pickle=True) + if os.path.exists(os.path.join(path, f'X_cat_{split}.npy')): + X_cat = np.load(os.path.join(path, f'X_cat_{split}.npy'), allow_pickle=True) + + return X_num, X_cat, y + +def read_changed_val(path, val_size=0.2): + path = Path(path) + X_num_train, X_cat_train, y_train = read_pure_data(path, 'train') + X_num_val, X_cat_val, y_val = read_pure_data(path, 'val') + is_regression = load_json(path / 'info.json')['task_type'] == 'regression' + + y = np.concatenate([y_train, y_val], axis=0) + + ixs = np.arange(y.shape[0]) + if is_regression: + train_ixs, val_ixs = train_test_split(ixs, test_size=val_size, random_state=777) + else: + train_ixs, val_ixs = train_test_split(ixs, test_size=val_size, random_state=777, stratify=y) + y_train = y[train_ixs] + y_val = y[val_ixs] + + if X_num_train is not None: + X_num = np.concatenate([X_num_train, X_num_val], axis=0) + X_num_train = X_num[train_ixs] + X_num_val = X_num[val_ixs] + + if X_cat_train is not None: + X_cat = np.concatenate([X_cat_train, X_cat_val], axis=0) + X_cat_train = X_cat[train_ixs] + X_cat_val = X_cat[val_ixs] + + return X_num_train, X_cat_train, y_train, X_num_val, X_cat_val, y_val + +############# + +def load_dataset_info(dataset_dir_name: str) -> Dict[str, Any]: + path = Path("data/" + dataset_dir_name) + info = util.load_json(path / 'info.json') + info['size'] = info['train_size'] + info['val_size'] + info['test_size'] + info['n_features'] = info['n_num_features'] + info['n_cat_features'] + info['path'] = path + return info diff --git a/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/lib/deep.py b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/lib/deep.py new file mode 100644 index 0000000000000000000000000000000000000000..aeed3e2ada4f9d0ee1a6f86b7e5d1a35d486149f --- /dev/null +++ b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/lib/deep.py @@ -0,0 +1,168 @@ +import statistics +from dataclasses import dataclass +from typing import Any, Callable, Literal, cast + +import rtdl +import torch +import torch.nn as nn +import torch.nn.functional as F +import torch.optim as optim +import zero +from torch import Tensor + +from .util import TaskType + + +def cos_sin(x: Tensor) -> Tensor: + return torch.cat([torch.cos(x), torch.sin(x)], -1) + + +@dataclass +class PeriodicOptions: + n: int # the output size is 2 * n + sigma: float + trainable: bool + initialization: Literal['log-linear', 'normal'] + + +class Periodic(nn.Module): + def __init__(self, n_features: int, options: PeriodicOptions) -> None: + super().__init__() + if options.initialization == 'log-linear': + coefficients = options.sigma ** (torch.arange(options.n) / options.n) + coefficients = coefficients[None].repeat(n_features, 1) + else: + assert options.initialization == 'normal' + coefficients = torch.normal(0.0, options.sigma, (n_features, options.n)) + if options.trainable: + self.coefficients = nn.Parameter(coefficients) # type: ignore[code] + else: + self.register_buffer('coefficients', coefficients) + + def forward(self, x: Tensor) -> Tensor: + assert x.ndim == 2 + return cos_sin(2 * torch.pi * self.coefficients[None] * x[..., None]) + + +def get_n_parameters(m: nn.Module): + return sum(x.numel() for x in m.parameters() if x.requires_grad) + + +def get_loss_fn(task_type: TaskType) -> Callable[..., Tensor]: + return ( + F.binary_cross_entropy_with_logits + if task_type == TaskType.BINCLASS + else F.cross_entropy + if task_type == TaskType.MULTICLASS + else F.mse_loss + ) + + +def default_zero_weight_decay_condition(module_name, module, parameter_name, parameter): + del module_name, parameter + return parameter_name.endswith('bias') or isinstance( + module, + ( + nn.BatchNorm1d, + nn.LayerNorm, + nn.InstanceNorm1d, + rtdl.CLSToken, + rtdl.NumericalFeatureTokenizer, + rtdl.CategoricalFeatureTokenizer, + Periodic, + ), + ) + + +def split_parameters_by_weight_decay( + model: nn.Module, zero_weight_decay_condition=default_zero_weight_decay_condition +) -> list[dict[str, Any]]: + parameters_info = {} + for module_name, module in model.named_modules(): + for parameter_name, parameter in module.named_parameters(): + full_parameter_name = ( + f'{module_name}.{parameter_name}' if module_name else parameter_name + ) + parameters_info.setdefault(full_parameter_name, ([], parameter))[0].append( + zero_weight_decay_condition( + module_name, module, parameter_name, parameter + ) + ) + params_with_wd = {'params': []} + params_without_wd = {'params': [], 'weight_decay': 0.0} + for full_parameter_name, (results, parameter) in parameters_info.items(): + (params_without_wd if any(results) else params_with_wd)['params'].append( + parameter + ) + return [params_with_wd, params_without_wd] + + +def make_optimizer( + config: dict[str, Any], + parameter_groups, +) -> optim.Optimizer: + if config['optimizer'] == 'FT-Transformer-default': + return optim.AdamW(parameter_groups, lr=1e-4, weight_decay=1e-5) + return getattr(optim, config['optimizer'])( + parameter_groups, + **{x: config[x] for x in ['lr', 'weight_decay', 'momentum'] if x in config}, + ) + + +def get_lr(optimizer: optim.Optimizer) -> float: + return next(iter(optimizer.param_groups))['lr'] + + +def is_oom_exception(err: RuntimeError) -> bool: + return any( + x in str(err) + for x in [ + 'CUDA out of memory', + 'CUBLAS_STATUS_ALLOC_FAILED', + 'CUDA error: out of memory', + ] + ) + + +def train_with_auto_virtual_batch( + optimizer, + loss_fn, + step, + batch, + chunk_size: int, +) -> tuple[Tensor, int]: + batch_size = len(batch) + random_state = zero.random.get_state() + loss = None + while chunk_size != 0: + try: + zero.random.set_state(random_state) + optimizer.zero_grad() + if batch_size <= chunk_size: + loss = loss_fn(*step(batch)) + loss.backward() + else: + loss = None + for chunk in zero.iter_batches(batch, chunk_size): + chunk_loss = loss_fn(*step(chunk)) + chunk_loss = chunk_loss * (len(chunk) / batch_size) + chunk_loss.backward() + if loss is None: + loss = chunk_loss.detach() + else: + loss += chunk_loss.detach() + except RuntimeError as err: + if not is_oom_exception(err): + raise + chunk_size //= 2 + else: + break + if not chunk_size: + raise RuntimeError('Not enough memory even for batch_size=1') + optimizer.step() + return cast(Tensor, loss), chunk_size + + +def process_epoch_losses(losses: list[Tensor]) -> tuple[list[float], float]: + losses_ = torch.stack(losses).tolist() + return losses_, statistics.mean(losses_) diff --git a/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/lib/env.py b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/lib/env.py new file mode 100644 index 0000000000000000000000000000000000000000..64be89d7d72c70e2ed9c7e0ecbbe682c14da3517 --- /dev/null +++ b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/lib/env.py @@ -0,0 +1,39 @@ +""" +Have not used in TabDDPM project. +""" + +import datetime +import os +import shutil +import typing as ty +from pathlib import Path + +PROJ = Path('tab-ddpm/').absolute().resolve() +EXP = PROJ / 'exp' +DATA = PROJ / 'data' + + +def get_path(path: ty.Union[str, Path]) -> Path: + if isinstance(path, str): + path = Path(path) + if not path.is_absolute(): + path = PROJ / path + return path.resolve() + + +def get_relative_path(path: ty.Union[str, Path]) -> Path: + return get_path(path).relative_to(PROJ) + + +def duplicate_path( + src: ty.Union[str, Path], alternative_project_dir: ty.Union[str, Path] +) -> None: + src = get_path(src) + alternative_project_dir = get_path(alternative_project_dir) + dst = alternative_project_dir / src.relative_to(PROJ) + dst.parent.mkdir(parents=True, exist_ok=True) + if dst.exists(): + dst = dst.with_name( + dst.name + '_' + datetime.datetime.now().strftime('%Y%m%dT%H%M%S') + ) + (shutil.copytree if src.is_dir() else shutil.copyfile)(src, dst) diff --git a/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/lib/metrics.py b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/lib/metrics.py new file mode 100644 index 0000000000000000000000000000000000000000..bdcac8171208065da730e974024aae0dc32b4665 --- /dev/null +++ b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/lib/metrics.py @@ -0,0 +1,158 @@ +import enum +from typing import Any, Optional, Tuple, Dict, Union, cast +from functools import partial + +import numpy as np +import scipy.special +import sklearn.metrics as skm + +from . import util +from .util import TaskType + + +class PredictionType(enum.Enum): + LOGITS = 'logits' + PROBS = 'probs' + +class MetricsReport: + def __init__(self, report: dict, task_type: TaskType): + self._res = {k: {} for k in report.keys()} + if task_type in (TaskType.BINCLASS, TaskType.MULTICLASS): + self._metrics_names = ["acc", "f1"] + for k in report.keys(): + self._res[k]["acc"] = report[k]["accuracy"] + self._res[k]["f1"] = report[k]["macro avg"]["f1-score"] + if task_type == TaskType.BINCLASS: + self._res[k]["roc_auc"] = report[k]["roc_auc"] + self._metrics_names.append("roc_auc") + + elif task_type == TaskType.REGRESSION: + self._metrics_names = ["r2", "rmse"] + for k in report.keys(): + self._res[k]["r2"] = report[k]["r2"] + self._res[k]["rmse"] = report[k]["rmse"] + else: + raise "Unknown TaskType!" + + def get_splits_names(self) -> list[str]: + return self._res.keys() + + def get_metrics_names(self) -> list[str]: + return self._metrics_names + + def get_metric(self, split: str, metric: str) -> float: + return self._res[split][metric] + + def get_val_score(self) -> float: + return self._res["val"]["r2"] if "r2" in self._res["val"] else self._res["val"]["f1"] + + def get_test_score(self) -> float: + return self._res["test"]["r2"] if "r2" in self._res["test"] else self._res["test"]["f1"] + + def print_metrics(self) -> None: + res = { + "val": {k: np.around(self._res["val"][k], 4) for k in self._res["val"]}, + "test": {k: np.around(self._res["test"][k], 4) for k in self._res["test"]} + } + + print("*"*100) + print("[val]") + print(res["val"]) + print("[test]") + print(res["test"]) + + return res + +class SeedsMetricsReport: + def __init__(self): + self._reports = [] + + def add_report(self, report: MetricsReport) -> None: + self._reports.append(report) + + def get_mean_std(self) -> dict: + res = {k: {} for k in ["train", "val", "test"]} + for split in self._reports[0].get_splits_names(): + for metric in self._reports[0].get_metrics_names(): + res[split][metric] = [x.get_metric(split, metric) for x in self._reports] + + agg_res = {k: {} for k in ["train", "val", "test"]} + for split in self._reports[0].get_splits_names(): + for metric in self._reports[0].get_metrics_names(): + for k, f in [("count", len), ("mean", np.mean), ("std", np.std)]: + agg_res[split][f"{metric}-{k}"] = f(res[split][metric]) + self._res = res + self._agg_res = agg_res + + return agg_res + + def print_result(self) -> dict: + res = {split: {k: float(np.around(self._agg_res[split][k], 4)) for k in self._agg_res[split]} for split in ["val", "test"]} + print("="*100) + print("EVAL RESULTS:") + print("[val]") + print(res["val"]) + print("[test]") + print(res["test"]) + print("="*100) + return res + +def calculate_rmse( + y_true: np.ndarray, y_pred: np.ndarray, std: Optional[float] +) -> float: + rmse = skm.mean_squared_error(y_true, y_pred) ** 0.5 + if std is not None: + rmse *= std + return rmse + + +def _get_labels_and_probs( + y_pred: np.ndarray, task_type: TaskType, prediction_type: Optional[PredictionType] +) -> Tuple[np.ndarray, Optional[np.ndarray]]: + assert task_type in (TaskType.BINCLASS, TaskType.MULTICLASS) + + if prediction_type is None: + return y_pred, None + + if prediction_type == PredictionType.LOGITS: + probs = ( + scipy.special.expit(y_pred) + if task_type == TaskType.BINCLASS + else scipy.special.softmax(y_pred, axis=1) + ) + elif prediction_type == PredictionType.PROBS: + probs = y_pred + else: + util.raise_unknown('prediction_type', prediction_type) + + assert probs is not None + labels = np.round(probs) if task_type == TaskType.BINCLASS else probs.argmax(axis=1) + return labels.astype('int64'), probs + + +def calculate_metrics( + y_true: np.ndarray, + y_pred: np.ndarray, + task_type: Union[str, TaskType], + prediction_type: Optional[Union[str, PredictionType]], + y_info: Dict[str, Any], +) -> Dict[str, Any]: + # Example: calculate_metrics(y_true, y_pred, 'binclass', 'logits', {}) + task_type = TaskType(task_type) + if prediction_type is not None: + prediction_type = PredictionType(prediction_type) + + if task_type == TaskType.REGRESSION: + assert prediction_type is None + assert 'std' in y_info + rmse = calculate_rmse(y_true, y_pred, y_info['std']) + r2 = skm.r2_score(y_true, y_pred) + result = {'rmse': rmse, 'r2': r2} + else: + labels, probs = _get_labels_and_probs(y_pred, task_type, prediction_type) + result = cast( + Dict[str, Any], skm.classification_report(y_true, labels, output_dict=True) + ) + if task_type == TaskType.BINCLASS: + result['roc_auc'] = skm.roc_auc_score(y_true, probs) + return result diff --git a/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/lib/util.py b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/lib/util.py new file mode 100644 index 0000000000000000000000000000000000000000..75e05c9c9d1f0f9d6687f6d5fe1e91cad1b4ea20 --- /dev/null +++ b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/lib/util.py @@ -0,0 +1,433 @@ +import argparse +import atexit +import enum +import json +import os +import pickle +import shutil +import sys +import time +import uuid +from copy import deepcopy +from dataclasses import asdict, fields, is_dataclass +from pathlib import Path +from pprint import pprint +from typing import Any, Callable, List, Dict, Type, Optional, Tuple, TypeVar, Union, cast, get_args, get_origin + +import __main__ +import numpy as np +import tomli +import tomli_w +import torch +import zero + +from . import env + +RawConfig = Dict[str, Any] +Report = Dict[str, Any] +T = TypeVar('T') + + +class Part(enum.Enum): + TRAIN = 'train' + VAL = 'val' + TEST = 'test' + + def __str__(self) -> str: + return self.value + + +class TaskType(enum.Enum): + BINCLASS = 'binclass' + MULTICLASS = 'multiclass' + REGRESSION = 'regression' + + def __str__(self) -> str: + return self.value + + +class Timer(zero.Timer): + @classmethod + def launch(cls) -> 'Timer': + timer = cls() + timer.run() + return timer + + +def update_training_log(training_log, data, metrics): + def _update(log_part, data_part): + for k, v in data_part.items(): + if isinstance(v, dict): + _update(log_part.setdefault(k, {}), v) + elif isinstance(v, list): + log_part.setdefault(k, []).extend(v) + else: + log_part.setdefault(k, []).append(v) + + _update(training_log, data) + transposed_metrics = {} + for part, part_metrics in metrics.items(): + for metric_name, value in part_metrics.items(): + transposed_metrics.setdefault(metric_name, {})[part] = value + _update(training_log, transposed_metrics) + + +def raise_unknown(unknown_what: str, unknown_value: Any): + raise ValueError(f'Unknown {unknown_what}: {unknown_value}') + + +def _replace(data, condition, value): + def do(x): + if isinstance(x, dict): + return {k: do(v) for k, v in x.items()} + elif isinstance(x, list): + return [do(y) for y in x] + else: + return value if condition(x) else x + + return do(data) + + +_CONFIG_NONE = '__none__' + + +def unpack_config(config: RawConfig) -> RawConfig: + config = cast(RawConfig, _replace(config, lambda x: x == _CONFIG_NONE, None)) + return config + + +def pack_config(config: RawConfig) -> RawConfig: + config = cast(RawConfig, _replace(config, lambda x: x is None, _CONFIG_NONE)) + return config + + +def load_config(path: Union[Path, str]) -> Any: + with open(path, 'rb') as f: + return unpack_config(tomli.load(f)) + + +def dump_config(config: Any, path: Union[Path, str]) -> None: + with open(path, 'wb') as f: + tomli_w.dump(pack_config(config), f) + # check that there are no bugs in all these "pack/unpack" things + assert config == load_config(path) + + +def load_json(path: Union[Path, str], **kwargs) -> Any: + return json.loads(Path(path).read_text(), **kwargs) + + +def dump_json(x: Any, path: Union[Path, str], **kwargs) -> None: + kwargs.setdefault('indent', 4) + Path(path).write_text(json.dumps(x, **kwargs) + '\n') + + +def load_pickle(path: Union[Path, str], **kwargs) -> Any: + return pickle.loads(Path(path).read_bytes(), **kwargs) + + +def dump_pickle(x: Any, path: Union[Path, str], **kwargs) -> None: + Path(path).write_bytes(pickle.dumps(x, **kwargs)) + + +def load(path: Union[Path, str], **kwargs) -> Any: + return globals()[f'load_{Path(path).suffix[1:]}'](Path(path), **kwargs) + + +def dump(x: Any, path: Union[Path, str], **kwargs) -> Any: + return globals()[f'dump_{Path(path).suffix[1:]}'](x, Path(path), **kwargs) + + +def _get_output_item_path( + path: Union[str, Path], filename: str, must_exist: bool +) -> Path: + path = env.get_path(path) + if path.suffix == '.toml': + path = path.with_suffix('') + if path.is_dir(): + path = path / filename + else: + assert path.name == filename + assert path.parent.exists() + if must_exist: + assert path.exists() + return path + + +def load_report(path: Path) -> Report: + return load_json(_get_output_item_path(path, 'report.json', True)) + + +def dump_report(report: dict, path: Path) -> None: + dump_json(report, _get_output_item_path(path, 'report.json', False)) + + +def load_predictions(path: Path) -> Dict[str, np.ndarray]: + with np.load(_get_output_item_path(path, 'predictions.npz', True)) as predictions: + return {x: predictions[x] for x in predictions} + + +def dump_predictions(predictions: Dict[str, np.ndarray], path: Path) -> None: + np.savez(_get_output_item_path(path, 'predictions.npz', False), **predictions) + + +def dump_metrics(metrics: Dict[str, Any], path: Path) -> None: + dump_json(metrics, _get_output_item_path(path, 'metrics.json', False)) + + +def load_checkpoint(path: Path, *args, **kwargs) -> Dict[str, np.ndarray]: + return torch.load( + _get_output_item_path(path, 'checkpoint.pt', True), *args, **kwargs + ) + + +def get_device() -> torch.device: + if torch.cuda.is_available(): + assert os.environ.get('CUDA_VISIBLE_DEVICES') is not None + return torch.device('cuda:0') + else: + return torch.device('cpu') + + +def _print_sep(c, size=100): + print(c * size) + + +def start( + config_cls: Type[T] = RawConfig, + argv: Optional[List[str]] = None, + patch_raw_config: Optional[Callable[[RawConfig], None]] = None, +) -> Tuple[T, Path, Report]: # config # output dir # report + parser = argparse.ArgumentParser() + parser.add_argument('config', metavar='FILE') + parser.add_argument('--force', action='store_true') + parser.add_argument('--continue', action='store_true', dest='continue_') + if argv is None: + program = __main__.__file__ + args = parser.parse_args() + else: + program = argv[0] + try: + args = parser.parse_args(argv[1:]) + except Exception: + print( + 'Failed to parse `argv`.' + ' Remember that the first item of `argv` must be the path (relative to' + ' the project root) to the script/notebook.' + ) + raise + args = parser.parse_args(argv) + + snapshot_dir = os.environ.get('SNAPSHOT_PATH') + if snapshot_dir and Path(snapshot_dir).joinpath('CHECKPOINTS_RESTORED').exists(): + assert args.continue_ + + config_path = env.get_path(args.config) + output_dir = config_path.with_suffix('') + _print_sep('=') + print(f'[output] {output_dir}') + _print_sep('=') + + assert config_path.exists() + raw_config = load_config(config_path) + if patch_raw_config is not None: + patch_raw_config(raw_config) + if is_dataclass(config_cls): + config = from_dict(config_cls, raw_config) + full_raw_config = asdict(config) + else: + assert config_cls is dict + full_raw_config = config = raw_config + full_raw_config = asdict(config) + + if output_dir.exists(): + if args.force: + print('Removing the existing output and creating a new one...') + shutil.rmtree(output_dir) + output_dir.mkdir() + elif not args.continue_: + backup_output(output_dir) + print('The output directory already exists. Done!\n') + sys.exit() + elif output_dir.joinpath('DONE').exists(): + backup_output(output_dir) + print('The "DONE" file already exists. Done!') + sys.exit() + else: + print('Continuing with the existing output...') + else: + print('Creating the output...') + output_dir.mkdir() + + report = { + 'program': str(env.get_relative_path(program)), + 'environment': {}, + 'config': full_raw_config, + } + if torch.cuda.is_available(): # type: ignore[code] + report['environment'].update( + { + 'CUDA_VISIBLE_DEVICES': os.environ.get('CUDA_VISIBLE_DEVICES'), + 'gpus': zero.hardware.get_gpus_info(), + 'torch.version.cuda': torch.version.cuda, + 'torch.backends.cudnn.version()': torch.backends.cudnn.version(), # type: ignore[code] + 'torch.cuda.nccl.version()': torch.cuda.nccl.version(), # type: ignore[code] + } + ) + dump_report(report, output_dir) + dump_json(raw_config, output_dir / 'raw_config.json') + _print_sep('-') + pprint(full_raw_config, width=100) + _print_sep('-') + return cast(config_cls, config), output_dir, report + + +_LAST_SNAPSHOT_TIME = None + + +def backup_output(output_dir: Path) -> None: + backup_dir = os.environ.get('TMP_OUTPUT_PATH') + snapshot_dir = os.environ.get('SNAPSHOT_PATH') + if backup_dir is None: + assert snapshot_dir is None + return + assert snapshot_dir is not None + + try: + relative_output_dir = output_dir.relative_to(env.PROJ) + except ValueError: + return + + for dir_ in [backup_dir, snapshot_dir]: + new_output_dir = dir_ / relative_output_dir + prev_backup_output_dir = new_output_dir.with_name(new_output_dir.name + '_prev') + new_output_dir.parent.mkdir(exist_ok=True, parents=True) + if new_output_dir.exists(): + new_output_dir.rename(prev_backup_output_dir) + shutil.copytree(output_dir, new_output_dir) + # the case for evaluate.py which automatically creates configs + if output_dir.with_suffix('.toml').exists(): + shutil.copyfile( + output_dir.with_suffix('.toml'), new_output_dir.with_suffix('.toml') + ) + if prev_backup_output_dir.exists(): + shutil.rmtree(prev_backup_output_dir) + + global _LAST_SNAPSHOT_TIME + if _LAST_SNAPSHOT_TIME is None or time.time() - _LAST_SNAPSHOT_TIME > 10 * 60: + import nirvana_dl.snapshot # type: ignore[code] + + nirvana_dl.snapshot.dump_snapshot() + _LAST_SNAPSHOT_TIME = time.time() + print('The snapshot was saved!') + + +def _get_scores(metrics: Dict[str, Dict[str, Any]]) -> Optional[Dict[str, float]]: + return ( + {k: v['score'] for k, v in metrics.items()} + if 'score' in next(iter(metrics.values())) + else None + ) + + +def format_scores(metrics: Dict[str, Dict[str, Any]]) -> str: + return ' '.join( + f"[{x}] {metrics[x]['score']:.3f}" + for x in ['test', 'val', 'train'] + if x in metrics + ) + + +def finish(output_dir: Path, report: dict) -> None: + print() + _print_sep('=') + + metrics = report.get('metrics') + if metrics is not None: + scores = _get_scores(metrics) + if scores is not None: + dump_json(scores, output_dir / 'scores.json') + print(format_scores(metrics)) + _print_sep('-') + + dump_report(report, output_dir) + json_output_path = os.environ.get('JSON_OUTPUT_FILE') + if json_output_path: + try: + key = str(output_dir.relative_to(env.PROJ)) + except ValueError: + pass + else: + json_output_path = Path(json_output_path) + try: + json_data = json.loads(json_output_path.read_text()) + except (FileNotFoundError, json.decoder.JSONDecodeError): + json_data = {} + json_data[key] = load_json(output_dir / 'report.json') + json_output_path.write_text(json.dumps(json_data, indent=4)) + shutil.copyfile( + json_output_path, + os.path.join(os.environ['SNAPSHOT_PATH'], 'json_output.json'), + ) + + output_dir.joinpath('DONE').touch() + backup_output(output_dir) + print(f'Done! | {report.get("time")} | {output_dir}') + _print_sep('=') + print() + + +def from_dict(datacls: Type[T], data: dict) -> T: + assert is_dataclass(datacls) + data = deepcopy(data) + for field in fields(datacls): + if field.name not in data: + continue + if is_dataclass(field.type): + data[field.name] = from_dict(field.type, data[field.name]) + elif ( + get_origin(field.type) is Union + and len(get_args(field.type)) == 2 + and get_args(field.type)[1] is type(None) + and is_dataclass(get_args(field.type)[0]) + ): + if data[field.name] is not None: + data[field.name] = from_dict(get_args(field.type)[0], data[field.name]) + return datacls(**data) + + +def replace_factor_with_value( + config: RawConfig, + key: str, + reference_value: int, + bounds: Tuple[float, float], +) -> None: + factor_key = key + '_factor' + if factor_key not in config: + assert key in config + else: + assert key not in config + factor = config.pop(factor_key) + assert bounds[0] <= factor <= bounds[1] + config[key] = int(factor * reference_value) + + +def get_temporary_copy(path: Union[str, Path]) -> Path: + path = env.get_path(path) + assert not path.is_dir() and not path.is_symlink() + tmp_path = path.with_name( + path.stem + '___' + str(uuid.uuid4()).replace('-', '') + path.suffix + ) + shutil.copyfile(path, tmp_path) + atexit.register(lambda: tmp_path.unlink()) + return tmp_path + + +def get_python(): + python = Path('python3.9') + return str(python) if python.exists() else 'python' + +def get_catboost_config(real_data_path, is_cv=False): + ds_name = Path(real_data_path).name + C = load_json(f'tuned_models/catboost/{ds_name}_cv.json') + return C \ No newline at end of file diff --git a/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/requirements.txt b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..0ce34ec62c2c3c306ad6b26213187ebdaedf8c60 --- /dev/null +++ b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/requirements.txt @@ -0,0 +1,22 @@ +catboost==1.0.3 +category-encoders==2.3.0 +dython==0.5.1 +icecream==2.1.2 +libzero==0.0.8 +numpy==1.21.4 +optuna==2.10.1 +pandas==1.3.4 +pyarrow==6.0.0 +rtdl==0.0.9 +scikit-learn==1.0.2 +scipy==1.7.2 +skorch==0.11.0 +tomli-w==0.4.0 +tomli==1.2.2 +tqdm==4.62.3 + +# smote +imbalanced-learn==0.7.0 + +# tvae +rdt==0.6.4 \ No newline at end of file diff --git a/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/run_tabddpm.sh b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/run_tabddpm.sh new file mode 100644 index 0000000000000000000000000000000000000000..1f694f5d430cf6563edbc14aa2e9c1508a00431c --- /dev/null +++ b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/run_tabddpm.sh @@ -0,0 +1,5 @@ +#!/usr/bin/env bash +set -e +cd /data/jialinzhang/synthetic_benchmark/tabddpm/code +export PYTHONPATH="$PWD:$PYTHONPATH" +python -m scripts.pipeline "$@" diff --git a/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/run_tabddpm_docker.sh b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/run_tabddpm_docker.sh new file mode 100644 index 0000000000000000000000000000000000000000..5174f039fea0ca7bce25d4cef3559b197e577204 --- /dev/null +++ b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/run_tabddpm_docker.sh @@ -0,0 +1,5 @@ +#!/usr/bin/env bash +set -e +cd /workspace/tabddpm/code +export PYTHONPATH="$PWD:$PYTHONPATH" +python -m scripts.pipeline "$@" diff --git a/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/scripts/__init__.py b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/scripts/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/scripts/__pycache__/__init__.cpython-311.pyc b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/scripts/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..68e412505aea0ac3e796b9843b44c9978e3eb810 Binary files /dev/null and b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/scripts/__pycache__/__init__.cpython-311.pyc differ diff --git a/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/scripts/__pycache__/eval_catboost.cpython-311.pyc b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/scripts/__pycache__/eval_catboost.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6b0e0ddb193db798b618d28d36484ae333b340f9 Binary files /dev/null and b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/scripts/__pycache__/eval_catboost.cpython-311.pyc differ diff --git a/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/scripts/__pycache__/eval_mlp.cpython-311.pyc b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/scripts/__pycache__/eval_mlp.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9f17c4718c7cfcf336c28d9140a4d02ab9f5d801 Binary files /dev/null and b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/scripts/__pycache__/eval_mlp.cpython-311.pyc differ diff --git a/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/scripts/__pycache__/eval_simple.cpython-311.pyc b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/scripts/__pycache__/eval_simple.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5b0935069999ce3b339ae52360d57e2221bdc0cf Binary files /dev/null and b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/scripts/__pycache__/eval_simple.cpython-311.pyc differ diff --git a/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/scripts/__pycache__/sample.cpython-311.pyc b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/scripts/__pycache__/sample.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cb9b09cda4055bdf48ca285686440edd4c0e27a4 Binary files /dev/null and b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/scripts/__pycache__/sample.cpython-311.pyc differ diff --git a/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/scripts/__pycache__/train.cpython-311.pyc b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/scripts/__pycache__/train.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ff12312dde83023891f22198209508f1ecdcc1d4 Binary files /dev/null and b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/scripts/__pycache__/train.cpython-311.pyc differ diff --git a/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/scripts/__pycache__/utils_train.cpython-311.pyc b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/scripts/__pycache__/utils_train.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c833cc139d6f4a1dbe95531df933183a21bfebc4 Binary files /dev/null and b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/scripts/__pycache__/utils_train.cpython-311.pyc differ diff --git a/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/scripts/eval_catboost.py b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/scripts/eval_catboost.py new file mode 100644 index 0000000000000000000000000000000000000000..55066c2176c33c8fec14416d34736899e039a64f --- /dev/null +++ b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/scripts/eval_catboost.py @@ -0,0 +1,145 @@ +from catboost import CatBoostClassifier, CatBoostRegressor +from sklearn.metrics import classification_report, r2_score +import numpy as np +import os +from sklearn.utils import shuffle +import zero +from pathlib import Path +import lib +from pprint import pprint +from lib import concat_features, read_pure_data, get_catboost_config, read_changed_val + +def train_catboost( + parent_dir, + real_data_path, + eval_type, + T_dict, + seed = 0, + params = None, + change_val = True, + device = None # dummy +): + zero.improve_reproducibility(seed) + if eval_type != "real": + synthetic_data_path = os.path.join(parent_dir) + info = lib.load_json(os.path.join(real_data_path, 'info.json')) + T = lib.Transformations(**T_dict) + + if change_val: + X_num_real, X_cat_real, y_real, X_num_val, X_cat_val, y_val = read_changed_val(real_data_path, val_size=0.2) + + X = None + print('-'*100) + if eval_type == 'merged': + print('loading merged data...') + if not change_val: + X_num_real, X_cat_real, y_real = read_pure_data(real_data_path) + X_num_fake, X_cat_fake, y_fake = read_pure_data(synthetic_data_path) + + ### + # dists = privacy_metrics(real_data_path, synthetic_data_path) + # bad_fakes = dists.argsort()[:int(0.25 * len(y_fake))] + # X_num_fake = np.delete(X_num_fake, bad_fakes, axis=0) + # X_cat_fake = np.delete(X_cat_fake, bad_fakes, axis=0) if X_cat_fake is not None else None + # y_fake = np.delete(y_fake, bad_fakes, axis=0) + ### + + y = np.concatenate([y_real, y_fake], axis=0) + + X_num = None + if X_num_real is not None: + X_num = np.concatenate([X_num_real, X_num_fake], axis=0) + + X_cat = None + if X_cat_real is not None: + X_cat = np.concatenate([X_cat_real, X_cat_fake], axis=0) + + elif eval_type == 'synthetic': + print(f'loading synthetic data: {parent_dir}') + X_num, X_cat, y = read_pure_data(synthetic_data_path) + + elif eval_type == 'real': + print('loading real data...') + if not change_val: + X_num, X_cat, y = read_pure_data(real_data_path) + else: + raise "Choose eval method" + + if not change_val: + X_num_val, X_cat_val, y_val = read_pure_data(real_data_path, 'val') + X_num_test, X_cat_test, y_test = read_pure_data(real_data_path, 'test') + + D = lib.Dataset( + {'train': X_num, 'val': X_num_val, 'test': X_num_test} if X_num is not None else None, + {'train': X_cat, 'val': X_cat_val, 'test': X_cat_test} if X_cat is not None else None, + {'train': y, 'val': y_val, 'test': y_test}, + {}, + lib.TaskType(info['task_type']), + info.get('n_classes') + ) + + D = lib.transform_dataset(D, T, None) + X = concat_features(D) + print(f'Train size: {X["train"].shape}, Val size {X["val"].shape}') + + if params is None: + catboost_config = get_catboost_config(real_data_path, is_cv=True) + else: + catboost_config = params + + if 'cat_features' not in catboost_config: + catboost_config['cat_features'] = list(range(D.n_num_features, D.n_features)) + + for col in range(D.n_features): + for split in X.keys(): + if col in catboost_config['cat_features']: + X[split][col] = X[split][col].astype(str) + else: + X[split][col] = X[split][col].astype(float) + print(T_dict) + pprint(catboost_config, width=100) + print('-'*100) + + if D.is_regression: + model = CatBoostRegressor( + **catboost_config, + eval_metric='RMSE', + random_seed=seed + ) + predict = model.predict + else: + model = CatBoostClassifier( + loss_function="MultiClass" if D.is_multiclass else "Logloss", + **catboost_config, + eval_metric='TotalF1', + random_seed=seed, + class_names=[str(i) for i in range(D.n_classes)] if D.is_multiclass else ["0", "1"] + ) + predict = ( + model.predict_proba + if D.is_multiclass + else lambda x: model.predict_proba(x)[:, 1] + ) + + model.fit( + X['train'], D.y['train'], + eval_set=(X['val'], D.y['val']), + verbose=100 + ) + predictions = {k: predict(v) for k, v in X.items()} + print(predictions['train'].shape) + + report = {} + report['eval_type'] = eval_type + report['dataset'] = real_data_path + report['metrics'] = D.calculate_metrics(predictions, None if D.is_regression else 'probs') + + metrics_report = lib.MetricsReport(report['metrics'], D.task_type) + metrics_report.print_metrics() + + if parent_dir is not None: + lib.dump_json(report, os.path.join(parent_dir, "results_catboost.json")) + + return metrics_report + + \ No newline at end of file diff --git a/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/scripts/eval_mlp.py b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/scripts/eval_mlp.py new file mode 100644 index 0000000000000000000000000000000000000000..396de4ef30589ff3c115b3bff7daa0bddeb9a57b --- /dev/null +++ b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/scripts/eval_mlp.py @@ -0,0 +1,176 @@ +from sklearn.metrics import classification_report, r2_score, f1_score +import numpy as np +import os +from sklearn.utils import shuffle +import zero +from pathlib import Path +import lib +from tab_ddpm.modules import MLP +from skorch.regressor import NeuralNetRegressor +from skorch.classifier import NeuralNetClassifier +from skorch.dataset import Dataset as SkDataset +from skorch.callbacks import EarlyStopping, EpochScoring +from skorch.helper import predefined_split +from torch.optim import AdamW +from torch.nn import MSELoss, BCEWithLogitsLoss, CrossEntropyLoss + +def train_mlp( + parent_dir, + real_data_path, + eval_type, + T_dict, + params = None, + change_val = False, + seed = 0, + device = "cuda:0" +): + zero.improve_reproducibility(seed) + synthetic_data_path = os.path.join(parent_dir) if parent_dir is not None else None + info = lib.load_json(os.path.join(real_data_path, 'info.json')) + T = lib.Transformations(**T_dict) + + if change_val: + X_num_real, X_cat_real, y_real, X_num_val, X_cat_val, y_val = lib.read_changed_val(real_data_path, val_size=0.2) + + X = None + print('-'*100) + if eval_type == 'merged': + print('loading merged data...') + if not change_val: + X_num_real, X_cat_real, y_real = lib.read_pure_data(real_data_path) + X_num_fake, X_cat_fake, y_fake = lib.read_pure_data(synthetic_data_path) + y = np.concatenate([y_real, y_fake], axis=0) + + X_num = None + if X_num_real is not None: + X_num = np.concatenate([X_num_real, X_num_fake], axis=0) + + X_cat = None + if X_cat_real is not None: + X_cat = np.concatenate([X_cat_real, X_cat_fake], axis=0) + + elif eval_type == 'synthetic': + print('loading synthetic data...') + X_num, X_cat, y = lib.read_pure_data(synthetic_data_path) + + elif eval_type == 'real': + print('loading real data...') + if not change_val: + X_num, X_cat, y = lib.read_pure_data(real_data_path) + else: + raise "Choose eval method" + + if not change_val: + X_num_val, X_cat_val, y_val = lib.read_pure_data(real_data_path, 'val') + X_num_test, X_cat_test, y_test = lib.read_pure_data(real_data_path, 'test') + + D = lib.Dataset( + {'train': X_num, 'val': X_num_val, 'test': X_num_test} if X_num is not None else None, + {'train': X_cat, 'val': X_cat_val, 'test': X_cat_test} if X_cat is not None else None, + {'train': y, 'val': y_val, 'test': y_test}, + {}, + lib.TaskType(info['task_type']), + info.get('n_classes') + ) + + D = lib.transform_dataset(D, T, None) + X = lib.concat_features(D) + + X["train"], D.y["train"] = shuffle(X["train"], D.y["train"], random_state=seed) + print(f'Train size: {X["train"].shape}, Val size {X["val"].shape}') + + if params is None: + params = lib.load_json(f"tuned_models/mlp/{Path(real_data_path).name}_cv.json") + + mlp_params = {} + if params is not None: + mlp_params["d_layers"] = params["d_layers"] + mlp_params["dropout"] = params["dropout"] + # mlp_params["n_blocks"] = params["n_blocks"] + # mlp_params["d_main"] = params["d_main"] + # mlp_params["d_hidden"] = params["d_hidden"] + # mlp_params["dropout_first"] = params["dropout_first"] + # mlp_params["dropout_second"] = params["dropout_second"] + mlp_params["d_in"] = X["train"].shape[1] + mlp_params["d_out"] = D.nn_output_dim + + model = MLP.make_baseline(**mlp_params) + + if D.is_regression: + y = {k: D.y[k].reshape(-1, 1).astype(np.float32) for k in D.y} + elif D.is_binclass: + y = {k: D.y[k].reshape(-1, 1).astype(np.float32) for k in D.y} + else: + y = {k: D.y[k].astype(np.int64) for k in D.y} + + train_ds = SkDataset(X = X["train"].to_numpy(), y = y["train"]) + val_ds = SkDataset(X = X["val"].to_numpy(), y = y["val"]) + es = EarlyStopping(monitor="valid_loss", patience=16) + + print('-'*100) + + def f1(net, X, y): + y_pred = net.predict(X) + return f1_score(y, y_pred, average="macro") + + def r2(net, X, y): + y_pred = net.predict(X) + return r2_score(y, y_pred) + + if D.is_regression: + net = NeuralNetRegressor( + model, + criterion=MSELoss, + optimizer=AdamW, + lr=params["lr"], + optimizer__weight_decay=params["weight_decay"], + batch_size=128 if len(D.y["train"]) < 10_000 else 256, + max_epochs=1000, + train_split=predefined_split(val_ds), + iterator_train__shuffle=True, + device=device, + callbacks=[es, EpochScoring(r2, lower_is_better=False)], + ) + + else: + net = NeuralNetClassifier( + model, + criterion=BCEWithLogitsLoss if D.is_binclass else CrossEntropyLoss, + optimizer=AdamW, + lr=params["lr"], + optimizer__weight_decay=params["weight_decay"], + batch_size=128 if len(D.y["train"]) < 10_000 else 256, + max_epochs=1000, + train_split=predefined_split(val_ds), + iterator_train__shuffle=True, + device=device, + callbacks=[es, EpochScoring(f1, lower_is_better=False)], + ) + + net.fit( + X=train_ds.X, + y=train_ds.y + ) + + print("LAST:", len(net.history)) + + predictions = {k: net.predict_proba(v.to_numpy())[:, 1] if D.is_binclass else + net.predict_proba(v.to_numpy()) if D.is_multiclass else + net.predict(v.to_numpy()) + for k, v in X.items() + } + + report = {} + report['eval_type'] = eval_type + report['dataset'] = real_data_path + report['metrics'] = D.calculate_metrics(predictions, None if D.is_regression else 'probs') + + metrics_report = lib.MetricsReport(report['metrics'], D.task_type) + metrics_report.print_metrics() + + if parent_dir is not None: + lib.dump_json(report, os.path.join(parent_dir, "results_mlp.json")) + + return metrics_report + + \ No newline at end of file diff --git a/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/scripts/eval_seeds.py b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/scripts/eval_seeds.py new file mode 100644 index 0000000000000000000000000000000000000000..cc4970e2a7293234d9d08afba2798719499bfc75 --- /dev/null +++ b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/scripts/eval_seeds.py @@ -0,0 +1,121 @@ +import argparse +import subprocess +import tempfile +import lib +import os +import shutil +from pathlib import Path +from copy import deepcopy +from scripts.eval_catboost import train_catboost +from scripts.eval_mlp import train_mlp +from scripts.eval_simple import train_simple + +pipeline = { + 'ddpm': 'scripts/pipeline.py', + 'smote': 'smote/pipeline_smote.py', + 'ctabgan': 'CTAB-GAN/pipeline_ctabgan.py', + 'ctabgan-plus': 'CTAB-GAN-Plus/pipeline_ctabgan.py', + 'tvae': 'CTGAN/pipeline_tvae.py' +} + +def eval_seeds( + raw_config, + n_seeds, + eval_type, + sampling_method="ddpm", + model_type="catboost", + n_datasets=1, + dump=True, + change_val=False +): + + metrics_seeds_report = lib.SeedsMetricsReport() + parent_dir = Path(raw_config["parent_dir"]) + + if eval_type == 'real': + n_datasets = 1 + + temp_config = deepcopy(raw_config) + with tempfile.TemporaryDirectory() as dir_: + dir_ = Path(dir_) + temp_config["parent_dir"] = str(dir_) + if sampling_method == "ddpm": + shutil.copy2(parent_dir / "model.pt", temp_config["parent_dir"]) + elif sampling_method in ["ctabgan", "ctabgan-plus"]: + shutil.copy2(parent_dir / "ctabgan.obj", temp_config["parent_dir"]) + elif sampling_method == "tvae": + shutil.copy2(parent_dir / "tvae.obj", temp_config["parent_dir"]) + + for sample_seed in range(n_datasets): + temp_config['sample']['seed'] = sample_seed + lib.dump_config(temp_config, dir_ / "config.toml") + if eval_type != 'real' and n_datasets > 1: + subprocess.run(['python3.9', f'{pipeline[sampling_method]}', '--config', f'{str(dir_ / "config.toml")}', '--sample'], check=True) + + T_dict = deepcopy(raw_config['eval']['T']) + for seed in range(n_seeds): + print(f'**Eval Iter: {sample_seed*n_seeds + (seed + 1)}/{n_seeds * n_datasets}**') + if model_type == "catboost": + T_dict["normalization"] = None + T_dict["cat_encoding"] = None + metric_report = train_catboost( + parent_dir=temp_config['parent_dir'], + real_data_path=temp_config['real_data_path'], + eval_type=eval_type, + T_dict=T_dict, + seed=seed, + change_val=change_val + ) + elif model_type == "mlp": + T_dict["normalization"] = "quantile" + T_dict["cat_encoding"] = "one-hot" + metric_report = train_mlp( + parent_dir=temp_config['parent_dir'], + real_data_path=temp_config['real_data_path'], + eval_type=eval_type, + T_dict=T_dict, + seed=seed, + change_val=change_val + ) + + metrics_seeds_report.add_report(metric_report) + + metrics_seeds_report.get_mean_std() + res = metrics_seeds_report.print_result() + if os.path.exists(parent_dir/ f"eval_{model_type}.json"): + eval_dict = lib.load_json(parent_dir / f"eval_{model_type}.json") + eval_dict = eval_dict | {eval_type: res} + else: + eval_dict = {eval_type: res} + + if dump: + lib.dump_json(eval_dict, parent_dir / f"eval_{model_type}.json") + + raw_config['sample']['seed'] = 0 + lib.dump_config(raw_config, parent_dir / 'config.toml') + return res + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument('--config', metavar='FILE') + parser.add_argument('n_seeds', type=int, default=10) + parser.add_argument('sampling_method', type=str, default="ddpm") + parser.add_argument('eval_type', type=str, default='synthetic') + parser.add_argument('model_type', type=str, default='catboost') + parser.add_argument('n_datasets', type=int, default=1) + parser.add_argument('--no_dump', action='store_false', default=True) + + args = parser.parse_args() + raw_config = lib.load_config(args.config) + eval_seeds( + raw_config, + n_seeds=args.n_seeds, + sampling_method=args.sampling_method, + eval_type=args.eval_type, + model_type=args.model_type, + n_datasets=args.n_datasets, + dump=args.no_dump + ) + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/scripts/eval_seeds_simple.py b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/scripts/eval_seeds_simple.py new file mode 100644 index 0000000000000000000000000000000000000000..187c88d31abc73efd4744bc1aa37bcc21d8c117f --- /dev/null +++ b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/scripts/eval_seeds_simple.py @@ -0,0 +1,130 @@ +import argparse +import subprocess +import tempfile +import lib +import os +import pandas as pd +import numpy as np +from pathlib import Path +from eval_simple import train_simple +from copy import deepcopy +import shutil + +pipeline = { + 'ddpm': 'scripts/pipeline.py', + 'smote': 'smote/pipeline_smote.py', + 'ctabgan': 'CTAB-GAN/pipeline_ctabgan.py', + 'ctabgan-plus': 'CTAB-GAN-Plus/pipeline_ctabganp.py', + 'tvae': 'CTGAN/pipeline_tvae.py' +} + + +def eval_seeds( + raw_config, + n_seeds, + eval_type, + sampling_method="ddpm", + model_type="simple", + n_datasets=1, + dump=True, + change_val=False +): + parent_dir = Path(raw_config["parent_dir"]) + models = ["tree", "lr", "rf", "mlp"] + metrics_seeds_report = { + k: lib.SeedsMetricsReport() for k in models + } + + if eval_type == 'real': + n_datasets = 1 + + T_dict = deepcopy(raw_config['eval']['T']) + T_dict["normalization"] = "minmax" + T_dict["cat_encoding"] = None + + temp_config = deepcopy(raw_config) + with tempfile.TemporaryDirectory() as dir_: + dir_ = Path(dir_) + temp_config["parent_dir"] = str(dir_) + if sampling_method == "ddpm": + shutil.copy2(parent_dir / "model.pt", temp_config["parent_dir"]) + elif sampling_method in ["ctabgan", "ctabgan-plus"]: + shutil.copy2(parent_dir / "ctabgan.obj", temp_config["parent_dir"]) + elif sampling_method == "tvae": + shutil.copy2(parent_dir / "tvae.obj", temp_config["parent_dir"]) + + for sample_seed in range(n_datasets): + temp_config['sample']['seed'] = sample_seed + lib.dump_config(temp_config, dir_ / "config.toml") + if eval_type != 'real': + subprocess.run(['python3.9', f'{pipeline[sampling_method]}', '--config', f'{str(dir_ / "config.toml")}', '--sample'], check=True) + + for seed in range(n_seeds): + print(f'**Eval Iter: {sample_seed*n_seeds + (seed + 1)}/{n_seeds * n_datasets}**') + for model in models: + metric_report = train_simple( + parent_dir=temp_config['parent_dir'], + real_data_path=temp_config['real_data_path'], + model_name=model, + eval_type=eval_type, + T_dict=T_dict, + seed=seed, + change_val=change_val + ) + + metrics_seeds_report[model].add_report(metric_report) + for k in models: + metrics_seeds_report[k].get_mean_std() + res = { + k: metrics_seeds_report[k].print_result() for k in models + } + + m1, m2 = ("r2-mean", "rmse-mean") if "r2-mean" in res["tree"]["val"] else ("f1-mean", "acc-mean") + res["avg"] = { + "val": { + m1: np.around(np.mean([res[k]["val"][m1] for k in models]), 4), + m2: np.around(np.mean([res[k]["val"][m2] for k in models]), 4) + }, + "test": { + m1: np.around(np.mean([res[k]["test"][m1] for k in models]), 4), + m2: np.around(np.mean([res[k]["test"][m2] for k in models]), 4) + }, + } + + if os.path.exists(parent_dir / f"eval_{model_type}.json"): + eval_dict = lib.load_json(parent_dir / f"eval_{model_type}.json") + eval_dict = eval_dict | {eval_type: res} + else: + eval_dict = {eval_type: res} + + if dump: + lib.dump_json(eval_dict, parent_dir / f"eval_{model_type}.json") + + raw_config['sample']['seed'] = 0 + lib.dump_config(raw_config, parent_dir / 'config.toml') + return res + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument('--config', metavar='FILE') + parser.add_argument('n_seeds', type=int, default=10) + parser.add_argument('sampling_method', type=str, default="ddpm") + parser.add_argument('eval_type', type=str, default='synthetic') + parser.add_argument('model_type', type=str, default='catboost') + parser.add_argument('n_datasets', type=int, default=1) + parser.add_argument('--no_dump', action='store_false', default=True) + + args = parser.parse_args() + raw_config = lib.load_config(args.config) + eval_seeds( + raw_config, + n_seeds=args.n_seeds, + sampling_method=args.sampling_method, + eval_type=args.eval_type, + model_type=args.model_type, + n_datasets=args.n_datasets, + dump=args.no_dump + ) + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/scripts/eval_simple.py b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/scripts/eval_simple.py new file mode 100644 index 0000000000000000000000000000000000000000..5e58199394b29839052de5abde1194530150abf8 --- /dev/null +++ b/SynthData0523/main/c6/tabddpm/tabddpm-c6-20260510_222430/_tabddpm_runtime/scripts/eval_simple.py @@ -0,0 +1,141 @@ +import numpy as np +import os +from sklearn.utils import shuffle +import zero +from pathlib import Path +import lib +from lib import concat_features, read_pure_data, read_changed_val +from sklearn.utils import shuffle +import lib +from sklearn.tree import DecisionTreeClassifier, DecisionTreeRegressor +from sklearn.ensemble import RandomForestClassifier, RandomForestRegressor +from sklearn.linear_model import LogisticRegression, Ridge +from sklearn.neural_network import MLPClassifier, MLPRegressor + +def train_simple( + parent_dir, + real_data_path, + eval_type, + T_dict, + model_name = "tree", + seed = 0, + change_val = True, + params = None, # dummy + device = None # dummy +): + zero.improve_reproducibility(seed) + if eval_type != "real": + synthetic_data_path = os.path.join(parent_dir) + + T_dict["normalization"] = "minmax" + T_dict["cat_encoding"] = None + T = lib.Transformations(**T_dict) + info = lib.load_json(os.path.join(real_data_path, 'info.json')) + + if change_val: + X_num_real, X_cat_real, y_real, X_num_val, X_cat_val, y_val = read_changed_val(real_data_path, val_size=0.2) + + X = None + print('-'*100) + if eval_type == 'merged': + print('loading merged data...') + if not change_val: + X_num_real, X_cat_real, y_real = read_pure_data(real_data_path) + X_num_fake, X_cat_fake, y_fake = read_pure_data(synthetic_data_path) + + ### + # dists = privacy_metrics(real_data_path, synthetic_data_path) + # bad_fakes = dists.argsort()[:int(0.25 * len(y_fake))] + # X_num_fake = np.delete(X_num_fake, bad_fakes, axis=0) + # X_cat_fake = np.delete(X_cat_fake, bad_fakes, axis=0) if X_cat_fake is not None else None + # y_fake = np.delete(y_fake, bad_fakes, axis=0) + ### + + y = np.concatenate([y_real, y_fake], axis=0) + + X_num = None + if X_num_real is not None: + X_num = np.concatenate([X_num_real, X_num_fake], axis=0) + + X_cat = None + if X_cat_real is not None: + X_cat = np.concatenate([X_cat_real, X_cat_fake], axis=0) + + elif eval_type == 'synthetic': + print(f'loading synthetic data: {parent_dir}') + X_num, X_cat, y = read_pure_data(synthetic_data_path) + + elif eval_type == 'real': + print('loading real data...') + if not change_val: + X_num, X_cat, y = read_pure_data(real_data_path) + else: + raise "Choose eval method" + + if not change_val: + X_num_val, X_cat_val, y_val = read_pure_data(real_data_path, 'val') + X_num_test, X_cat_test, y_test = read_pure_data(real_data_path, 'test') + + D = lib.Dataset( + {'train': X_num, 'val': X_num_val, 'test': X_num_test} if X_num is not None else None, + {'train': X_cat, 'val': X_cat_val, 'test': X_cat_test} if X_cat is not None else None, + {'train': y, 'val': y_val, 'test': y_test}, + {}, + lib.TaskType(info['task_type']), + info.get('n_classes') + ) + + D = lib.transform_dataset(D, T, None) + X = concat_features(D) + # ixs = np.random.choice(len(D.y["train"]), min(info["train_size"], len(D.y["train"])), replace=False) + # X["train"] = X["train"].iloc[ixs] + # D.y["train"] = D.y["train"][ixs] + + print(f'Train size: {X["train"].shape}, Val size {X["val"].shape}') + print(T_dict) + print('-'*100) + + if D.is_regression: + models = { + "tree": DecisionTreeRegressor(max_depth=28, random_state=seed), + "rf": RandomForestRegressor(max_depth=28, random_state=seed), + "lr": Ridge(max_iter=500, random_state=seed), + "mlp": MLPRegressor(max_iter=100, random_state=seed) + } + else: + models = { + "tree": DecisionTreeClassifier(max_depth=28, random_state=seed), + "rf": RandomForestClassifier(max_depth=28, random_state=seed), + "lr": LogisticRegression(max_iter=500, n_jobs=2, random_state=seed), + "mlp": MLPClassifier(max_iter=100, random_state=seed) + } + + model = models[model_name] + + predict = ( + model.predict + if D.is_regression + else model.predict_proba + if D.is_multiclass + else lambda x: model.predict_proba(x)[:, 1] + ) + + model.fit(X['train'], D.y['train']) + + predictions = {k: predict(v) for k, v in X.items()} + + report = {} + report['eval_type'] = eval_type + report['dataset'] = real_data_path + report['metrics'] = D.calculate_metrics(predictions, None if D.is_regression else 'probs') + + metrics_report = lib.MetricsReport(report['metrics'], D.task_type) + print(model.__class__.__name__) + metrics_report.print_metrics() + + # if parent_dir is not None: + # lib.dump_json(report, os.path.join(parent_dir, "results_catboost.json")) + + return metrics_report + + \ No newline at end of file