Upload 33 files

.gitattributes

@@ -33,3 +33,23 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+models/for_GM/results_fold_0_var_1_bet_zscore_gm/figures/standard_binary/fold_0/epoch_001_1.png filter=lfs diff=lfs merge=lfs -text
+models/for_GM/results_fold_0_var_1_bet_zscore_gm/figures/standard_binary/fold_0/epoch_001_2.png filter=lfs diff=lfs merge=lfs -text
+models/for_GM/results_fold_0_var_1_bet_zscore_gm/figures/standard_binary/fold_0/epoch_002_1.png filter=lfs diff=lfs merge=lfs -text
+models/for_GM/results_fold_0_var_1_bet_zscore_gm/figures/standard_binary/fold_0/epoch_002_2.png filter=lfs diff=lfs merge=lfs -text
+models/for_GM/results_fold_0_var_1_bet_zscore_gm/figures/standard_binary/fold_0/epoch_003_1.png filter=lfs diff=lfs merge=lfs -text
+models/for_GM/results_fold_0_var_1_bet_zscore_gm/figures/standard_binary/fold_0/epoch_003_2.png filter=lfs diff=lfs merge=lfs -text
+models/for_GM/results_fold_0_var_1_bet_zscore_gm/figures/standard_binary/fold_0/epoch_004_1.png filter=lfs diff=lfs merge=lfs -text
+models/for_GM/results_fold_0_var_1_bet_zscore_gm/figures/standard_binary/fold_0/epoch_004_2.png filter=lfs diff=lfs merge=lfs -text
+models/for_GM/results_fold_0_var_1_bet_zscore_gm/figures/standard_binary/fold_0/epoch_005_1.png filter=lfs diff=lfs merge=lfs -text
+models/for_GM/results_fold_0_var_1_bet_zscore_gm/figures/standard_binary/fold_0/epoch_005_2.png filter=lfs diff=lfs merge=lfs -text
+models/for_GM/results_fold_0_var_1_bet_zscore_gm/figures/standard_binary/fold_0/epoch_006_1.png filter=lfs diff=lfs merge=lfs -text
+models/for_GM/results_fold_0_var_1_bet_zscore_gm/figures/standard_binary/fold_0/epoch_006_2.png filter=lfs diff=lfs merge=lfs -text
+models/for_GM/results_fold_0_var_1_bet_zscore_gm/figures/standard_binary/fold_0/epoch_007_1.png filter=lfs diff=lfs merge=lfs -text
+models/for_GM/results_fold_0_var_1_bet_zscore_gm/figures/standard_binary/fold_0/epoch_007_2.png filter=lfs diff=lfs merge=lfs -text
+models/for_GM/results_fold_0_var_1_bet_zscore_gm/figures/standard_binary/fold_0/epoch_008_1.png filter=lfs diff=lfs merge=lfs -text
+models/for_GM/results_fold_0_var_1_bet_zscore_gm/figures/standard_binary/fold_0/epoch_008_2.png filter=lfs diff=lfs merge=lfs -text
+models/for_GM/results_fold_0_var_1_bet_zscore_gm/figures/standard_binary/fold_0/epoch_009_1.png filter=lfs diff=lfs merge=lfs -text
+models/for_GM/results_fold_0_var_1_bet_zscore_gm/figures/standard_binary/fold_0/epoch_009_2.png filter=lfs diff=lfs merge=lfs -text
+models/for_GM/results_fold_0_var_1_bet_zscore_gm/figures/standard_binary/fold_0/epoch_010_1.png filter=lfs diff=lfs merge=lfs -text
+models/for_GM/results_fold_0_var_1_bet_zscore_gm/figures/standard_binary/fold_0/epoch_010_2.png filter=lfs diff=lfs merge=lfs -text

models/for_GM/class_weights_gm/class_weights_fold0_standard_binary.json

@@ -0,0 +1,23 @@
+{
+  "fold_id": 0,
+  "class_scenario": "binary",
+  "preprocessing": "standard",
+  "num_classes": 2,
+  "total_pixels": 88539136,
+  "class_pixel_counts": [
+    79575838,
+    8963298
+  ],
+  "class_frequencies": [
+    0.8987645644068629,
+    0.10123543559313702
+  ],
+  "class_weights": [
+    0.20247246624134155,
+    1.7975275337586585
+  ],
+  "class_names": [
+    "Background",
+    "Specialized GM"
+  ]
+}

models/for_GM/data_splits_sp_gm/SP_GM_fold_assignments.json

@@ -0,0 +1,1295 @@
+{
+  "metadata": {
+    "total_patients": 268,
+    "test_patients": 26,
+    "trainval_patients": 242,
+    "n_folds": 5,
+    "random_seed": 42,
+    "datasets": [
+      "Local_SAI_GM_sp"
+    ]
+  },
+  "test_set": {
+    "patients": [
+      "117524",
+      "132287",
+      "105597",
+      "120429",
+      "117949",
+      "126395",
+      "134240",
+      "120907",
+      "106506",
+      "110784",
+      "118754",
+      "112997",
+      "112730",
+      "129466",
+      "105911",
+      "111008",
+      "129008",
+      "129044",
+      "110543",
+      "117276",
+      "114454",
+      "104474",
+      "114770",
+      "130578",
+      "116740",
+      "107680"
+    ],
+    "n_patients": 26
+  },
+  "folds": {
+    "fold_0": {
+      "train_patients": [
+        "101228",
+        "101627",
+        "102035",
+        "102313",
+        "104252",
+        "104280",
+        "104447",
+        "104453",
+        "104670",
+        "104797",
+        "104810",
+        "104871",
+        "105074",
+        "105549",
+        "105755",
+        "105917",
+        "105978",
+        "106270",
+        "106536",
+        "106639",
+        "106780",
+        "106976",
+        "107130",
+        "107455",
+        "107508",
+        "107539",
+        "107630",
+        "107966",
+        "107997",
+        "108295",
+        "108344",
+        "108444",
+        "108726",
+        "108975",
+        "109141",
+        "109267",
+        "109395",
+        "109654",
+        "109816",
+        "109923",
+        "109944",
+        "110012",
+        "110157",
+        "110218",
+        "110280",
+        "110327",
+        "110497",
+        "111140",
+        "111189",
+        "111489",
+        "111691",
+        "111852",
+        "112414",
+        "112657",
+        "112659",
+        "112765",
+        "112776",
+        "113394",
+        "114058",
+        "114128",
+        "114266",
+        "114304",
+        "114525",
+        "114585",
+        "114903",
+        "114990",
+        "115588",
+        "115628",
+        "115788",
+        "115799",
+        "115841",
+        "115991",
+        "116236",
+        "116246",
+        "116577",
+        "116700",
+        "116914",
+        "116937",
+        "117314",
+        "117385",
+        "117814",
+        "118018",
+        "118078",
+        "118409",
+        "118450",
+        "118481",
+        "118605",
+        "118719",
+        "118755",
+        "119730",
+        "120638",
+        "120749",
+        "120857",
+        "121140",
+        "121404",
+        "121499",
+        "121620",
+        "121804",
+        "121921",
+        "122000",
+        "122316",
+        "122762",
+        "122884",
+        "123575",
+        "124187",
+        "124899",
+        "125198",
+        "125465",
+        "125567",
+        "125798",
+        "126228",
+        "126396",
+        "126445",
+        "126465",
+        "126494",
+        "126523",
+        "126542",
+        "126704",
+        "126768",
+        "126779",
+        "127096",
+        "127513",
+        "127758",
+        "127816",
+        "127897",
+        "128785",
+        "128901",
+        "129055",
+        "129100",
+        "129637",
+        "129739",
+        "130214",
+        "130282",
+        "130366",
+        "130371",
+        "130402",
+        "130556",
+        "130662",
+        "130801",
+        "131040",
+        "131231",
+        "131235",
+        "131364",
+        "131444",
+        "131494",
+        "131606",
+        "131636",
+        "131792",
+        "131924",
+        "132155",
+        "132207",
+        "132282",
+        "132296",
+        "132589",
+        "132597",
+        "132605",
+        "132920",
+        "133196",
+        "133338",
+        "133562",
+        "133710",
+        "133814",
+        "133850",
+        "133886",
+        "133934",
+        "133946",
+        "134032",
+        "134654",
+        "134728",
+        "134919",
+        "134955",
+        "135467",
+        "135503",
+        "135687",
+        "135695",
+        "135697",
+        "135725",
+        "135733",
+        "135830",
+        "135855",
+        "136104",
+        "136105",
+        "136175",
+        "136220",
+        "136310",
+        "136382",
+        "136793",
+        "136817",
+        "136966",
+        "136996",
+        "137104",
+        "137508",
+        "137675"
+      ],
+      "val_patients": [
+        "104420",
+        "104518",
+        "104520",
+        "104899",
+        "104937",
+        "105302",
+        "105465",
+        "106063",
+        "106200",
+        "106905",
+        "107233",
+        "107739",
+        "108807",
+        "110540",
+        "112055",
+        "112378",
+        "113046",
+        "113845",
+        "114836",
+        "116268",
+        "116768",
+        "118660",
+        "118807",
+        "119095",
+        "119224",
+        "120781",
+        "122020",
+        "122288",
+        "125626",
+        "127511",
+        "127545",
+        "127870",
+        "129164",
+        "129916",
+        "130308",
+        "130373",
+        "131919",
+        "132371",
+        "132812",
+        "132896",
+        "133340",
+        "134197",
+        "134555",
+        "135628",
+        "136144",
+        "136589",
+        "137168",
+        "137617",
+        "137624"
+      ],
+      "n_train": 193,
+      "n_val": 49
+    },
+    "fold_1": {
+      "train_patients": [
+        "101228",
+        "101627",
+        "102035",
+        "102313",
+        "104252",
+        "104420",
+        "104447",
+        "104453",
+        "104518",
+        "104520",
+        "104670",
+        "104810",
+        "104871",
+        "104899",
+        "104937",
+        "105074",
+        "105302",
+        "105465",
+        "105549",
+        "105755",
+        "105917",
+        "105978",
+        "106063",
+        "106200",
+        "106270",
+        "106536",
+        "106905",
+        "107130",
+        "107233",
+        "107455",
+        "107539",
+        "107630",
+        "107739",
+        "107966",
+        "107997",
+        "108295",
+        "108444",
+        "108726",
+        "108807",
+        "108975",
+        "109141",
+        "109267",
+        "109395",
+        "109654",
+        "109923",
+        "109944",
+        "110012",
+        "110280",
+        "110327",
+        "110497",
+        "110540",
+        "111140",
+        "111189",
+        "111489",
+        "111691",
+        "112055",
+        "112378",
+        "112659",
+        "112765",
+        "112776",
+        "113046",
+        "113394",
+        "113845",
+        "114058",
+        "114128",
+        "114266",
+        "114525",
+        "114585",
+        "114836",
+        "114903",
+        "115588",
+        "115788",
+        "115799",
+        "115841",
+        "115991",
+        "116236",
+        "116246",
+        "116268",
+        "116577",
+        "116768",
+        "116937",
+        "117314",
+        "117385",
+        "118018",
+        "118078",
+        "118450",
+        "118481",
+        "118605",
+        "118660",
+        "118755",
+        "118807",
+        "119095",
+        "119224",
+        "120749",
+        "120781",
+        "120857",
+        "121499",
+        "121620",
+        "121804",
+        "122020",
+        "122288",
+        "122316",
+        "122762",
+        "122884",
+        "123575",
+        "124899",
+        "125198",
+        "125465",
+        "125567",
+        "125626",
+        "125798",
+        "126396",
+        "126465",
+        "126494",
+        "126542",
+        "126704",
+        "126779",
+        "127096",
+        "127511",
+        "127513",
+        "127545",
+        "127870",
+        "127897",
+        "128785",
+        "129055",
+        "129100",
+        "129164",
+        "129739",
+        "129916",
+        "130214",
+        "130282",
+        "130308",
+        "130371",
+        "130373",
+        "130402",
+        "130556",
+        "130662",
+        "130801",
+        "131231",
+        "131444",
+        "131494",
+        "131606",
+        "131636",
+        "131792",
+        "131919",
+        "131924",
+        "132155",
+        "132207",
+        "132282",
+        "132296",
+        "132371",
+        "132589",
+        "132812",
+        "132896",
+        "132920",
+        "133196",
+        "133340",
+        "133562",
+        "133710",
+        "133814",
+        "133850",
+        "133886",
+        "134032",
+        "134197",
+        "134555",
+        "134654",
+        "134728",
+        "134919",
+        "134955",
+        "135467",
+        "135503",
+        "135628",
+        "135687",
+        "135695",
+        "135697",
+        "135725",
+        "135733",
+        "135830",
+        "136104",
+        "136144",
+        "136175",
+        "136220",
+        "136589",
+        "136793",
+        "136817",
+        "136966",
+        "136996",
+        "137104",
+        "137168",
+        "137508",
+        "137617",
+        "137624",
+        "137675"
+      ],
+      "val_patients": [
+        "104280",
+        "104797",
+        "106639",
+        "106780",
+        "106976",
+        "107508",
+        "108344",
+        "109816",
+        "110157",
+        "110218",
+        "111852",
+        "112414",
+        "112657",
+        "114304",
+        "114990",
+        "115628",
+        "116700",
+        "116914",
+        "117814",
+        "118409",
+        "118719",
+        "119730",
+        "120638",
+        "121140",
+        "121404",
+        "121921",
+        "122000",
+        "124187",
+        "126228",
+        "126445",
+        "126523",
+        "126768",
+        "127758",
+        "127816",
+        "128901",
+        "129637",
+        "130366",
+        "131040",
+        "131235",
+        "131364",
+        "132597",
+        "132605",
+        "133338",
+        "133934",
+        "133946",
+        "135855",
+        "136105",
+        "136310",
+        "136382"
+      ],
+      "n_train": 193,
+      "n_val": 49
+    },
+    "fold_2": {
+      "train_patients": [
+        "101627",
+        "102313",
+        "104280",
+        "104420",
+        "104447",
+        "104453",
+        "104518",
+        "104520",
+        "104797",
+        "104810",
+        "104871",
+        "104899",
+        "104937",
+        "105074",
+        "105302",
+        "105465",
+        "105549",
+        "105755",
+        "105978",
+        "106063",
+        "106200",
+        "106639",
+        "106780",
+        "106905",
+        "106976",
+        "107233",
+        "107455",
+        "107508",
+        "107630",
+        "107739",
+        "107966",
+        "107997",
+        "108344",
+        "108444",
+        "108726",
+        "108807",
+        "109141",
+        "109267",
+        "109395",
+        "109654",
+        "109816",
+        "109923",
+        "109944",
+        "110012",
+        "110157",
+        "110218",
+        "110280",
+        "110327",
+        "110497",
+        "110540",
+        "111489",
+        "111691",
+        "111852",
+        "112055",
+        "112378",
+        "112414",
+        "112657",
+        "112765",
+        "112776",
+        "113046",
+        "113394",
+        "113845",
+        "114304",
+        "114525",
+        "114585",
+        "114836",
+        "114903",
+        "114990",
+        "115628",
+        "115788",
+        "115799",
+        "115841",
+        "116236",
+        "116246",
+        "116268",
+        "116577",
+        "116700",
+        "116768",
+        "116914",
+        "117314",
+        "117814",
+        "118018",
+        "118078",
+        "118409",
+        "118450",
+        "118481",
+        "118605",
+        "118660",
+        "118719",
+        "118755",
+        "118807",
+        "119095",
+        "119224",
+        "119730",
+        "120638",
+        "120749",
+        "120781",
+        "121140",
+        "121404",
+        "121499",
+        "121804",
+        "121921",
+        "122000",
+        "122020",
+        "122288",
+        "122762",
+        "122884",
+        "123575",
+        "124187",
+        "124899",
+        "125198",
+        "125626",
+        "126228",
+        "126445",
+        "126523",
+        "126542",
+        "126768",
+        "127096",
+        "127511",
+        "127513",
+        "127545",
+        "127758",
+        "127816",
+        "127870",
+        "127897",
+        "128785",
+        "128901",
+        "129100",
+        "129164",
+        "129637",
+        "129739",
+        "129916",
+        "130214",
+        "130282",
+        "130308",
+        "130366",
+        "130371",
+        "130373",
+        "130402",
+        "130801",
+        "131040",
+        "131231",
+        "131235",
+        "131364",
+        "131444",
+        "131494",
+        "131792",
+        "131919",
+        "132155",
+        "132207",
+        "132282",
+        "132296",
+        "132371",
+        "132589",
+        "132597",
+        "132605",
+        "132812",
+        "132896",
+        "133196",
+        "133338",
+        "133340",
+        "133562",
+        "133710",
+        "133814",
+        "133850",
+        "133934",
+        "133946",
+        "134032",
+        "134197",
+        "134555",
+        "134654",
+        "134919",
+        "134955",
+        "135467",
+        "135503",
+        "135628",
+        "135697",
+        "135725",
+        "135830",
+        "135855",
+        "136104",
+        "136105",
+        "136144",
+        "136175",
+        "136220",
+        "136310",
+        "136382",
+        "136589",
+        "136966",
+        "137168",
+        "137508",
+        "137617",
+        "137624",
+        "137675"
+      ],
+      "val_patients": [
+        "101228",
+        "102035",
+        "104252",
+        "104670",
+        "105917",
+        "106270",
+        "106536",
+        "107130",
+        "107539",
+        "108295",
+        "108975",
+        "111140",
+        "111189",
+        "112659",
+        "114058",
+        "114128",
+        "114266",
+        "115588",
+        "115991",
+        "116937",
+        "117385",
+        "120857",
+        "121620",
+        "122316",
+        "125465",
+        "125567",
+        "125798",
+        "126396",
+        "126465",
+        "126494",
+        "126704",
+        "126779",
+        "129055",
+        "130556",
+        "130662",
+        "131606",
+        "131636",
+        "131924",
+        "132920",
+        "133886",
+        "134728",
+        "135687",
+        "135695",
+        "135733",
+        "136793",
+        "136817",
+        "136996",
+        "137104"
+      ],
+      "n_train": 194,
+      "n_val": 48
+    },
+    "fold_3": {
+      "train_patients": [
+        "101228",
+        "101627",
+        "102035",
+        "104252",
+        "104280",
+        "104420",
+        "104518",
+        "104520",
+        "104670",
+        "104797",
+        "104871",
+        "104899",
+        "104937",
+        "105302",
+        "105465",
+        "105549",
+        "105755",
+        "105917",
+        "106063",
+        "106200",
+        "106270",
+        "106536",
+        "106639",
+        "106780",
+        "106905",
+        "106976",
+        "107130",
+        "107233",
+        "107508",
+        "107539",
+        "107630",
+        "107739",
+        "108295",
+        "108344",
+        "108807",
+        "108975",
+        "109267",
+        "109654",
+        "109816",
+        "109923",
+        "110012",
+        "110157",
+        "110218",
+        "110280",
+        "110327",
+        "110540",
+        "111140",
+        "111189",
+        "111489",
+        "111852",
+        "112055",
+        "112378",
+        "112414",
+        "112657",
+        "112659",
+        "112765",
+        "113046",
+        "113394",
+        "113845",
+        "114058",
+        "114128",
+        "114266",
+        "114304",
+        "114836",
+        "114990",
+        "115588",
+        "115628",
+        "115788",
+        "115799",
+        "115991",
+        "116246",
+        "116268",
+        "116700",
+        "116768",
+        "116914",
+        "116937",
+        "117314",
+        "117385",
+        "117814",
+        "118018",
+        "118078",
+        "118409",
+        "118481",
+        "118605",
+        "118660",
+        "118719",
+        "118807",
+        "119095",
+        "119224",
+        "119730",
+        "120638",
+        "120749",
+        "120781",
+        "120857",
+        "121140",
+        "121404",
+        "121499",
+        "121620",
+        "121921",
+        "122000",
+        "122020",
+        "122288",
+        "122316",
+        "122762",
+        "122884",
+        "124187",
+        "125465",
+        "125567",
+        "125626",
+        "125798",
+        "126228",
+        "126396",
+        "126445",
+        "126465",
+        "126494",
+        "126523",
+        "126704",
+        "126768",
+        "126779",
+        "127096",
+        "127511",
+        "127513",
+        "127545",
+        "127758",
+        "127816",
+        "127870",
+        "128785",
+        "128901",
+        "129055",
+        "129100",
+        "129164",
+        "129637",
+        "129916",
+        "130308",
+        "130366",
+        "130371",
+        "130373",
+        "130556",
+        "130662",
+        "130801",
+        "131040",
+        "131235",
+        "131364",
+        "131444",
+        "131606",
+        "131636",
+        "131919",
+        "131924",
+        "132207",
+        "132282",
+        "132296",
+        "132371",
+        "132589",
+        "132597",
+        "132605",
+        "132812",
+        "132896",
+        "132920",
+        "133338",
+        "133340",
+        "133562",
+        "133710",
+        "133814",
+        "133850",
+        "133886",
+        "133934",
+        "133946",
+        "134197",
+        "134555",
+        "134654",
+        "134728",
+        "134955",
+        "135467",
+        "135628",
+        "135687",
+        "135695",
+        "135733",
+        "135855",
+        "136105",
+        "136144",
+        "136175",
+        "136310",
+        "136382",
+        "136589",
+        "136793",
+        "136817",
+        "136966",
+        "136996",
+        "137104",
+        "137168",
+        "137508",
+        "137617",
+        "137624",
+        "137675"
+      ],
+      "val_patients": [
+        "102313",
+        "104447",
+        "104453",
+        "104810",
+        "105074",
+        "105978",
+        "107455",
+        "107966",
+        "107997",
+        "108444",
+        "108726",
+        "109141",
+        "109395",
+        "109944",
+        "110497",
+        "111691",
+        "112776",
+        "114525",
+        "114585",
+        "114903",
+        "115841",
+        "116236",
+        "116577",
+        "118450",
+        "118755",
+        "121804",
+        "123575",
+        "124899",
+        "125198",
+        "126542",
+        "127897",
+        "129739",
+        "130214",
+        "130282",
+        "130402",
+        "131231",
+        "131494",
+        "131792",
+        "132155",
+        "133196",
+        "134032",
+        "134919",
+        "135503",
+        "135697",
+        "135725",
+        "135830",
+        "136104",
+        "136220"
+      ],
+      "n_train": 194,
+      "n_val": 48
+    },
+    "fold_4": {
+      "train_patients": [
+        "101228",
+        "102035",
+        "102313",
+        "104252",
+        "104280",
+        "104420",
+        "104447",
+        "104453",
+        "104518",
+        "104520",
+        "104670",
+        "104797",
+        "104810",
+        "104899",
+        "104937",
+        "105074",
+        "105302",
+        "105465",
+        "105917",
+        "105978",
+        "106063",
+        "106200",
+        "106270",
+        "106536",
+        "106639",
+        "106780",
+        "106905",
+        "106976",
+        "107130",
+        "107233",
+        "107455",
+        "107508",
+        "107539",
+        "107739",
+        "107966",
+        "107997",
+        "108295",
+        "108344",
+        "108444",
+        "108726",
+        "108807",
+        "108975",
+        "109141",
+        "109395",
+        "109816",
+        "109944",
+        "110157",
+        "110218",
+        "110497",
+        "110540",
+        "111140",
+        "111189",
+        "111691",
+        "111852",
+        "112055",
+        "112378",
+        "112414",
+        "112657",
+        "112659",
+        "112776",
+        "113046",
+        "113845",
+        "114058",
+        "114128",
+        "114266",
+        "114304",
+        "114525",
+        "114585",
+        "114836",
+        "114903",
+        "114990",
+        "115588",
+        "115628",
+        "115841",
+        "115991",
+        "116236",
+        "116268",
+        "116577",
+        "116700",
+        "116768",
+        "116914",
+        "116937",
+        "117385",
+        "117814",
+        "118409",
+        "118450",
+        "118660",
+        "118719",
+        "118755",
+        "118807",
+        "119095",
+        "119224",
+        "119730",
+        "120638",
+        "120781",
+        "120857",
+        "121140",
+        "121404",
+        "121620",
+        "121804",
+        "121921",
+        "122000",
+        "122020",
+        "122288",
+        "122316",
+        "123575",
+        "124187",
+        "124899",
+        "125198",
+        "125465",
+        "125567",
+        "125626",
+        "125798",
+        "126228",
+        "126396",
+        "126445",
+        "126465",
+        "126494",
+        "126523",
+        "126542",
+        "126704",
+        "126768",
+        "126779",
+        "127511",
+        "127545",
+        "127758",
+        "127816",
+        "127870",
+        "127897",
+        "128901",
+        "129055",
+        "129164",
+        "129637",
+        "129739",
+        "129916",
+        "130214",
+        "130282",
+        "130308",
+        "130366",
+        "130373",
+        "130402",
+        "130556",
+        "130662",
+        "131040",
+        "131231",
+        "131235",
+        "131364",
+        "131494",
+        "131606",
+        "131636",
+        "131792",
+        "131919",
+        "131924",
+        "132155",
+        "132371",
+        "132597",
+        "132605",
+        "132812",
+        "132896",
+        "132920",
+        "133196",
+        "133338",
+        "133340",
+        "133886",
+        "133934",
+        "133946",
+        "134032",
+        "134197",
+        "134555",
+        "134728",
+        "134919",
+        "135503",
+        "135628",
+        "135687",
+        "135695",
+        "135697",
+        "135725",
+        "135733",
+        "135830",
+        "135855",
+        "136104",
+        "136105",
+        "136144",
+        "136220",
+        "136310",
+        "136382",
+        "136589",
+        "136793",
+        "136817",
+        "136996",
+        "137104",
+        "137168",
+        "137617",
+        "137624"
+      ],
+      "val_patients": [
+        "101627",
+        "104871",
+        "105549",
+        "105755",
+        "107630",
+        "109267",
+        "109654",
+        "109923",
+        "110012",
+        "110280",
+        "110327",
+        "111489",
+        "112765",
+        "113394",
+        "115788",
+        "115799",
+        "116246",
+        "117314",
+        "118018",
+        "118078",
+        "118481",
+        "118605",
+        "120749",
+        "121499",
+        "122762",
+        "122884",
+        "127096",
+        "127513",
+        "128785",
+        "129100",
+        "130371",
+        "130801",
+        "131444",
+        "132207",
+        "132282",
+        "132296",
+        "132589",
+        "133562",
+        "133710",
+        "133814",
+        "133850",
+        "134654",
+        "134955",
+        "135467",
+        "136175",
+        "136966",
+        "137508",
+        "137675"
+      ],
+      "n_train": 194,
+      "n_val": 48
+    }
+  }
+}

models/for_GM/model_training_scripts/p1_compute_class_weights.py

@@ -0,0 +1,336 @@
+"""
+P1 Article - Compute Class Weights from Training Data
+Utility script to calculate inverse frequency weights for class balancing
+
+Usage:
+    python p1_compute_class_weights.py --fold 0 --scenario binary --preprocessing standard
+    
+Output:
+    Saves class weights to JSON file for reproducibility
+    Prints weights for use in training
+    
+"""
+
+import numpy as np
+import json
+from pathlib import Path
+from tqdm import tqdm
+import argparse
+
+# Import data loader
+from p1_data_loader import DataConfig, P1DataLoader
+
+
+def compute_class_frequencies(dataset, num_classes, total_samples=None):
+    """
+    Compute class frequencies from dataset
+    
+    Args:
+        dataset: TensorFlow dataset yielding (paired_input, target_mask)
+        num_classes: Number of classes (2)
+        total_samples: Total number of samples (for progress bar)
+        
+    Returns:
+        class_pixel_counts: Array of pixel counts per class
+        total_pixels: Total number of pixels analyzed
+    """
+    class_pixel_counts = np.zeros(num_classes, dtype=np.int64)
+    total_pixels = 0
+    
+    print(f"Computing class frequencies for {num_classes}-class scenario...")
+    
+    iterator = tqdm(dataset, total=total_samples, desc="Processing") if total_samples else dataset
+    
+    for paired_input, target_mask, _, _ in iterator:
+        # target_mask shape: (batch_size, 256, 256)
+        masks = target_mask.numpy()
+        
+        for mask in masks:
+            # Count pixels for each class
+            for class_id in range(num_classes):
+                class_pixel_counts[class_id] += np.sum(mask == class_id)
+            
+            total_pixels += mask.size
+    
+    return class_pixel_counts, total_pixels
+
+
+def compute_inverse_frequency_weights(class_pixel_counts, num_classes):
+    """
+    Compute inverse frequency weights with normalization
+    
+    Args:
+        class_pixel_counts: Array of pixel counts per class
+        num_classes: Number of classes
+        
+    Returns:
+        class_weights: Normalized inverse frequency weights
+        class_frequencies: Class frequencies (for reference)
+    """
+    total_pixels = np.sum(class_pixel_counts)
+    
+    # Class frequencies
+    class_frequencies = class_pixel_counts / total_pixels
+    
+    # Inverse frequency (with small epsilon to avoid division by zero)
+    epsilon = 1e-6
+    inverse_freq = 1.0 / (class_frequencies + epsilon)
+    
+    # Normalize weights to sum = num_classes
+    # This keeps weights in a reasonable range while maintaining relative importance
+    class_weights = inverse_freq / np.sum(inverse_freq) * num_classes
+    
+    return class_weights, class_frequencies
+
+
+def compute_and_save_class_weights(fold_id, class_scenario, preprocessing, 
+                                   output_dir='class_weights_gm'):
+    """
+    Compute class weights for a specific fold and scenario
+    
+    Args:
+        fold_id: Fold number (0-4)
+        class_scenario: 'binary'
+        preprocessing: 'standard' or 'zoomed'
+        output_dir: Directory to save weights
+        
+    Returns:
+        Dictionary with weights and statistics
+    """
+    print("\n" + "="*70)
+    print(f"COMPUTING CLASS WEIGHTS")
+    print("="*70)
+    print(f"Fold: {fold_id}")
+    print(f"Scenario: {class_scenario}")
+    print(f"Preprocessing: {preprocessing}")
+    print("="*70 + "\n")
+    
+    # Initialize data loader
+    config = DataConfig()
+    data_loader = P1DataLoader(config)
+    
+    # Determine number of classes
+    num_classes = 2 if class_scenario == 'binary' else 2
+    
+    # Load training dataset
+    print("Loading training dataset...")
+    train_dataset = data_loader.create_dataset_for_fold(
+        fold_id=fold_id,
+        split='train',
+        preprocessing=preprocessing,
+        class_scenario=class_scenario,
+        batch_size=4,  # Larger batch for faster processing
+        shuffle=False  # No need to shuffle for counting
+    )
+    
+    # Get dataset size
+    train_size = sum(1 for _ in train_dataset)
+    print(f"Training samples: {train_size}")
+      
+    # Compute class frequencies
+    class_pixel_counts, total_pixels = compute_class_frequencies(
+        train_dataset, num_classes, train_size
+    )
+    
+    # Compute inverse frequency weights
+    class_weights, class_frequencies = compute_inverse_frequency_weights(
+        class_pixel_counts, num_classes
+    )
+    
+    # Print results
+    print("\n" + "="*70)
+    print("RESULTS")
+    print("="*70)
+    
+    class_names = {
+        2: ['Background', 'Specialized GM']
+    }
+    
+    print(f"\nTotal pixels analyzed: {total_pixels:,}")
+    print(f"\nClass Statistics:")
+    print("-" * 70)
+    
+    for i in range(num_classes):
+        print(f"Class {i} ({class_names[num_classes][i]}):")
+        print(f"  Pixel count:  {class_pixel_counts[i]:,}")
+        print(f"  Frequency:    {class_frequencies[i]:.6f} ({class_frequencies[i]*100:.2f}%)")
+        print(f"  Weight:       {class_weights[i]:.4f}")
+        print()
+    
+    # Save to JSON
+    output_path = Path(output_dir)
+    output_path.mkdir(exist_ok=True)
+    
+    results = {
+        'fold_id': fold_id,
+        'class_scenario': class_scenario,
+        'preprocessing': preprocessing,
+        'num_classes': num_classes,
+        'total_pixels': int(total_pixels),
+        'class_pixel_counts': class_pixel_counts.tolist(),
+        'class_frequencies': class_frequencies.tolist(),
+        'class_weights': class_weights.tolist(),
+        'class_names': class_names[num_classes]
+    }
+    
+    filename = f"class_weights_fold{fold_id}_{preprocessing}_{class_scenario}.json"
+    filepath = output_path / filename
+    
+    with open(filepath, 'w') as f:
+        json.dump(results, f, indent=2)
+    
+    print("="*70)
+    print(f"✅ Class weights saved to: {filepath}")
+    print("="*70)
+    
+    # Print weights in format ready for code
+    print("\nFor use in training script:")
+    print("-" * 70)
+    print(f"class_weights = tf.constant({class_weights.tolist()}, dtype=tf.float32)")
+    print()
+    
+    return results
+
+
+def compute_all_scenarios_for_fold(fold_id):
+    """
+    Compute class weights for all 2 scenarios of a given fold
+    
+    Args:
+        fold_id: Fold number (0-4)
+    """
+    scenarios = [
+        {'preprocessing': 'standard', 'class_scenario': 'binary'},
+        {'preprocessing': 'zoomed', 'class_scenario': 'binary'},
+    ]
+    
+    all_results = {}
+    
+    for scenario in scenarios:
+        results = compute_and_save_class_weights(
+            fold_id=fold_id,
+            class_scenario=scenario['class_scenario'],
+            preprocessing=scenario['preprocessing']
+        )
+        
+        key = f"{scenario['preprocessing']}_{scenario['class_scenario']}"
+        all_results[key] = results
+        
+        print("\n" + "="*70 + "\n")
+    
+    return all_results
+
+
+def load_class_weights(fold_id, class_scenario, preprocessing, weights_dir='class_weights_gm'):
+    """
+    Load previously computed class weights
+    
+    Args:
+        fold_id: Fold number (0-4)
+        class_scenario: 'binary'
+        preprocessing: 'standard' or 'zoomed'
+        weights_dir: Directory containing weights files
+        
+    Returns:
+        class_weights: NumPy array of weights
+    """
+    weights_path = Path(weights_dir)
+    filename = f"class_weights_fold{fold_id}_{preprocessing}_{class_scenario}.json"
+    filepath = weights_path / filename
+    
+    if not filepath.exists():
+        raise FileNotFoundError(
+            f"Class weights not found: {filepath}\n"
+            f"Run compute_and_save_class_weights() first."
+        )
+    
+    with open(filepath, 'r') as f:
+        results = json.load(f)
+    
+    class_weights = np.array(results['class_weights'], dtype=np.float32)
+    
+    return class_weights
+
+
+def main():
+    """Main entry point with argument parsing"""
+    parser = argparse.ArgumentParser(
+        description='Compute class weights from training data',
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+    # Single scenario
+    python p1_compute_class_weights.py --fold 0 --scenario binary --preprocessing standard
+    
+    # All scenarios for one fold
+    python p1_compute_class_weights.py --fold 0 --all
+    
+    # All folds (for completeness)
+    python p1_compute_class_weights.py --all-folds
+        """
+    )
+    
+    parser.add_argument(
+        '--fold',
+        type=int,
+        choices=[0, 1, 2, 3, 4],
+        help='Fold number (0-4)'
+    )
+    
+    parser.add_argument(
+        '--scenario',
+        type=str,
+        choices=['binary'],
+        help='Class scenario'
+    )
+    
+    parser.add_argument(
+        '--preprocessing',
+        type=str,
+        choices=['standard', 'zoomed'],
+        help='Preprocessing type'
+    )
+    
+    parser.add_argument(
+        '--all',
+        action='store_true',
+        help='Compute for all scenarios of specified fold'
+    )
+    
+    parser.add_argument(
+        '--all-folds',
+        action='store_true',
+        help='Compute for all scenarios of all folds'
+    )
+    
+    args = parser.parse_args()
+    
+    # Validate arguments
+    if args.all_folds:
+        # Compute for all folds
+        for fold_id in range(5):
+            print(f"\n{'='*70}")
+            print(f"PROCESSING FOLD {fold_id}")
+            print(f"{'='*70}\n")
+            compute_all_scenarios_for_fold(fold_id)
+    
+    elif args.all:
+        # Compute all scenarios for one fold
+        if args.fold is None:
+            parser.error("--fold is required when using --all")
+        compute_all_scenarios_for_fold(args.fold)
+    
+    else:
+        # Compute single scenario
+        if args.fold is None or args.scenario is None or args.preprocessing is None:
+            parser.error("--fold, --scenario, and --preprocessing are required")
+        
+        compute_and_save_class_weights(
+            fold_id=args.fold,
+            class_scenario=args.scenario,
+            preprocessing=args.preprocessing
+        )
+
+
+if __name__ == "__main__":
+    main()

models/for_GM/model_training_scripts/p1_data_loader.py

@@ -0,0 +1,847 @@
+"""
+P1 & P4 Articles - Data Loading System
+
+Complete implementation for brain segmentation experiments
+
+Specialized Gray Matter (GM) Segmentation with U-Net Models - Journal Paper Implementation
+Binary segmentation: Background vs Specialized GM
+Professional results saving and visualization for publication
+
+This relates to our articles:
+"Specialized gray matter segmentation via a generative adversarial network: 
+application on brain white matter hyperintensities classification"
+
+"Deep Learning-Based Neuroanatomical Profiling Reveals Detailed Brain Changes:
+A Large-Scale Multiple Sclerosis Study"
+
+Features:
+- Load FLAIR images and individual mask files from Cohort directory
+- Support both Local_SAI_GM_sp dataset
+- Handle standard and zoomed preprocessing variants
+- Combine masks into 2-class format
+- Create paired inputs: [FLAIR | mask] concatenated (256x512)
+- Patient-stratified K-fold cross-validation
+- TensorFlow dataset creation with proper batching
+
+Authors:
+"Mahdi Bashiri Bawil, Mousa Shamsi, Abolhassan Shakeri Bavil"
+
+Developer:
+"Mahdi Bashiri Bawil"
+"""
+
+import numpy as np
+import os
+from pathlib import Path
+from typing import Tuple, List, Dict, Optional
+import json
+from sklearn.model_selection import KFold
+from tqdm import tqdm
+import cv2 as cv
+
+# Deep Learning
+import tensorflow as tf
+
+
+###################### Configuration ######################
+
+class DataConfig:
+    """Data configuration for P4 experiments"""
+    
+    def __init__(self):
+        # Base paths
+        self.cohort_dir = Path("/mnt/e/MBashiri/ours_articles/Paper#2/Data/Cohort")  # CHANGE THIS to your actual path of Data Cohort
+        
+        # Dataset configurations
+        self.datasets = {
+            'Local_SAI_GM_sp': {
+                'base_path': self.cohort_dir / 'Local_SAI_GM_sp',
+                'slice_range': (1, 20),  # inclusive range 9,15
+                'patient_prefix_length': 6  # "101228"
+            }
+        }
+        
+        # Preprocessing variants
+        self.preprocessing_types = ['standard', 'zoomed']
+        
+        # Class scenarios
+        self.class_scenarios = {
+            'binary': {
+                'num_classes': 2,
+                'class_names': ['Background', 'Specialized GM'],
+                'description': 'Binary: Background, Specialized GM',
+                'class_mapping': {
+                    'background': 0,
+                    'specialized_gm': 1,
+                }
+            }
+        }
+        
+        # K-fold parameters
+        self.k_folds = 5
+        self.test_split = 0.1  # 10% for test set
+        self.random_state = 42
+        
+        # Image parameters
+        self.target_size = (256, 256)
+        self.paired_width = 512  # FLAIR (256) + mask (256)
+        
+        # Paths for splits
+        self.splits_dir = Path("data_splits_sp_gm")
+        self.splits_file = self.splits_dir / "SP_GM_fold_assignments.json"
+
+
+###################### Helper Functions ######################
+
+def extract_patient_id(filename: str, prefix_length: int = 6) -> str:
+    """
+    Extract patient ID from filename
+    
+    Args:
+        filename: e.g., "101228_5.npy" or "c01p01_25.png"
+        prefix_length: Number of characters in patient ID
+        
+    Returns:
+        Patient ID: e.g., "101228" or "c01p01"
+    """
+    return filename.split('_')[0][:prefix_length]
+
+
+def extract_slice_number(filename: str) -> int:
+    """
+    Extract slice number from filename
+    
+    Args:
+        filename: e.g., "101228_5.npy" or "c01p01_25.png"
+        
+    Returns:
+        Slice number as integer
+    """
+    # Get the part before file extension
+    basename = filename.split('.')[0]
+    # Get the last part after splitting by '_'
+    slice_num = basename.split('_')[-1]
+    return int(slice_num)
+
+
+def load_flair_image(flair_path: Path, normalize: bool = False, of_z_score: bool = False) -> np.ndarray:
+    """
+    Load FLAIR image (.png format)
+    
+    Args:
+        flair_path: Path to .png file
+        normalize: Whether to apply z-score normalization
+        
+    Returns:
+        FLAIR image (256, 256, 1) as float32
+    """
+    if of_z_score:
+        # Load NPY: the already z-scored FLAIR image data
+        flair = np.load(str(flair_path).replace('.png','.npy')).astype(np.float32)
+    else:
+        # Load PNG as grayscale
+        flair = cv.imread(str(flair_path), cv.IMREAD_GRAYSCALE).astype(np.float32)
+
+        # Normalize to [-1, 1]:
+        flair = (flair - np.min(flair)) / (np.max(flair) - np.min(flair))
+        flair = (2 * flair) - 1
+    
+    # Ensure correct shape
+    if len(flair.shape) == 2:
+        flair = np.expand_dims(flair, axis=-1)
+    
+    # Additional normalization if needed (should already be normalized)
+    if normalize and (np.std(flair) > 2.0 or np.abs(np.mean(flair)) > 1.0):
+        # Re-normalize if values seem off
+        flair = (flair - np.mean(flair)) / (np.std(flair) + 1e-7)
+    
+    return flair
+
+
+def load_mask_image(mask_path: Path) -> np.ndarray:
+    """
+    Load mask image (.png format)
+    
+    Args:
+        mask_path: Path to .png file
+        
+    Returns:
+        Binary mask (256, 256) as uint8
+    """
+    # Load PNG as grayscale
+    mask = cv.imread(str(mask_path), cv.IMREAD_GRAYSCALE)
+    
+    if mask is None:
+        raise FileNotFoundError(f"Could not load mask: {mask_path}")
+    
+    # Binarize (any non-zero value becomes 1)
+    mask = (mask > 0).astype(np.uint8)
+    
+    return mask
+
+
+def combine_masks(gm_mask: np.ndarray, 
+                  class_scenario: str,
+                  preprocess: bool = False) -> np.ndarray:
+    """
+    Combine individual masks into multi-class format
+    
+    Args:
+        gm_mask: Ventricles mask (256, 256)
+        class_scenario: 'binary'
+        preprocess: Boolean turning the morphological preprocessing on or off
+        
+    Returns:
+        Combined mask (256, 256) with class labels
+    """
+    if preprocess:
+        from skimage.morphology import remove_small_objects, binary_erosion, binary_closing, binary_opening, disk, binary_dilation
+        min_object_size = 5
+        closing_kernel_size = 2
+        dilation_kernel_size = 1
+
+        gm_mask = gm_mask > 0
+
+        gm_mask = binary_closing(gm_mask, disk(closing_kernel_size))
+        gm_mask = binary_erosion(gm_mask, disk(dilation_kernel_size))
+        gm_mask = remove_small_objects(gm_mask, min_size=min_object_size)
+
+    # Class 0: Background (default)
+    # Class 1: Specialized GM
+    combined = np.zeros_like(gm_mask, dtype=np.uint8)
+    combined[gm_mask>0] = 1
+    
+    return combined
+
+
+def is_valid_slice(gm_mask: np.ndarray) -> bool:
+    """
+    Check if slice has at least one non-empty mask
+    
+    Args:
+        gm_mask: Specialized GM mask (256, 256)
+        
+    Returns:
+        True if at least one mask has non-zero pixels
+    """
+    has_specialized_gm = np.sum(gm_mask) > 50
+    
+    # Valid if ANY mask has content
+    return True #  or has_specialized_gm 
+
+
+def create_paired_input(flair: np.ndarray, 
+                                 mask: np.ndarray,
+                                 brain_mask: np.ndarray,
+                                 num_classes: np.ndarray,
+                                 if_bet=False) -> np.ndarray:
+    """
+    Create paired input: [FLAIR | mask] concatenated horizontally
+    
+    Args:
+        flair: FLAIR image (256, 256, 1) float32
+        mask: Combined mask (256, 256) uint8
+        
+    Returns:
+        Paired image (256, 512, 1) float32
+    """
+    # Binarize (any non-zero value becomes 1)
+    brain_mask = brain_mask > 0
+
+    # Brain extraction
+    if if_bet:
+        # print("\n\t Doing THEEEEEEEEE BET")
+        flair[~brain_mask] = np.min(flair)
+        mask[~brain_mask] = 0
+
+    # Ensure flair is 3D
+    if len(flair.shape) == 2:
+        flair = np.expand_dims(flair, axis=-1)
+    
+    # Convert mask to float and normalize to [0, 1] range for consistency
+
+    max_class = num_classes
+    mask_normalized = mask.astype(np.float32)
+    if max_class > 0:
+        mask_normalized = mask_normalized / max_class
+        mask_normalized = (2 * mask_normalized) - 1
+    
+    mask_3d = np.expand_dims(mask_normalized, axis=-1)
+    
+    # Concatenate horizontally: [FLAIR | mask]
+    paired = np.concatenate([flair, mask_3d], axis=1)  # (256, 512, 1)
+    
+    return paired, mask
+
+
+###################### Patient Stratified Splitting ######################
+
+class PatientStratifiedSplitter:
+    """
+    Create patient-stratified train/val/test splits
+    Similar to P6 implementation but adapted for P1 data structure
+    """
+    
+    def __init__(self, config: DataConfig):
+        self.config = config
+        self.config.splits_dir.mkdir(exist_ok=True)
+    
+    def collect_all_patients(self) -> Dict[str, List[str]]:
+        """
+        Collect all unique patient IDs from both datasets
+        
+        Returns:
+            Dictionary mapping dataset_name -> list of patient IDs
+        """
+        all_patients = {}
+        
+        for dataset_name, dataset_config in self.config.datasets.items():
+            patients = set()
+            
+            # Path to FLAIR images (standard preprocessing)
+            flair_dir = dataset_config['base_path'] / 'FLAIR' / 'Preprocessed' / 'images'
+            
+            if not flair_dir.exists():
+                print(f"Warning: {flair_dir} does not exist. Skipping {dataset_name}.")
+                continue
+            
+            # Collect all .png files
+            for flair_file in flair_dir.glob('*.png'):
+                patient_id = extract_patient_id(
+                    flair_file.name, 
+                    dataset_config['patient_prefix_length']
+                )
+                patients.add(patient_id)
+            
+            all_patients[dataset_name] = sorted(list(patients))
+            print(f"{dataset_name}: {len(all_patients[dataset_name])} patients")
+        
+        return all_patients
+    
+    def create_patient_stratified_splits(self, 
+                                        save: bool = True) -> Dict:
+        """
+        Create patient-stratified K-fold splits
+        
+        Returns:
+            Dictionary containing fold assignments
+        """
+        all_patients = self.collect_all_patients()
+        
+        # Combine patients from both datasets
+        combined_patients = []
+        for dataset_name, patients in all_patients.items():
+            combined_patients.extend(patients)
+        
+        combined_patients = np.array(combined_patients)
+        total_patients = len(combined_patients)
+        
+        print(f"\nTotal unique patients: {total_patients}")
+        
+        # Step 1: Split into train+val (80%) and test (20%)
+        np.random.seed(self.config.random_state)
+        test_size = int(total_patients * self.config.test_split)
+        
+        test_indices = np.random.choice(
+            total_patients, 
+            size=test_size, 
+            replace=False
+        )
+        
+        test_patients = combined_patients[test_indices]
+        train_val_indices = np.setdiff1d(np.arange(total_patients), test_indices)
+        train_val_patients = combined_patients[train_val_indices]
+        
+        print(f"Test patients: {len(test_patients)}")
+        print(f"Train+Val patients: {len(train_val_patients)}")
+        
+        # Step 2: Create K-fold splits on train+val patients
+        kfold = KFold(
+            n_splits=self.config.k_folds, 
+            shuffle=True, 
+            random_state=self.config.random_state
+        )
+        
+        fold_assignments = {
+            'metadata': {
+                'total_patients': total_patients,
+                'test_patients': len(test_patients),
+                'trainval_patients': len(train_val_patients),
+                'n_folds': self.config.k_folds,
+                'random_seed': self.config.random_state,
+                'datasets': list(all_patients.keys())
+            },
+            'test_set': {
+                'patients': test_patients.tolist(),
+                'n_patients': len(test_patients)
+            },
+            'folds': {}
+        }
+        
+        for fold_idx, (train_idx, val_idx) in enumerate(kfold.split(train_val_patients)):
+            train_patients_fold = train_val_patients[train_idx]
+            val_patients_fold = train_val_patients[val_idx]
+            
+            fold_assignments['folds'][f'fold_{fold_idx}'] = {
+                'train_patients': train_patients_fold.tolist(),
+                'val_patients': val_patients_fold.tolist(),
+                'n_train': len(train_patients_fold),
+                'n_val': len(val_patients_fold)
+            }
+            
+            print(f"Fold {fold_idx}: Train={len(train_patients_fold)}, Val={len(val_patients_fold)}")
+        
+        # Save to JSON
+        if save:
+            with open(self.config.splits_file, 'w') as f:
+                json.dump(fold_assignments, f, indent=2)
+            print(f"\n✅ Fold assignments saved to: {self.config.splits_file}")
+        
+        return fold_assignments
+    
+    def load_fold_assignments(self) -> Dict:
+        """Load existing fold assignments from JSON"""
+        if not self.config.splits_file.exists():
+            raise FileNotFoundError(
+                f"Fold assignments not found: {self.config.splits_file}\n"
+                f"Run create_patient_stratified_splits() first."
+            )
+        
+        with open(self.config.splits_file, 'r') as f:
+            fold_assignments = json.load(f)
+        
+        return fold_assignments
+    
+    def verify_patient_separation(self, fold_assignments: Dict) -> bool:
+        """
+        Verify no patient appears in multiple folds or in both train/val
+        Similar to P6's verification logic
+        """
+        print("\n" + "="*60)
+        print("VERIFYING PATIENT SEPARATION")
+        print("="*60)
+        
+        all_issues = []
+        test_patients = set(fold_assignments['test_set']['patients'])
+        
+        # Check 1: No patient in both test and train/val
+        for fold_name, fold_data in fold_assignments['folds'].items():
+            train_patients = set(fold_data['train_patients'])
+            val_patients = set(fold_data['val_patients'])
+            
+            test_train_overlap = test_patients.intersection(train_patients)
+            test_val_overlap = test_patients.intersection(val_patients)
+            
+            if test_train_overlap:
+                issue = f"{fold_name}: Test-Train overlap: {test_train_overlap}"
+                all_issues.append(issue)
+                print(f"❌ {issue}")
+            
+            if test_val_overlap:
+                issue = f"{fold_name}: Test-Val overlap: {test_val_overlap}"
+                all_issues.append(issue)
+                print(f"❌ {issue}")
+        
+        # Check 2: No patient in both train and val within same fold
+        for fold_name, fold_data in fold_assignments['folds'].items():
+            train_patients = set(fold_data['train_patients'])
+            val_patients = set(fold_data['val_patients'])
+            
+            train_val_overlap = train_patients.intersection(val_patients)
+            if train_val_overlap:
+                issue = f"{fold_name}: Train-Val overlap: {train_val_overlap}"
+                all_issues.append(issue)
+                print(f"❌ {issue}")
+        
+        # Check 3: Each patient in validation exactly once
+        all_val_patients = []
+        for fold_data in fold_assignments['folds'].values():
+            all_val_patients.extend(fold_data['val_patients'])
+        
+        val_patient_counts = {}
+        for patient in all_val_patients:
+            val_patient_counts[patient] = val_patient_counts.get(patient, 0) + 1
+        
+        for patient, count in val_patient_counts.items():
+            if count != 1:
+                issue = f"Patient {patient} in validation {count} times (should be 1)"
+                all_issues.append(issue)
+                print(f"❌ {issue}")
+        
+        if not all_issues:
+            print("✅ All patient separation checks passed")
+            print("✅ No data leakage detected")
+            return True
+        else:
+            print(f"\n❌ Found {len(all_issues)} issues")
+            return False
+
+
+###################### Data Loader ######################
+
+class P1DataLoader:
+    """
+    Main data loader for P1 experiments
+    Handles loading FLAIR and masks, creating paired inputs, TensorFlow datasets
+    """
+    
+    def __init__(self, config: DataConfig):
+        self.config = config
+    
+    def get_file_paths(self, 
+                       patient_id: str, 
+                       slice_num: int,
+                       dataset_name: str,
+                       preprocessing: str) -> Dict[str, Path]:
+        """
+        Construct file paths for a given patient-slice
+        
+        Args:
+            patient_id: e.g., "101228" or "c01p01"
+            slice_num: Slice number
+            dataset_name: 'Local_SAI_GM_sp'
+            preprocessing: 'standard' or 'zoomed'
+            
+        Returns:
+            Dictionary with paths to FLAIR and mask files
+        """
+        dataset_config = self.config.datasets[dataset_name]
+        base_path = dataset_config['base_path']
+        
+        # Determine subdirectory based on preprocessing
+        if preprocessing == 'standard':
+            flair_subdir = 'images'
+            gt_subdir = 'images'
+        else:  # zoomed
+            flair_subdir = 'zoomed/images'
+            gt_subdir = 'zoomed/images'
+        
+        # Construct paths
+        flair_path = base_path / 'FLAIR' / 'Preprocessed' / flair_subdir / f'{patient_id}_{slice_num}.png'
+        gm_path = base_path / 'GroundTruth' / gt_subdir / 'GM_Masks' / f'{patient_id}_{slice_num}.png'
+        brain_path = base_path / 'GroundTruth' / gt_subdir / 'Brain_Masks' / f'{patient_id}_{slice_num}.png'
+        
+        # Optional: zooming factors (only for zoomed preprocessing)
+        zoom_factors_path = None
+        if preprocessing == 'zoomed':
+            zoom_factors_path = base_path / 'FLAIR' / 'Preprocessed' / 'zoomed' / 'images' / f'{patient_id}_zooming_factors.npy'
+        
+        return {
+            'flair': flair_path,
+            'gm_mask': gm_path,
+            'brain_mask': brain_path,
+            'zoom_factors': zoom_factors_path
+        }
+    
+    def load_single_slice(self,
+                         patient_id: str,
+                         slice_num: int,
+                         dataset_name: str,
+                         preprocessing: str,
+                         class_scenario: str,
+                         of_z_score: bool = True,
+                         if_bet: bool = True,
+                         pre_morph: bool = False) -> Tuple[np.ndarray, np.ndarray]:
+        """
+        Load a single patient-slice and create paired input
+        
+        Args:
+            patient_id: Patient identifier
+            slice_num: Slice number
+            dataset_name: 'Local_SAI_GM_sp'
+            preprocessing: 'standard' or 'zoomed'
+            class_scenario: 'binary'
+            
+        Returns:
+            Tuple of (paired_input, combined_mask)
+            - paired_input: (256, 512, 1) FLAIR + mask concatenated
+            - combined_mask: (256, 256) multi-class labels
+        """
+        # Class number
+        num_classes = 1 # int(class_scenario[0]) - 1
+
+        # Get file paths
+        paths = self.get_file_paths(patient_id, slice_num, dataset_name, preprocessing)
+        
+        # Load FLAIR
+        flair = load_flair_image(paths['flair'], of_z_score=of_z_score)
+        
+        # Load masks
+        gm_mask = load_mask_image(paths['gm_mask'])
+        brain_mask = load_mask_image(paths['brain_mask'])
+        
+        # Combine masks
+        combined_mask = combine_masks(gm_mask, class_scenario, preprocess=pre_morph)
+        
+        # Create paired input
+        paired_input, combined_mask = create_paired_input(flair, combined_mask, brain_mask, num_classes=num_classes, if_bet=if_bet)
+        
+        return paired_input, combined_mask
+        
+    def collect_patient_slices(self, 
+                            patient_list: List[str],
+                            dataset_name: str,
+                            preprocessing: str) -> List[Tuple[str, int, str]]:
+        """
+        Collect all valid slice files for given patients
+        FILTERS OUT SLICES WITH ALL EMPTY MASKS
+        
+        Args:
+            patient_list: List of patient IDs
+            dataset_name: 'Local_SAI_GM_sp'
+            preprocessing: 'standard' or 'zoomed'
+            
+        Returns:
+            List of tuples (patient_id, slice_num, dataset_name)
+        """
+        dataset_config = self.config.datasets[dataset_name]
+        slice_min, slice_max = dataset_config['slice_range']
+        
+        patient_slices = []
+        skipped_empty = 0
+        
+        for patient_id in patient_list:
+            # Check which dataset this patient belongs to
+            # Try to find patient in current dataset
+            for slice_num in range(slice_min, slice_max + 1):
+                paths = self.get_file_paths(patient_id, slice_num, dataset_name, preprocessing)
+                
+                # Check if all required files exist
+                if (paths['flair'].exists() and 
+                    paths['gm_mask'].exists() and 
+                    paths['brain_mask'].exists()):
+                    
+                    # VALIDATION: Check if masks are not all empty
+                    try:
+                        gm_mask = load_mask_image(paths['gm_mask'])
+                        brain_mask = load_mask_image(paths['brain_mask'])
+                        
+                        # Only add if at least one mask has content
+                        if is_valid_slice(gm_mask):
+                            patient_slices.append((patient_id, slice_num, dataset_name))
+                        else:
+                            skipped_empty += 1
+                            
+                    except Exception as e:
+                        print(f"Warning: Could not validate {patient_id}_{slice_num}: {e}")
+                        skipped_empty += 1
+        
+        if skipped_empty > 0:
+            print(f"  ⚠️  Skipped {skipped_empty} slices with empty masks")
+        
+        return patient_slices
+        
+    def create_dataset_for_fold(self,
+                                fold_id: int,
+                                split: str,
+                                preprocessing: str,
+                                class_scenario: str,
+                                batch_size: int = 1,
+                                shuffle: bool = True,
+                                use_z_scored: bool = True,
+                                bet: bool = False) -> tf.data.Dataset:
+        """
+        Create TensorFlow dataset for a specific fold and split
+        
+        Args:
+            fold_id: Fold number (0-4)
+            split: 'train', 'val', or 'test'
+            preprocessing: 'standard' or 'zoomed'
+            class_scenario: 'binary'
+            batch_size: Batch size
+            shuffle: Whether to shuffle data
+            
+        Returns:
+            tf.data.Dataset yielding (paired_input, combined_mask) batches
+        """
+        # Load fold assignments
+        splitter = PatientStratifiedSplitter(self.config)
+        fold_assignments = splitter.load_fold_assignments()
+        
+        # Get patient list for this split
+        if split == 'test':
+            patient_list = fold_assignments['test_set']['patients']
+        else:
+            fold_key = f'fold_{fold_id}'
+            if split == 'train':
+                patient_list = fold_assignments['folds'][fold_key]['train_patients']
+            elif split == 'val':
+                patient_list = fold_assignments['folds'][fold_key]['val_patients']
+            else:
+                raise ValueError(f"Unknown split: {split}")
+        
+        print(f"\nCreating dataset for fold {fold_id}, split '{split}'")
+        print(f"Patients: {len(patient_list)}")
+        
+        # Collect all patient-slices from both datasets
+        all_patient_slices = []
+        
+        for dataset_name in self.config.datasets.keys():
+            # Filter patient list to only include patients from this dataset
+            # This is done by checking patient ID prefix
+            dataset_patients = [p for p in patient_list]
+            
+            patient_slices = self.collect_patient_slices(
+                dataset_patients, 
+                dataset_name, 
+                preprocessing
+            )
+            all_patient_slices.extend(patient_slices)
+        
+        print(f"Total slices: {len(all_patient_slices)}")
+        
+        if len(all_patient_slices) == 0:
+            raise ValueError(f"No data found for fold {fold_id}, split '{split}'")
+        
+        # Create TensorFlow dataset
+        def data_generator():
+            """Generator function for tf.data.Dataset"""
+            for patient_id, slice_num, dataset_name in all_patient_slices:
+                try:
+                    paired_input, combined_mask = self.load_single_slice(
+                        patient_id, slice_num, dataset_name, 
+                        preprocessing, class_scenario
+                    )
+                    yield paired_input, combined_mask, patient_id, slice_num
+                except Exception as e:
+                    print(f"Error loading {patient_id}_{slice_num}: {e}")
+                    continue
+        
+        # Create dataset
+        dataset = tf.data.Dataset.from_generator(
+            data_generator,
+            output_signature=(
+                tf.TensorSpec(shape=(256, 512, 1), dtype=tf.float32),   # concatenated image
+                tf.TensorSpec(shape=(256, 256), dtype=tf.uint8),        # multi-level mask
+                tf.TensorSpec(shape=(),            dtype=tf.string),    # patient_id
+                tf.TensorSpec(shape=(),            dtype=tf.int32)      # slice_num
+            )
+        )
+
+        # ── Cache BEFORE shuffle/batch ──────────────────────────────────────
+        # On epoch 1 the generator runs once and all samples are stored
+        # in RAM (~1 GB).  From epoch 2 onward no disk I/O occurs at all.
+        # Placing cache HERE (on unbatched, unshuffled samples) means:
+        #   • The expensive load/decode/combine step is paid only once.
+        #   • Shuffle re-randomises the order freshly each epoch (because
+        #     reshuffle_each_iteration=True is the default).
+        #   • Batch composition therefore differs every epoch as desired.
+        dataset = dataset.cache()
+
+        # Shuffle if training  (acts on the in-RAM cache every epoch)
+        if shuffle and split == 'train':
+            dataset = dataset.shuffle(
+                buffer_size=len(all_patient_slices),
+                reshuffle_each_iteration=True   # new random order each epoch
+            )
+        
+        # Batch and prefetch
+        dataset = dataset.batch(batch_size)
+        dataset = dataset.prefetch(tf.data.AUTOTUNE)
+        
+        return dataset
+
+
+###################### Testing & Validation Functions ######################
+
+def test_data_loading():
+    """Test data loading functionality"""
+    print("\n" + "="*60)
+    print("TESTING DATA LOADING")
+    print("="*60)
+    
+    config = DataConfig()
+    
+    # Test 1: Create fold assignments
+    print("\n[TEST 1] Creating patient stratified splits...")
+    splitter = PatientStratifiedSplitter(config)
+    fold_assignments = splitter.create_patient_stratified_splits(save=True)
+    
+    # Verify patient separation
+    is_valid = splitter.verify_patient_separation(fold_assignments)
+    
+    if not is_valid:
+        print("❌ Patient separation verification failed!")
+        return False
+    
+    # Test 2: Load a single slice
+    print("\n[TEST 2] Loading single slice...")
+    loader = P1DataLoader(config)
+    
+    # Get a test patient from fold 0 train set
+    test_patient = fold_assignments['folds']['fold_0']['train_patients'][0]
+    
+    # Determine which dataset this patient belongs to
+    if test_patient.startswith('1'):
+        test_dataset = 'Local_SAI_GM_sp'
+        test_slice = 10  # Middle of 8-15 range
+    else:
+        raise ValueError
+
+    
+    try:
+        paired_input, combined_mask = loader.load_single_slice(
+            test_patient, test_slice, test_dataset, 
+            'standard', 'binary'
+        )
+        
+        print(f"✅ Loaded slice {test_patient}_{test_slice}")
+        print(f"   Paired input shape: {paired_input.shape}")
+        print(f"   Combined mask shape: {combined_mask.shape}")
+        print(f"   Mask unique values: {np.unique(combined_mask)}")
+        
+    except Exception as e:
+        print(f"❌ Failed to load slice: {e}")
+        return False
+    
+    # Test 3: Create TensorFlow dataset
+    print("\n[TEST 3] Creating TensorFlow dataset...")
+    try:
+        dataset = loader.create_dataset_for_fold(
+            fold_id=0,
+            split='train',
+            preprocessing='standard',
+            class_scenario='binary',
+            batch_size=2,
+            shuffle=True
+        )
+        
+        # Get first batch
+        for batch_paired, batch_masks, _, _ in dataset.take(1):
+            print(f"✅ Created dataset")
+            print(f"   Batch paired input shape: {batch_paired.shape}")
+            print(f"   Batch masks shape: {batch_masks.shape}")
+            print(f"   Paired input dtype: {batch_paired.dtype}")
+            print(f"   Masks dtype: {batch_masks.dtype}")
+            
+    except Exception as e:
+        print(f"❌ Failed to create dataset: {e}")
+        return False
+    
+    print("\n" + "="*60)
+    print("✅ ALL TESTS PASSED")
+    print("="*60)
+    
+    return True
+
+
+###################### Main Execution ######################
+
+if __name__ == "__main__":
+    # Run tests
+    success = test_data_loading()
+    
+    if success:
+        print("\n" + "="*60)
+        print("DATA LOADER READY FOR USE")
+        print("="*60)
+        print("\nNext steps:")
+        print("1. Verify fold_assignments.json created in data_splits/")
+        print("2. Check that all file paths are correct for your system")
+        print("3. Proceed to model implementation")
+    else:
+        print("\n" + "="*60)
+        print("❌ DATA LOADER TESTS FAILED")
+        print("="*60)
+        print("\nPlease fix the issues above before proceeding")
+

models/for_GM/model_training_scripts/p1_pix2pix_var5.py

@@ -0,0 +1,1313 @@
+"""
+P1 Article - Specialized Gray Matter (GM) Segmentation with U-Net Models - Journal Paper Implementation
+
+Features:
+- Multi-channel Generator output (softmax)
+- Attention-Weighted PatchGAN Discriminator
+- Adaptive hybrid loss (Weighted Categorical Cross-Entropy & Focal Dice)
+- One-hot encoded targets
+- Class weight computation per fold
+- Optimized for severe class imbalance
+"""
+
+import tensorflow as tf
+import os
+import time
+import numpy as np
+import matplotlib.pyplot as plt
+from pathlib import Path
+from tqdm import tqdm
+import json
+
+from unet_model import build_unet_3class
+
+# Import data loader
+from p1_data_loader import DataConfig, P1DataLoader
+
+# Import utilities from baseline
+from utility_functions import (
+    clear_gpu_memory,
+    get_gpu_memory_info,
+)
+
+# Import class weights utility
+from p1_compute_class_weights import compute_and_save_class_weights, load_class_weights
+
+
+print("TensorFlow Version:", tf.__version__)
+
+###################### GPU Configuration ######################
+
+# Configure GPU memory growth
+physical_devices = tf.config.list_physical_devices('GPU')
+if physical_devices:
+    try:
+        for device in physical_devices:
+            tf.config.experimental.set_memory_growth(device, True)
+        print("✅ GPU memory growth enabled")
+        print(f"   Available GPUs: {len(physical_devices)}")
+    except RuntimeError as e:
+        print(f"GPU configuration error: {e}")
+else:
+    print("⚠️  No GPU detected - training will be slow")
+ 
+"""
+GPU Memory Management for Sequential Experiments
+To properly release memory between experiments
+"""
+
+###################### Target Preparation ######################
+
+def prepare_inputs(paired_input, target_mask, num_classes):
+    """
+    Prepare inputs for training
+    
+    Args:
+        paired_input: (bs, 256, 512, 1) with FLAIR + mask
+        target_mask: (bs, 256, 256) with class labels [0, num_classes-1]
+        num_classes: number of classes
+        
+    Returns:
+        flair_normalized: FLAIR normalized to [-1, 1]
+        target_onehot: One-hot encoded mask (bs, 256, 256, num_classes)
+    """
+    # Extract FLAIR, previously normalized to [-1, 1]
+    flair_normalized = paired_input[:, :, :256, :]
+
+    # One-hot encode target
+    target_onehot = tf.one_hot(target_mask, depth=num_classes, dtype=tf.float32)
+    
+    return flair_normalized, target_onehot
+
+###################### Metrics Calculation ######################
+
+def compute_classwise_metrics(all_val_true, all_val_pred, num_classes, exclude_class=None):
+    """
+    Compute class-wise Dice, Precision, and Recall for validation predictions.
+    
+    Args:
+        all_val_true: List of one-hot encoded ground truth tensors
+        all_val_pred: List of softmax output tensors from generator
+        num_classes: Number of classes (2)
+        exclude_class: Class to exclude from metric calculation (e.g., 0 for background)
+    
+    Returns:
+        Dictionary containing class-wise and mean metrics
+    """
+    # Concatenate all batches
+    y_true_concat = tf.concat(all_val_true, axis=0)  # Shape: (N, H, W, num_classes)
+    y_pred_concat = tf.concat(all_val_pred, axis=0)  # Shape: (N, H, W, num_classes)
+    
+    # Flatten spatial dimensions: (N*H*W, num_classes)
+    y_true_flat = tf.reshape(y_true_concat, [-1, num_classes])
+    y_pred_flat = tf.reshape(y_pred_concat, [-1, num_classes])
+    
+    # Convert predictions to one-hot (argmax)
+    y_pred_classes = tf.argmax(y_pred_flat, axis=-1)
+    y_pred_onehot = tf.one_hot(y_pred_classes, depth=num_classes)
+    
+    # Convert to numpy for easier computation
+    y_true_np = y_true_flat.numpy()
+    y_pred_np = y_pred_onehot.numpy()
+    
+    metrics = {
+        'dice': {},
+        'precision': {},
+        'recall': {}
+    }
+    
+    classes_to_evaluate = [c for c in range(num_classes) if c != exclude_class]
+    
+    for class_idx in classes_to_evaluate:
+        # Extract binary masks for this class
+        true_class = y_true_np[:, class_idx]
+        pred_class = y_pred_np[:, class_idx]
+        
+        # True Positives, False Positives, False Negatives
+        TP = np.sum((true_class == 1) & (pred_class == 1))
+        FP = np.sum((true_class == 0) & (pred_class == 1))
+        FN = np.sum((true_class == 1) & (pred_class == 0))
+        
+        # Dice Score: 2*TP / (2*TP + FP + FN)
+        dice = (2 * TP) / (2 * TP + FP + FN + 1e-7)
+        
+        # Precision: TP / (TP + FP)
+        precision = TP / (TP + FP + 1e-7)
+        
+        # Recall (Sensitivity): TP / (TP + FN)
+        recall = TP / (TP + FN + 1e-7)
+        
+        metrics['dice'][f'class_{class_idx}'] = float(dice)
+        metrics['precision'][f'class_{class_idx}'] = float(precision)
+        metrics['recall'][f'class_{class_idx}'] = float(recall)
+    
+    # Compute mean metrics (excluding the excluded class)
+    metrics['dice']['mean'] = np.mean([v for v in metrics['dice'].values()])
+    metrics['precision']['mean'] = np.mean([v for v in metrics['precision'].values()])
+    metrics['recall']['mean'] = np.mean([v for v in metrics['recall'].values()])
+    
+    return metrics
+
+###################### Experiment Configuration ######################
+
+class ExperimentConfig:
+    """Configuration for multi-class pix2pix experiment"""
+    
+    def __init__(self, 
+                 variant: int = 1,
+                 preprocessing: str = 'standard',
+                 class_scenario: str = 'binary',
+                 fold_id: int = 0):
+        
+        # Experiment identification
+        self.variant = variant
+        self.preprocessing = preprocessing  # 'standard' or 'zoomed'
+        self.class_scenario = class_scenario  # 'binary'
+        self.fold_id = fold_id
+        
+        # Experiment name
+        self.exp_name = f"exp_{variant}_multiclass_{preprocessing}_{class_scenario}_fold{fold_id}"
+        
+        # Number of classes
+        self.num_classes = 2 if class_scenario == 'binary' else 2
+        
+        # Training hyperparameters
+        self.batch_size = 4
+        self.img_width = 256
+        self.img_height = 256
+        self.epochs = 20
+        
+        # Loss weights
+        self.lambda_seg = 50   # seg loss weight
+        self.lambda_gan = 1     # GAN loss weight
+        
+        # Adaptive loss parameters
+        self.focal_gamma = 0.5           # Focal loss focusing parameter
+        self.beta_threshold = 0.25       # Transition at epoch 15/60
+        self.beta_smoothness = 0.05      # Transition width
+        self.use_focal_alpha = True      # Use class weights in focal loss
+        
+        # Optimizer parameters
+        self.learning_rate = 2e-4
+        self.beta_1 = 0.9
+        
+        # Attention parameters
+        self.attention_weight = 2.0  # How much to upweight lesion regions
+        
+        # Paths
+        self.results_dir = Path(f"results_fold_{fold_id}_var_{variant}_bet_zscore_gm")
+        self.models_dir = self.results_dir / "models" / f"{preprocessing}_{class_scenario}"
+        self.figures_dir = self.results_dir / "figures" / f"{preprocessing}_{class_scenario}" / f"fold_{fold_id}"
+        self.logs_dir = self.results_dir / "logs" / f"{preprocessing}_{class_scenario}" / f"fold_{fold_id}"
+        
+        # Create directories
+        self.models_dir.mkdir(parents=True, exist_ok=True)
+        self.figures_dir.mkdir(parents=True, exist_ok=True)
+        self.logs_dir.mkdir(parents=True, exist_ok=True)
+        
+        # Checkpoint configuration
+        self.checkpoint_dir = self.models_dir / f"fold_{fold_id}"
+        self.checkpoint_dir.mkdir(exist_ok=True)
+        
+        # Class weights directory
+        self.weights_dir = Path("class_weights_gm")
+        self.weights_dir.mkdir(exist_ok=True)
+
+        # Save configuration
+        self.save_config()
+    
+    def save_config(self):
+        """Save experiment configuration to JSON"""
+        config_dict = {
+            'variant': self.variant,
+            'variant_name': 'Multiclass_AttentionD_AdaptiveLoss',
+            'preprocessing': self.preprocessing,
+            'class_scenario': self.class_scenario,
+            'fold_id': self.fold_id,
+            'num_classes': self.num_classes,
+            'batch_size': self.batch_size,
+            'epochs': self.epochs,
+            'lambda_seg': self.lambda_seg,
+            'lambda_gan': self.lambda_gan,
+            'focal_gamma': self.focal_gamma,
+            'beta_threshold': self.beta_threshold,
+            'beta_smoothness': self.beta_smoothness,
+            'learning_rate': self.learning_rate,
+            'beta_1': self.beta_1,
+            'attention_weight': self.attention_weight,
+            'innovation': 'Phase-transitioning segmentation loss (Weighted CE → Focal Loss)'
+        }
+        
+        config_file = self.checkpoint_dir / "config.json"
+        with open(config_file, 'w') as f:
+            json.dump(config_dict, f, indent=2)
+
+
+###################### Model Architecture ######################
+
+def downsample(filters, size, apply_norm=True, use_groupnorm=True):
+    """
+    Downsample block for encoder
+    
+    Args:
+        filters: Number of filters
+        size: Kernel size
+        apply_norm: Whether to apply normalization
+        use_groupnorm: If True, use GroupNorm (better for batch_size=1)
+                       If False, use BatchNorm (original pix2pix)
+    """
+    initializer = tf.random_normal_initializer(0., 0.02)
+    
+    result = tf.keras.Sequential()
+    result.add(
+        tf.keras.layers.Conv2D(
+            filters, size, strides=2, padding='same',
+            kernel_initializer=initializer, use_bias=False
+        )
+    )
+    
+    if apply_norm:
+        if use_groupnorm:
+            # ✅ GroupNorm: Independent of batch size, no train/inference mismatch
+            # Use 32 groups (standard), or filters//8 if filters < 32
+            groups = min(32, max(1, filters // 8))
+            result.add(tf.keras.layers.GroupNormalization(groups=groups))
+        else:
+            # Original BatchNorm (can cause NaN with batch_size=1 at inference)
+            result.add(tf.keras.layers.BatchNormalization(momentum=0.99))
+    
+    result.add(tf.keras.layers.LeakyReLU())
+    
+    return result
+
+
+def build_attention_discriminator(num_classes: int, input_channels: int = 1, 
+                                   attention_weight: float = 2.0, use_groupnorm: bool = True):
+    """
+    Build Attention-Weighted PatchGAN Discriminator
+    
+    Args:
+        num_classes: Number of classes in target mask
+        input_channels: Number of input channels
+        attention_weight: Multiplier for lesion regions (>1.0 upweights lesions)
+        use_groupnorm: If True, use GroupNorm instead of BatchNorm
+    
+    Returns:
+        Discriminator model
+    """
+    initializer = tf.random_normal_initializer(0., 0.02)
+    
+    # Input: FLAIR image
+    inp = tf.keras.layers.Input(
+        shape=[256, 256, input_channels], 
+        name='input_image'
+    )
+    
+    # ✅ Target: Multi-channel one-hot mask
+    tar = tf.keras.layers.Input(
+        shape=[256, 256, num_classes],
+        name='target_mask'
+    )
+    
+    # ✅ Compute spatial attention map from target mask
+    # attention_map: (bs, 256, 256, 1)
+    # Background (class 0) gets weight 1.0, lesions get attention_weight
+    class_indices = tf.argmax(tar, axis=-1, output_type=tf.int32)  # (bs, 256, 256)
+    attention_map = tf.where(
+        class_indices == 0,
+        tf.ones_like(class_indices, dtype=tf.float32),  # Background: weight 1.0
+        tf.ones_like(class_indices, dtype=tf.float32) * attention_weight  # Lesions: upweighted
+    )
+    attention_map = tf.expand_dims(attention_map, axis=-1)  # (bs, 256, 256, 1)
+    
+    # Concatenate input and target
+    x = tf.keras.layers.concatenate([inp, tar])  # (bs, 256, 256, 1+num_classes)
+    
+    # Standard PatchGAN backbone
+    down1 = downsample(64, 4, apply_norm=False, use_groupnorm=use_groupnorm)(x)  # (bs, 128, 128, 64)
+    down2 = downsample(128, 4, use_groupnorm=use_groupnorm)(down1)     # (bs, 64, 64, 128)
+    down3 = downsample(256, 4, use_groupnorm=use_groupnorm)(down2)     # (bs, 32, 32, 256)
+    
+    zero_pad1 = tf.keras.layers.ZeroPadding2D()(down3)  # (bs, 34, 34, 256)
+    conv = tf.keras.layers.Conv2D(
+        512, 4, strides=1,
+        kernel_initializer=initializer,
+        use_bias=False
+    )(zero_pad1)  # (bs, 31, 31, 512)
+    
+    if use_groupnorm:
+        batchnorm1 = tf.keras.layers.GroupNormalization(groups=8)(conv)
+    else:
+        batchnorm1 = tf.keras.layers.BatchNormalization()(conv)
+    leaky_relu = tf.keras.layers.LeakyReLU()(batchnorm1)
+    
+    zero_pad2 = tf.keras.layers.ZeroPadding2D()(leaky_relu)  # (bs, 33, 33, 512)
+    
+    # Output patch predictions
+    patch_output = tf.keras.layers.Conv2D(
+        1, 4, strides=1,
+        kernel_initializer=initializer,
+        name='patch_predictions'
+    )(zero_pad2)  # (bs, 30, 30, 1)
+    
+    # ✅ Apply spatial attention to patch predictions
+    # Downsample attention map to match patch size (256 -> 30)
+    attention_downsampled = tf.keras.layers.AveragePooling2D(
+        pool_size=(9, 9), strides=(8, 8), padding='same'
+    )(attention_map)  # Approximate (bs, 30, 30, 1)
+    
+    # Ensure exact shape match
+    attention_resized = tf.image.resize(
+        attention_downsampled, 
+        [tf.shape(patch_output)[1], tf.shape(patch_output)[2]],
+        method='bilinear'
+    )
+    
+    # Apply attention weighting
+    weighted_output = patch_output * attention_resized
+    
+    return tf.keras.Model(
+        inputs=[inp, tar], 
+        outputs=weighted_output, 
+        name='AttentionDiscriminator'
+    )
+
+
+###################### Beta Scheduling ######################
+
+def smooth_step(x, threshold=0.5, smoothness=0.1):
+    """
+    Smooth step function for phase transition
+    
+    Creates smooth transition around threshold value using sigmoid.
+    
+    Args:
+        x: Current progress (typically epoch / total_epochs)
+        threshold: Center point of transition (e.g., 0.5 for epoch 25/50)
+        smoothness: Width of transition (smaller = sharper, larger = smoother)
+        
+    Returns:
+        Value in [0, 1] representing transition progress
+        - x << threshold: returns ≈ 0
+        - x ≈ threshold: returns ≈ 0.5
+        - x >> threshold: returns ≈ 1
+        
+    Example:
+        epoch_progress = 0.3  # Epoch 15/50
+        beta = smooth_step(0.3, threshold=0.5, smoothness=0.1)
+        # beta ≈ 0.05 (mostly phase 1)
+        
+        epoch_progress = 0.5  # Epoch 25/50
+        beta = smooth_step(0.5, threshold=0.5, smoothness=0.1)
+        # beta ≈ 0.5 (equal mix)
+        
+        epoch_progress = 0.7  # Epoch 35/50
+        beta = smooth_step(0.7, threshold=0.5, smoothness=0.1)
+        # beta ≈ 0.95 (mostly phase 2)
+    """
+    # Sigmoid centered at threshold
+    # (x - threshold) / smoothness controls steepness
+    return tf.sigmoid((x - threshold) / smoothness)
+
+
+def compute_beta_schedule(current_epoch, total_epochs, 
+                          threshold=0.5, smoothness=0.1):
+    """
+    Compute beta value for current epoch
+    
+    Args:
+        current_epoch: Current epoch number (0-indexed)
+        total_epochs: Total number of epochs
+        threshold: Transition center (0.5 = midpoint)
+        smoothness: Transition width
+        
+    Returns:
+        Beta value in [0, 1]
+    """
+    epoch_progress = tf.cast(current_epoch, tf.float32) / tf.cast(total_epochs, tf.float32)
+    beta = smooth_step(epoch_progress, threshold, smoothness)
+    return beta
+
+
+###################### Loss Functions ######################
+
+def unified_focal_loss(y_true, y_pred, gamma=2.0, alpha=None, exclude_class=None):
+    """
+    Unified Focal Loss
+    
+    Focal loss down-weights easy examples and focuses on hard examples.
+    Particularly effective for class imbalance and boundary regions.
+    
+    Args:
+        y_true: Ground truth labels (bs, H, W, num_classes) one-hot encoded
+        y_pred: Predicted probabilities (bs, H, W, num_classes) from softmax
+        gamma: Focusing parameter (default 2.0)
+            - gamma=0: equivalent to cross-entropy
+            - gamma>0: down-weights easy examples
+            - Higher gamma = more focus on hard examples
+        alpha: Per-class balancing weights (num_classes,) - optional, trainable
+            - If None, no additional balancing
+            - If provided, applies per-class weighting like weighted CE
+            
+    Returns:
+        Scalar loss value
+        
+    Formula:
+        FL = -α * (1 - p_t)^γ * log(p_t)
+        where:
+        - p_t is probability of correct class
+        - (1 - p_t)^γ is modulating factor (focal term)
+        - α is class balancing weight
+    """
+    # Clip predictions to avoid log(0)
+    y_pred = tf.clip_by_value(y_pred, 1e-7, 1.0 - 1e-7)
+    
+    # Probability of correct class at each pixel
+    # y_true is one-hot, so this extracts p for the true class
+    p_t = tf.reduce_sum(y_true * y_pred, axis=-1)
+    # Shape: (bs, H, W)
+    
+    # Focal term: (1 - p_t)^gamma
+    # This is small for easy examples (p_t ≈ 1) and large for hard examples (p_t ≈ 0)
+    focal_term = tf.pow(1.0 - p_t, gamma)
+    # Shape: (bs, H, W)
+    
+    # Cross-entropy term: -log(p_t)
+    ce_term = -tf.math.log(p_t)
+    # Shape: (bs, H, W)
+    
+    # Focal loss: focal_term * ce_term
+    focal_loss = focal_term * ce_term
+    # Shape: (bs, H, W)
+    
+    # Optional: Apply alpha balancing (per-class weights)
+    if alpha is not None:
+        # Get weight for true class at each pixel
+        weights_tensor = tf.cast(alpha, dtype=tf.float32)
+        weights_tensor = tf.reshape(weights_tensor, [1, 1, 1, -1])
+        alpha_map = tf.reduce_sum(y_true * weights_tensor, axis=-1)
+        # Shape: (bs, H, W)
+        
+    # Weighted focal
+    # Exclude specific class if specified
+    if exclude_class is not None:
+        class_mask = tf.argmax(y_true, axis=-1)  # (bs, 256, 256)
+        valid_mask = tf.cast(class_mask != exclude_class, tf.float32)
+
+        if alpha is not None:
+            focal_loss = alpha_map * focal_loss * valid_mask
+        else:
+            focal_loss = focal_loss * valid_mask
+
+        return tf.reduce_sum(focal_loss) / (tf.reduce_sum(valid_mask) + 1e-7)
+    else:
+        
+        if alpha is not None:
+            focal_loss = alpha_map * focal_loss
+
+        return tf.reduce_mean(focal_loss)
+
+def unified_focal_dice_loss(y_true, y_pred, gamma=0.5, delta=0.6, alpha=None, exclude_class=None):
+    """
+    Unified Focal Loss - Dice-based
+    
+    Combines Dice coefficient with precision-recall focal weighting.
+    Best for imbalanced multi-class segmentation with small structures.
+    
+    Args:
+        y_true: Ground truth one-hot (bs, H, W, num_classes)
+        y_pred: Predicted probabilities (bs, H, W, num_classes)
+        gamma: Focusing parameter for Dice component (default 0.5)
+               - gamma=0: equivalent to Dice loss
+               - gamma>0: focuses on hard examples
+        delta: Weight for precision-recall component (0-1, default 0.6)
+               - Controls emphasis on boundary regions
+        alpha: Per-class weights (num_classes,) - optional
+        exclude_class: Class index to exclude from loss
+    
+    Returns:
+        Scalar loss value
+        
+    Formula:
+        UFL = (1 - Dice)^gamma * (1 - precision * recall)^delta
+        Focuses on hard examples and boundary regions
+    """
+    smooth = 1e-6
+    y_pred = tf.clip_by_value(y_pred, 1e-7, 1.0 - 1e-7)
+    num_classes = tf.shape(y_pred)[-1]
+    
+    unified_losses = []
+    
+    for class_idx in range(num_classes if isinstance(num_classes, int) else y_pred.shape[-1]):
+        # Skip excluded class
+        if exclude_class is not None and class_idx == exclude_class:
+            continue
+
+        y_true_class = y_true[..., class_idx]
+        y_pred_class = y_pred[..., class_idx]
+        
+        # Flatten for calculations
+        y_true_f = tf.reshape(y_true_class, [-1])
+        y_pred_f = tf.reshape(y_pred_class, [-1])
+        
+        # True positives, false positives, false negatives
+        tp = tf.reduce_sum(y_true_f * y_pred_f)
+        fp = tf.reduce_sum((1.0 - y_true_f) * y_pred_f)
+        fn = tf.reduce_sum(y_true_f * (1.0 - y_pred_f))
+        
+        # Precision and recall
+        precision = (tp + smooth) / (tp + fp + smooth)
+        recall = (tp + smooth) / (tp + fn + smooth)
+        
+        # Dice coefficient
+        dice = (2.0 * tp + smooth) / (2.0 * tp + fp + fn + smooth)
+        
+        # Unified focal loss: focuses on hard examples and boundary regions
+        # (1 - dice)^gamma: focuses on classes with low Dice (hard examples)
+        # (1 - precision * recall)^delta: focuses on boundary regions
+        unified_loss_class = tf.pow(1.0 - dice, gamma) * tf.pow(1.0 - precision * recall, delta)
+        
+        # Apply class weights
+        if alpha is not None:
+            unified_loss_class = unified_loss_class * tf.cast(alpha[class_idx], tf.float32)
+        
+        unified_losses.append(unified_loss_class)
+    
+    # Stack and mean across classes (excluding the skipped class)
+    total_loss = tf.reduce_mean(tf.stack(unified_losses))
+    
+    return total_loss
+
+
+def weighted_categorical_crossentropy(y_true, y_pred, class_weights, exclude_class=None):
+    """
+    Weighted categorical cross-entropy loss
+    
+    Args:
+        y_true: (bs, 256, 256, num_classes) one-hot encoded
+        y_pred: (bs, 256, 256, num_classes) softmax probabilities
+        class_weights: (num_classes,) weight per class
+        exclude_class: Optional int, class index to exclude from loss (e.g., 2 for CSF)
+    
+    Returns:
+        Scalar loss value
+    """
+    # Clip predictions to prevent log(0)
+    y_pred = tf.clip_by_value(y_pred, 1e-7, 1.0 - 1e-7)
+    
+    # Cross-entropy per pixel: -sum(y_true * log(y_pred))
+    ce = -tf.reduce_sum(y_true * tf.math.log(y_pred), axis=-1)  # (bs, 256, 256)
+    
+    # Apply class weights
+    # class_weights shape: (num_classes,) -> (1, 1, 1, num_classes) for broadcasting
+    weights_tensor = tf.cast(class_weights, dtype=tf.float32)
+    weights_tensor = tf.reshape(weights_tensor, [1, 1, 1, -1])
+    
+    # Weight map: (bs, 256, 256)
+    pixel_weights = tf.reduce_sum(y_true * weights_tensor, axis=-1)
+    
+    # Weighted cross-entropy
+    # Exclude specific class if specified
+    if exclude_class is not None:
+        class_mask = tf.argmax(y_true, axis=-1)  # (bs, 256, 256)
+        valid_mask = tf.cast(class_mask != exclude_class, tf.float32)
+        weighted_ce = ce * pixel_weights * valid_mask
+        return tf.reduce_sum(weighted_ce) / (tf.reduce_sum(valid_mask) + 1e-7)
+    else:
+        weighted_ce = ce * pixel_weights
+        return tf.reduce_mean(weighted_ce)
+
+# Combined Adaptive Loss #
+
+def adaptive_segmentation_loss(y_true, y_pred, class_weights, beta, 
+                               focal_gamma=0.5, use_focal_alpha=True,
+                               exclude_class=None):
+    """
+    Adaptive segmentation loss with smooth phase transition
+    
+    Combines weighted cross-entropy (phase 1) and focal loss (phase 2)
+    based on beta parameter.
+    
+    Args:
+        y_true: Ground truth (bs, H, W, num_classes) one-hot
+        y_pred: Predictions (bs, H, W, num_classes) softmax probabilities
+        class_weights: Trainable class weights (num_classes,)
+        beta: Transition parameter [0, 1]
+            - beta=0: pure weighted CE (early training)
+            - beta=1: pure focal loss (late training)
+        focal_gamma: Focusing parameter for focal loss (default 0.5)
+        use_focal_alpha: Whether to use class_weights as focal alpha
+        
+    Returns:
+        seg_loss: Combined loss
+        wcce_loss: Weighted CE component (for monitoring)
+        focal_loss: Focal loss component (for monitoring)
+        
+    Phase Behavior:
+        Epochs 1-10: beta ≈ 0 → Weighted CE dominates
+            - Learns basic class separation
+            - Benefits from explicit class weighting
+        
+        Epochs 10-20: beta transitions 0 → 1
+            - Smooth change in loss landscape
+            - Gradual shift in training dynamics
+        
+        Epochs 20-60: beta ≈ 1 → Focal loss dominates
+            - Focuses on hard examples
+            - Refines boundaries and difficult regions
+    """
+    # Compute Phase 1 loss: Weighted Cross-Entropy
+    wcce_loss = weighted_categorical_crossentropy(y_true, y_pred, class_weights, exclude_class=exclude_class)
+
+    # Compute Phase 2 loss: Focal Loss
+    focal_alpha = class_weights if use_focal_alpha else None
+    focal_loss = unified_focal_dice_loss(y_true, y_pred, 
+                                       gamma=focal_gamma, 
+                                       alpha=focal_alpha,
+                                       exclude_class=exclude_class)
+    
+    # Adaptive combination based on beta
+    # beta=0: (1-0)*wce + 0*focal = wce (phase 1)
+    # beta=1: (1-1)*wce + 1*focal = focal (phase 2)
+    # beta=0.5: 0.5*wce + 0.5*focal = equal mix (transition)
+    seg_loss = (1.0 - beta) * wcce_loss + beta * focal_loss
+    
+    return seg_loss, wcce_loss, focal_loss
+
+
+# Binary cross-entropy for GAN loss
+bce_loss = tf.keras.losses.BinaryCrossentropy(from_logits=True)
+
+
+def generator_loss(disc_generated_output, gen_output, target_onehot, 
+                  class_weights, beta, lambda_gan=1, lambda_seg=100,
+                  focal_gamma=2.0, use_focal_alpha=True):
+    """
+    Generator loss: GAN loss + Weighted CCE
+    
+    Args:
+        disc_generated_output: Discriminator output for generated mask
+        gen_output: Generated mask (bs, 256, 256, num_classes) softmax
+        target_onehot: Target mask (bs, 256, 256, num_classes) one-hot
+        class_weights: (num_classes,) weight per class
+        beta: Phase transition parameter [0, 1]
+        lambda_gan: Weight for GAN loss (default 1.0)
+        lambda_seg: Weight for segmentation loss (default 100.0)
+        focal_gamma: Focal loss focusing parameter (default 2.0)
+        use_focal_alpha: Whether to use class weights in focal loss
+    
+    Returns:
+        total_gen_loss, gan_loss, seg_loss
+    """
+    # GAN loss: fool the discriminator
+    gan_loss = bce_loss(
+        tf.ones_like(disc_generated_output), 
+        disc_generated_output
+    )
+    
+    # Weighted categorical cross-entropy
+    # seg_loss = weighted_categorical_crossentropy(target_onehot, gen_output, class_weights)
+    seg_loss, wcce_loss, focal_loss = adaptive_segmentation_loss(target_onehot, gen_output, class_weights, beta, 
+                               focal_gamma=focal_gamma, use_focal_alpha=True)
+    
+    # Total generator loss
+    total_gen_loss = (lambda_gan * gan_loss) + (lambda_seg * seg_loss)
+    
+    return total_gen_loss, gan_loss, seg_loss, wcce_loss, focal_loss
+
+
+def discriminator_loss(disc_real_output, disc_generated_output):
+    """
+    Discriminator loss: distinguish real from fake
+    
+    Args:
+        disc_real_output: Discriminator output for real mask
+        disc_generated_output: Discriminator output for generated mask
+    
+    Returns:
+        total_disc_loss
+    """
+    real_loss = bce_loss(
+        tf.ones_like(disc_real_output), 
+        disc_real_output
+    )
+    
+    generated_loss = bce_loss(
+        tf.zeros_like(disc_generated_output), 
+        disc_generated_output
+    )
+    
+    total_disc_loss = real_loss + generated_loss
+    
+    return total_disc_loss
+
+
+###################### Training Functions ######################
+
+@tf.function
+def train_step(input_image, target_onehot, generator, discriminator, 
+               generator_optimizer, discriminator_optimizer, 
+               class_weights_np, beta_value,
+               lambda_gan, lambda_seg, focal_gamma, use_focal_alpha):
+    """
+    Single training step
+    
+    Args:
+        input_image: Input FLAIR (bs, 256, 256, 1) in [-1, 1]
+        target_onehot: Target mask (bs, 256, 256, num_classes) one-hot
+        generator, discriminator, optimizers
+        class_weights: (num_classes,) weight per class
+        beta_value: Current beta for phase transition
+        lambda_gan, lambda_seg: Loss weights
+        focal_gamma: Focal loss parameter
+        use_focal_alpha: Whether to use class weights in focal
+    
+    Returns:
+        gen_total_loss, gen_gan_loss, gen_seg_loss, disc_loss
+    """
+    with tf.GradientTape() as gen_tape, tf.GradientTape() as disc_tape:
+        # Generate output
+        gen_output = generator(input_image, training=True)
+        
+        # Discriminator outputs
+        disc_real_output = discriminator(
+            [input_image, target_onehot], training=True
+        )
+        disc_generated_output = discriminator(
+            [input_image, gen_output], training=True
+        )
+        
+        # Generator loss (adaptive)
+        gen_total_loss, gen_gan_loss, gen_seg_loss, gen_wce_loss, gen_focal_loss = \
+            generator_loss(
+                disc_generated_output, gen_output, target_onehot, 
+                class_weights_np, beta_value, lambda_gan, lambda_seg,
+                focal_gamma, use_focal_alpha
+            )
+
+        # Discriminator loss
+        disc_loss = discriminator_loss(disc_real_output, disc_generated_output)
+    
+    # Calculate gradients
+    generator_gradients = gen_tape.gradient(
+        gen_total_loss, generator.trainable_variables
+    )
+    discriminator_gradients = disc_tape.gradient(
+        disc_loss, discriminator.trainable_variables
+    )
+    
+    # Apply gradients
+    generator_optimizer.apply_gradients(
+        zip(generator_gradients, generator.trainable_variables)
+    )
+    discriminator_optimizer.apply_gradients(
+        zip(discriminator_gradients, discriminator.trainable_variables)
+    )
+    
+    # return gen_total_loss, gen_gan_loss, gen_seg_loss, disc_loss
+    return (gen_total_loss, gen_gan_loss, gen_seg_loss, gen_wce_loss, 
+            gen_focal_loss, disc_loss, class_weights_np)
+
+
+def generate_and_save_images(generator, test_input, test_target, 
+                            epoch, save_path, num_classes):
+    """
+    Generate predictions and save visualization
+    
+    Args:
+        generator: Generator model
+        test_input: Test input image (bs, 256, 512, 1)
+        test_target: Test target mask (bs, 256, 256)
+        epoch: Current epoch number
+        save_path: Path to save figure
+        num_classes: Number of classes
+    """
+    for ik in range(test_input.numpy().shape[0]):
+        # Extract FLAIR
+        flair_normalized = test_input[ik, :, :256, :]
+        flair_normalized = tf.expand_dims(flair_normalized, axis=0)
+        
+        # Generate prediction
+        prediction_softmax = generator(flair_normalized, training=False)
+        
+        # Convert to class labels
+        pred_classes = tf.argmax(prediction_softmax, axis=-1).numpy()
+        target_mask = test_target[ik].numpy()
+        
+        # Create figure
+        plt.figure(figsize=(20, 5))
+        
+        # Input FLAIR
+        plt.subplot(1, 5, 1)
+        plt.title('Input FLAIR')
+        plt.imshow(flair_normalized[0, :, :, 0], cmap='gray')
+        plt.axis('off')
+        
+        # Ground truth
+        plt.subplot(1, 5, 2)
+        plt.title('Ground Truth')
+        plt.imshow(target_mask, cmap='jet', vmin=0, vmax=num_classes-1)
+        plt.colorbar()
+        plt.axis('off')
+        
+        # Prediction
+        plt.subplot(1, 5, 3)
+        plt.title('Predicted Classes')
+        plt.imshow(pred_classes[0], cmap='jet', vmin=0, vmax=num_classes-1)
+        plt.colorbar()
+        plt.axis('off')
+        
+        # Class probabilities for most confident prediction
+        plt.subplot(1, 5, 4)
+        plt.title('Max Probability')
+        max_prob = tf.reduce_max(prediction_softmax[0], axis=-1).numpy()
+        plt.imshow(max_prob, cmap='viridis', vmin=0, vmax=1)
+        plt.colorbar()
+        plt.axis('off')
+        
+        # Difference map
+        plt.subplot(1, 5, 5)
+        plt.title('Error Map (Red=Wrong)')
+        error_map = (pred_classes[0] != target_mask).astype(float)
+        plt.imshow(error_map, cmap='Reds', vmin=0, vmax=1)
+        plt.colorbar()
+        plt.axis('off')
+        
+        plt.tight_layout()
+        plt.savefig(save_path / f'epoch_{epoch:03d}_{ik+1}.png', dpi=300, bbox_inches='tight')
+        plt.close()
+
+
+###################### Main Training Function ######################
+
+def train_experiment_with_metrics(config: ExperimentConfig):
+    """
+    Main training function for multi-class pix2pix with attention on discriminator and adaptive loss
+    
+    Args:
+        config: ExperimentConfig object
+    """
+    print("\n" + "="*70)
+    print(f"TRAINING EXPERIMENT: {config.exp_name}")
+    print("="*70)
+    print(f"Variant: {config.variant} (Baseline + AttentionD + Adaptive Loss)")
+    print(f"Preprocessing: {config.preprocessing}")
+    print(f"Class scenario: {config.class_scenario} ({config.num_classes} classes)")
+    print(f"Fold: {config.fold_id}")
+    print(f"Epochs: {config.epochs}")
+    print(f"Batch size: {config.batch_size}")
+    print(f"Loss weights: λ_SEG={config.lambda_seg}, λ_GAN={config.lambda_gan}")
+    print(f"Focal gamma: {config.focal_gamma}")
+    print(f"Attention weight: {config.attention_weight}")
+    print("="*70 + "\n")
+
+    # Check initial GPU memory
+    get_gpu_memory_info()
+    
+    # Initialize data loader
+    data_config = DataConfig()
+    data_loader = P1DataLoader(data_config)
+    
+    # Load datasets
+    print("Loading training data...")
+    train_dataset = data_loader.create_dataset_for_fold(
+        fold_id=config.fold_id,
+        split='train',
+        preprocessing=config.preprocessing,
+        class_scenario=config.class_scenario,
+        batch_size=config.batch_size,
+        shuffle=True
+    )
+    
+    print("Loading validation data...")
+    val_dataset = data_loader.create_dataset_for_fold(
+        fold_id=config.fold_id,
+        split='val',
+        preprocessing=config.preprocessing,
+        class_scenario=config.class_scenario,
+        batch_size=config.batch_size,
+        shuffle=False
+    )
+    
+    # Get dataset sizes
+    # Note: from_generator pipelines always report cardinality as INFINITE (-1)
+    # even with .cache(), so we derive the batch count from the slice list instead.
+    # We iterate once here; this also warms the in-memory cache so epoch 1 is fast.
+    print("Warming dataset cache (first pass over data — subsequent epochs use RAM)...")
+    train_size = sum(1 for _ in train_dataset)
+    val_size   = sum(1 for _ in val_dataset)
+    # ⚠️  Do NOT rebuild the datasets here — that would create new generators and
+    #     throw away the cache we just populated.
+    
+    print(f"Training samples (batches): {train_size}")
+    print(f"Validation samples (batches): {val_size}\n")
+    
+    # Compute or load class weights
+    print("Computing class weights from training data...")
+    try:
+        class_weights = load_class_weights(
+            config.fold_id, config.class_scenario, 
+            config.preprocessing, config.weights_dir
+        )
+        print("✅ Loaded pre-computed class weights")
+    except FileNotFoundError:
+        print("Computing class weights (this may take a few minutes)...")
+        results = compute_and_save_class_weights(
+            config.fold_id, config.class_scenario, 
+            config.preprocessing, str(config.weights_dir)
+        )
+        class_weights = np.array(results['class_weights'], dtype=np.float32)
+    
+    print(f"Class weights: {class_weights}")
+
+    # Build models
+    print("\n🏗️  Building models...")
+    generator = build_unet_3class(input_shape=(256, 256, 1), num_classes=config.num_classes)
+    discriminator = build_attention_discriminator(
+        config.num_classes, 
+        input_channels=1,
+        attention_weight=config.attention_weight,
+        use_groupnorm=True  # ✅ Consistent with generator
+    )
+    
+    print(f"Generator parameters: {generator.count_params():,}")
+    print(f"Discriminator parameters: {discriminator.count_params():,}\n")
+    
+    # Optimizers
+    generator_optimizer = tf.keras.optimizers.legacy.Adam(
+        config.learning_rate, beta_1=config.beta_1
+    )
+    discriminator_optimizer = tf.keras.optimizers.legacy.Adam(
+        config.learning_rate, beta_1=config.beta_1
+    )
+    
+    # Initialize optimizer variables
+    # CRITICAL: Build optimizer variables by calling them once with dummy data
+    # This prevents the "tf.function only supports singleton tf.Variables" error
+    print("Initializing optimizer variables...")
+    dummy_input = tf.zeros((1, 256, 256, 1))
+    dummy_target = tf.zeros((1, 256, 256, config.num_classes))
+    
+    with tf.GradientTape() as gen_tape, tf.GradientTape() as disc_tape:
+        gen_output = generator(dummy_input, training=True)
+        disc_output = discriminator([dummy_input, dummy_target], training=True)
+        # Dummy losses
+        dummy_gen_loss = tf.reduce_mean(gen_output)
+        dummy_disc_loss = tf.reduce_mean(disc_output)
+
+    # Apply dummy gradients to build optimizer variables
+    # Don't include class_weights since they're not trainable
+    gen_grads = gen_tape.gradient(dummy_gen_loss, generator.trainable_variables)
+    disc_grads = disc_tape.gradient(dummy_disc_loss, discriminator.trainable_variables)
+    
+    generator_optimizer.apply_gradients(zip(gen_grads, generator.trainable_variables))
+    discriminator_optimizer.apply_gradients(zip(disc_grads, discriminator.trainable_variables))
+    print("✅ Optimizer variables initialized\n")
+    
+    # Checkpoint
+    checkpoint = tf.train.Checkpoint(
+        generator_optimizer=generator_optimizer,
+        discriminator_optimizer=discriminator_optimizer,
+        generator=generator,
+        discriminator=discriminator
+    )
+    
+    checkpoint_prefix = config.checkpoint_dir / "ckpt"
+    manager = tf.train.CheckpointManager(
+        checkpoint, config.checkpoint_dir, max_to_keep=1
+    )
+    
+    if manager.latest_checkpoint:
+        checkpoint.restore(manager.latest_checkpoint)
+        print(f"✅ Restored from checkpoint: {manager.latest_checkpoint}\n")
+    else:
+        print("Starting training from scratch\n")
+
+    # Load pretrained models:    
+    generator_weights_path = f"{config.checkpoint_dir}/best_dice_generator.h5"
+    if os.path.isfile(generator_weights_path):
+        generator.load_weights(generator_weights_path)
+    
+    discriminator_weights_path = f"{config.checkpoint_dir}/best_dice_discriminator.h5"
+    if os.path.isfile(discriminator_weights_path):
+        discriminator.load_weights(discriminator_weights_path)
+    
+    # Get example for visualization
+    skip_n = 1 # min(100 // config.batch_size, val_size - 1)
+    example_paired, example_target, _, _ = next(iter(val_dataset.skip(skip_n).take(20)))
+    
+    print("Initializing metrics computer...")
+    if config.num_classes == 2:
+        class_names = ['Background', 'Specialized_GM']
+    else:
+        raise FileNotFoundError
+
+    # Training history
+    history = {
+        'gen_total_loss': [],
+        'gen_gan_loss': [],
+        'gen_seg_loss': [],
+        'gen_wce_loss': [],
+        'gen_focal_loss': [],
+        'disc_loss': [],
+        'val_loss': [],
+        'beta_value': [],
+        'val_metrics': []
+    }
+    
+    # Training loop
+    best_val_loss = float('inf')
+    best_val_dice = 0.0
+    exclude_class = None    # Exclude class !
+    
+    try:
+        for epoch in range(config.epochs):
+            start_time = time.time()
+            
+            # Compute beta for this epoch
+            beta_value = compute_beta_schedule(
+                epoch, config.epochs, 
+                config.beta_threshold, config.beta_smoothness
+            )
+
+            # Training metrics
+            epoch_gen_total_loss = []
+            epoch_gen_gan_loss = []
+            epoch_gen_seg_loss = []
+            epoch_gen_wce_loss = []
+            epoch_gen_focal_loss = []
+            epoch_disc_loss = []
+            
+            # Training loop
+
+            # Update learning rate based on epoch
+            new_lr_1 = config.learning_rate * ((1-(7/8)*beta_value))  # Exponential decay based on beta (based on switching on focal loss)
+            new_lr_2 = config.learning_rate * ((1-(1-0.5e-2)*(epoch / config.epochs)))  # Steadily decay from 2e-4 to 1e-6
+            new_lr = min(new_lr_1, new_lr_2)
+            generator_optimizer.learning_rate.assign(new_lr)
+            discriminator_optimizer.learning_rate.assign(new_lr)
+
+            lambda_GAN = config.lambda_gan*(1-beta_value.numpy()).astype(np.float64)
+            print(f"\nEpoch {epoch+1}/{config.epochs} (β={beta_value.numpy():.4f}) (λ_GAN={lambda_GAN:.4f}) (lr={new_lr:.6f})")
+            train_bar = tqdm(train_dataset, total=train_size, desc="Training")
+            
+            for paired_input, target_mask, patient_id_tensor, slice_num_tensor in train_bar:
+
+                patient_id = patient_id_tensor.numpy()[0].decode('utf-8')  # batch dim + bytes→str
+                slice_num  = int(slice_num_tensor.numpy()[0])
+
+                # ✅ Prepare inputs: normalize FLAIR + one-hot encode target
+                flair_normalized, target_onehot = prepare_inputs(
+                    paired_input, target_mask, config.num_classes
+                )
+                
+                # Train step
+                gen_total, gen_gan, gen_seg, gen_wce, gen_focal, disc, cw = train_step(
+                    flair_normalized, target_onehot,
+                    generator, discriminator,
+                    generator_optimizer, discriminator_optimizer,
+                    class_weights, beta_value,
+                    config.lambda_gan, config.lambda_seg, 
+                    config.focal_gamma, config.use_focal_alpha
+                )
+                
+                epoch_gen_total_loss.append(gen_total.numpy())
+                epoch_gen_gan_loss.append(gen_gan.numpy())
+                epoch_gen_seg_loss.append(gen_seg.numpy())
+                epoch_gen_wce_loss.append(gen_wce.numpy())
+                epoch_gen_focal_loss.append(gen_focal.numpy())
+                epoch_disc_loss.append(disc.numpy())
+                
+                # Update progress bar
+                train_bar.set_postfix({
+                    'G_loss': f"{gen_total.numpy():.4f}",
+                    'D_loss': f"{disc.numpy():.4f}",
+                    'SEG': f"{gen_seg.numpy():.4f}"
+                })
+            
+            # Calculate epoch averages
+            avg_gen_total = np.mean(epoch_gen_total_loss)
+            avg_gen_gan = np.mean(epoch_gen_gan_loss)
+            avg_gen_seg = np.mean(epoch_gen_seg_loss)
+            avg_gen_wce = np.mean(epoch_gen_wce_loss)
+            avg_gen_focal = np.mean(epoch_gen_focal_loss)
+            avg_disc = np.mean(epoch_disc_loss)
+            
+            history['gen_total_loss'].append(avg_gen_total)
+            history['gen_gan_loss'].append(avg_gen_gan)
+            history['gen_seg_loss'].append(avg_gen_seg)
+            history['gen_wce_loss'].append(avg_gen_wce)
+            history['gen_focal_loss'].append(avg_gen_focal)
+            history['disc_loss'].append(avg_disc)
+            history['beta_value'].append(float(beta_value.numpy()))
+            
+            # Validation
+            val_losses = []
+            all_val_true = []
+            all_val_pred = []
+            
+            for val_paired, val_target, patient_id_tensor, slice_num_tensor in val_dataset:
+                try:
+
+                    patient_id = patient_id_tensor.numpy()[0].decode('utf-8')  # batch dim + bytes→str
+                    slice_num  = int(slice_num_tensor.numpy()[0])
+
+                    val_flair_norm, val_target_onehot = prepare_inputs(
+                        val_paired, val_target, config.num_classes
+                    )
+
+                    val_pred = generator(val_flair_norm, training=False)  # ✅ Now safe!
+                    
+                    val_seg_loss, _, _ = adaptive_segmentation_loss(
+                        val_target_onehot, val_pred, class_weights, 
+                        beta_value, focal_gamma=config.focal_gamma, exclude_class=exclude_class
+                    )
+
+                    # Store true and prediction values for final metrics calculation
+                    all_val_true.append(val_target_onehot)
+                    all_val_pred.append(val_pred)
+                    
+                    if not tf.math.is_nan(val_seg_loss):
+                        val_losses.append(val_seg_loss.numpy())
+                except:
+                    continue
+            
+
+            if len(val_losses) > 0:
+                avg_val_loss = np.mean(val_losses)
+                history['val_loss'].append(avg_val_loss)
+                
+                # Compute class-wise metrics
+                val_metrics = compute_classwise_metrics(
+                    all_val_true, all_val_pred, 
+                    config.num_classes#, exclude_class=exclude_class
+                )
+                history['val_metrics'].append(val_metrics)
+                
+                # Print validation results
+                epoch_time = time.time() - start_time
+                print(f"\n{'='*70}")
+                print(f"Epoch {epoch+1}/{config.epochs} Summary (Time: {epoch_time:.2f}s)")
+                print(f"{'='*70}")
+                print(f"Training Losses:")
+                print(f"  Generator Total: {avg_gen_total:.4f} | GAN: {avg_gen_gan:.4f} | SEG: {avg_gen_seg:.4f}")
+                print(f"  WCE: {avg_gen_wce:.4f} | Focal: {avg_gen_focal:.4f} | Discriminator: {avg_disc:.4f}")
+                print(f"\nValidation Loss: {avg_val_loss:.4f}")
+                print(f"\nClass-wise Dice Scores:")
+                for class_name, dice_val in val_metrics['dice'].items():
+                    if class_name != 'mean':
+                        print(f"  {class_name}: {dice_val:.4f}")
+                        if class_name == f"class_{config.num_classes -1}":
+                            gm_val_dice = dice_val
+                print(f"  Mean Dice: {val_metrics['dice']['mean']:.4f}")
+                print(f"\nClass-wise Precision:")
+                for class_name, prec_val in val_metrics['precision'].items():
+                    if class_name != 'mean':
+                        print(f"  {class_name}: {prec_val:.4f}")
+                print(f"  Mean Precision: {val_metrics['precision']['mean']:.4f}")
+                print(f"\nClass-wise Recall:")
+                for class_name, rec_val in val_metrics['recall'].items():
+                    if class_name != 'mean':
+                        print(f"  {class_name}: {rec_val:.4f}")
+                print(f"  Mean Recall: {val_metrics['recall']['mean']:.4f}")
+                print(f"{'='*70}\n")
+                
+                # Save best model based on validation loss
+                overal_val_performance = 0.9 * gm_val_dice + 0.1 * (1-10*avg_val_loss)
+                if overal_val_performance > best_val_dice and beta_value.numpy() > 0.9:
+                    best_val_dice = overal_val_performance
+                    generator.save_weights(f"{config.checkpoint_dir}/best_dice_generator.h5")
+                    discriminator.save_weights(f"{config.checkpoint_dir}/best_dice_discriminator.h5")
+                    print(f"✓ Best model saved (performance: {best_val_dice:.4f})")
+            else:
+                print("Warning: No valid validation batches")
+                history['val_loss'].append(float('nan'))
+                history['val_metrics'].append({})
+            
+            # Print epoch summary
+            epoch_time = time.time() - start_time
+            print(f"Epoch {epoch+1} Summary:")
+            print(f"  Gen Total Loss: {avg_gen_total:.4f}")
+            print(f"  Gen GAN Loss: {avg_gen_gan:.4f}")
+            print(f"  Gen Seg Loss: {avg_gen_seg:.4f}")
+            print(f"    - WCE component: {avg_gen_wce:.4f}")
+            print(f"    - Focal component: {avg_gen_focal:.4f}")
+            print(f"  Disc Loss: {avg_disc:.4f}")
+            print(f"  Val Loss: {avg_val_loss:.4f}")
+            print(f"  Beta: {beta_value.numpy():.4f}")
+            print(f"  Time: {epoch_time:.2f}s")
+
+            # Save checkpoint
+            if (epoch + 1) % 5 == 0 and False:
+                manager.save()
+                print(f"  💾 Saved checkpoint")
+            
+            # Generate sample images
+            if (epoch + 1) % 5 == 0 or epoch == 0 or True:
+                generate_and_save_images(
+                    generator, example_paired, example_target,
+                    epoch + 1, config.figures_dir, config.num_classes
+                )
+                print(f"  📊 Saved visualization")
+        
+        # # Save final model
+        # final_model_path = config.checkpoint_dir / "final_model.h5"
+        # generator.save(final_model_path)
+        # print(f"\n✅ Training complete! Final model saved to {final_model_path}")
+        
+        # Save history
+        history_serializable = {
+            key: [float(val) if isinstance(val, (int, float, np.number)) else val 
+                  for val in values]
+            for key, values in history.items()
+        }
+        
+        history_file = config.checkpoint_dir / "history.json"
+        with open(history_file, 'w') as f:
+            json.dump(history_serializable, f, indent=2)
+        
+        return history, history_file
+    
+    finally:
+        # CRITICAL: Always cleanup, even if training fails
+        # This runs whether training succeeds or fails
+        print("\n🧹 Cleaning up resources...")
+
+        # Delete models explicitly to break references
+        try:
+            del generator
+            del discriminator
+            del generator_optimizer
+            del discriminator_optimizer
+            del checkpoint
+            del manager
+            del train_dataset
+            del val_dataset
+            # class_weights don't need deletion (they're constants, not variables)
+            print("✅ Deleted model objects")
+        except Exception as e:
+            print(f"⚠️  Error deleting objects: {e}")
+        
+        # Clear GPU memory
+        clear_gpu_memory()
+        
+        # Check final GPU memory
+        get_gpu_memory_info()
+
+
+###################### Main Execution ######################
+
+if __name__ == "__main__":
+    # Example: Train multi-class model for 4-class, standard preprocessing, fold 0
+    config = ExperimentConfig(
+        variant=1,
+        preprocessing='standard',
+        class_scenario='binary',
+        fold_id=0
+    )
+    
+    history, history_path = train_experiment_with_metrics(config)
+    
+    print("\n" + "="*70)
+    print("EXPERIMENT COMPLETE")
+    print("="*70)

models/for_GM/model_training_scripts/p1_predict_new_data_gm.py

@@ -0,0 +1,477 @@
+"""
+P1 Article - Prediction Script for New Data (No Ground Truth)
+
+Predicts specialized Gray Matter segmentation masks for new HC/MS cohort patients.
+
+Outputs per patient:
+  - {patient_id}_gm_mask.nii.gz   → binary gm mask (class 1)
+
+Developer:
+Mahdi Bashiri Bawil
+"""
+
+import tensorflow as tf
+import os
+import numpy as np
+from pathlib import Path
+from tqdm import tqdm
+import nibabel as nib
+import argparse
+
+print("TensorFlow Version:", tf.__version__)
+
+
+###################### GPU Configuration ######################
+
+physical_devices = tf.config.list_physical_devices('GPU')
+if physical_devices:
+    try:
+        for device in physical_devices:
+            tf.config.experimental.set_memory_growth(device, True)
+        print(f"✅ GPU memory growth enabled  ({len(physical_devices)} GPU(s) found)")
+    except RuntimeError as e:
+        print(f"GPU configuration error: {e}")
+else:
+    print("⚠️  No GPU detected – inference will run on CPU")
+
+
+###################### Configuration ######################
+
+class PredictConfig:
+    """
+    All settings for the new-data prediction pipeline.
+    Edit the values in __init__ or pass overrides via the CLI at the bottom.
+    """
+
+    def __init__(
+        self,
+        # ── Model settings ──────────────────────────────────────────────────
+        variant: int = 1,
+        preprocessing: str = "standard",
+        class_scenario: str = "binary",
+        architecture_name: str = "unet",
+        model_name: str = "best_dice_model.h5",
+        fold_id: int = 0,
+
+        # ── Slice range (1-based, inclusive) ────────────────────────────────
+        # Only slices within [slice_start, slice_end] are fed to the model.
+        # All other slices receive empty (zero) masks.
+        slice_start: int = 1,
+        slice_end: int = 20,
+
+        # ── Data root ───────────────────────────────────────────────────────
+        data_root: str = "/mnt/d/TEMP_P4",
+
+        # ── Post-processing ─────────────────────────────────────────────────
+        apply_postprocess: bool = False,
+        min_object_size: int = 5,
+        closing_kernel_size: int = 2,
+    ):
+        # Experiment
+        self.variant = variant
+        self.fold_id = fold_id
+        self.preprocessing = preprocessing
+        self.class_scenario = class_scenario
+        self.architecture_name = architecture_name
+        self.model_name = model_name
+
+        # Classes
+        self.num_classes = 2
+        self.class_names = ["Background", "Specialized_GM"]
+
+        # Image dimensions (must match training)
+        self.img_width = 256
+        self.img_height = 256
+
+        # Slice range (1-based, inclusive)
+        self.slice_start = slice_start
+        self.slice_end = slice_end
+
+        # Post-processing
+        self.apply_postprocess = apply_postprocess
+        print(f'\n \t apply_postprocess: {apply_postprocess} \n')
+        self.min_object_size = min_object_size
+        self.closing_kernel_size = closing_kernel_size
+
+        # Data root
+        self.data_root = Path(data_root)
+
+        # Cohort sub-directories (relative to data_root)
+        self.cohorts = {
+            "HC": self.data_root / "HC_COHORT_PREP_prepared" / "FLAIR_Preprocessed",
+            "MS": self.data_root / "MS_COHORT_PREP_prepared" / "FLAIR_Preprocessed",
+        }
+
+        # Model path
+        self.results_dir = Path(
+            f"results_fold_{fold_id}_var_{variant}_bet_zscore_gm"   # adjust if you use a single fold
+        )
+        self.models_dir = self.results_dir / "models" / f"{preprocessing}_{class_scenario}"
+
+        # ── Print summary ────────────────────────────────────────────────────
+        print(f"\n{'='*70}")
+        print("PREDICTION CONFIGURATION (New Data)")
+        print(f"{'='*70}")
+        print(f"  Variant          : {self.variant}")
+        print(f"  Fold             : {self.fold_id}")
+        print(f"  Preprocessing    : {self.preprocessing}")
+        print(f"  Class scenario   : {self.class_scenario} ({self.num_classes} classes)")
+        print(f"  Architecture     : {self.architecture_name}")
+        print(f"  Model file       : {self.model_name}")
+        print(f"  Slice range      : {self.slice_start} – {self.slice_end}  (1-based)")
+        print(f"  Post-processing  : {self.apply_postprocess}")
+        print(f"  Data root        : {self.data_root}")
+        print(f"{'='*70}\n")
+
+
+###################### Utility Helpers ######################
+
+def load_nifti(path: Path):
+    """Load a NIfTI file and return (numpy_array, nib_image)."""
+    img = nib.load(str(path))
+    return img.get_fdata(dtype=np.float32), img
+
+
+def save_binary_nifti(mask: np.ndarray, save_path: Path, reference_img):
+    """
+    Save a binary 3-D mask as a NIfTI file.
+
+    Args:
+        mask         : (H, W, S) or (S, H, W) boolean/uint8 array
+        save_path    : destination path (*.nii.gz)
+        reference_img: nibabel image whose affine/header are reused
+    """
+    save_path.parent.mkdir(parents=True, exist_ok=True)
+    nifti_out = nib.Nifti1Image(
+        mask.astype(np.uint8),
+        reference_img.affine,
+        reference_img.header,
+    )
+    nib.save(nifti_out, str(save_path))
+
+
+def preprocess_slice(slice_2d: np.ndarray, target_h: int = 256, target_w: int = 256) -> np.ndarray:
+    """
+    Resize a 2-D slice to (target_h, target_w) if necessary and
+    return a float32 array with shape (1, H, W, 1) ready for the model.
+
+    The data files are assumed to be already normalised to [0, 1] and
+    z-score normalised (as stated in the task description), so no
+    additional intensity normalisation is applied here.
+    """
+    import cv2  # lightweight resize; falls back to zoom if cv2 unavailable
+
+    h, w = slice_2d.shape
+    if h != target_h or w != target_w:
+        slice_2d = cv2.resize(
+            slice_2d, (target_w, target_h), interpolation=cv2.INTER_LINEAR
+        )
+
+    # shape → (1, H, W, 1)
+    return slice_2d[np.newaxis, :, :, np.newaxis].astype(np.float32)
+
+
+def post_process_pred(pred_classes: np.ndarray, num_classes: int = 2,
+                      min_object_size: int = 5, closing_kernel_size: int = 2) -> np.ndarray:
+    """
+    Morphological post-processing for a single 2-D prediction slice.
+    Identical to the function used during training inference.
+
+    Pipeline (per foreground class):
+      1. Extract binary mask from the label map.
+      2. binary_closing  – fill small holes / bridge tiny gaps.
+      3. remove_small_objects – discard isolated noise specks.
+      4. Reconstruct integer label map.
+    """
+    from skimage.morphology import remove_small_objects, binary_closing, disk
+
+    kernel = disk(closing_kernel_size)
+
+    def clean(mask):
+        if not mask.any():
+            return mask
+        mask = binary_closing(mask, kernel)
+        mask = remove_small_objects(mask, min_size=min_object_size)
+        return mask
+
+    gm_mask = (pred_classes == 1)
+
+    gm_mask  = clean(gm_mask)
+
+    post_pred = np.zeros_like(pred_classes)
+    post_pred[gm_mask] = 1
+
+    return post_pred
+
+
+###################### Model Loading ######################
+
+def load_model(config: PredictConfig, fold_id: int):
+    """
+    Build the model architecture and load weights for the given fold.
+
+    Returns the loaded generator (keras Model).
+    """
+    if config.architecture_name == "unet":
+        from unet_model import build_unet_3class as build_fn
+    elif config.architecture_name == "attnunet":
+        from attn_unet_model import build_attention_unet_3class as build_fn
+    elif config.architecture_name == "dlv3unet":
+        from dlv3_unet_model_GN import build_deeplabv3_unet_3class as build_fn
+    elif config.architecture_name == "transunet":
+        from trans_unet_model import build_trans_unet_3class as build_fn
+    else:
+        raise ValueError(f"Unknown architecture: {config.architecture_name}")
+
+    model_path = (
+        config.models_dir
+        / f"fold_{fold_id}"
+        / config.model_name
+    )
+
+    if not model_path.exists():
+        raise FileNotFoundError(f"Model not found: {model_path}")
+
+    generator = build_fn(
+        input_shape=(config.img_height, config.img_width, 1),
+        num_classes=config.num_classes,
+    )
+    generator.load_weights(str(model_path))
+    print(f"  ✅ Fold {fold_id} model loaded from: {model_path}")
+    return generator
+
+
+###################### Per-Patient Prediction ######################
+
+def predict_patient(
+    patient_id: str,
+    flair_path: Path,
+    brain_mask_path: Path,
+    models: list,          # list of keras generators (one per fold)
+    config: PredictConfig,
+    gm_out_dir: Path,
+):
+    """
+    Run inference for a single patient and save Specialized_GM masks.
+
+    Steps:
+      1. Load FLAIR volume and brain mask.
+      2. Apply brain mask (multiply) → brain-extracted volume.
+      3. For each slice in [slice_start, slice_end]:
+           a. Resize to 256×256.
+           b. Run through all fold models and average softmax outputs.
+           c. argmax → class label.
+           d. Optional post-processing.
+      4. Slices outside the range → empty (zero) predictions.
+      5. Save: main prediction, Specialized_GM binary mask.
+    """
+    # ── Load data ────────────────────────────────────────────────────────────
+    flair_data, flair_img = load_nifti(flair_path)       # (H, W, S)
+    brain_mask, _         = load_nifti(brain_mask_path)  # (H, W, S) binary
+
+    # Brain extraction: zero out non-brain voxels
+    brain_mask_bool = brain_mask > 0
+    flair_brain = np.copy(flair_data)
+    flair_brain[~brain_mask_bool] = np.min(flair_data)
+
+    # flair_brain = flair_data * brain_mask                # (H, W, S)
+
+    num_slices = flair_brain.shape[2]
+
+    # Convert to 0-based slice indices for the active range
+    # Input: slice_start / slice_end are 1-based (as stated in the task).
+    active_start = config.slice_start - 1   # inclusive, 0-based
+    active_end   = config.slice_end   - 1   # inclusive, 0-based
+
+    # Clamp to actual volume depth
+    active_start = max(0, active_start)
+    active_end   = min(num_slices - 1, active_end)
+
+    # Initialise output volumes (H, W, S) – same spatial shape as the input
+    H, W = flair_brain.shape[0], flair_brain.shape[1]
+    pred_volume = np.zeros((H, W, num_slices), dtype=np.uint8)  # main prediction
+    gm_volume = np.zeros((H, W, num_slices), dtype=np.uint8)    # binary Specialized_GM
+
+    # ── Inference loop ───────────────────────────────────────────────────────
+    for s in range(num_slices):
+
+        if s < active_start or s > active_end:
+            # Outside desired range: leave masks empty
+            continue
+
+        slice_2d = flair_brain[:, :, s]                  # (H, W)
+        model_input = preprocess_slice(                   # (1, 256, 256, 1)
+            slice_2d, config.img_height, config.img_width
+        )
+
+        # Ensemble: average softmax probabilities across all fold models
+        softmax_sum = np.zeros(
+            (1, config.img_height, config.img_width, config.num_classes),
+            dtype=np.float32,
+        )
+        for gen in models:
+            softmax_sum += gen(model_input, training=False).numpy()
+
+        softmax_avg = softmax_sum / len(models)           # (1, H, W, C)
+        pred_slice  = np.argmax(softmax_avg, axis=-1)[0]  # (H, W)
+
+        # Optional post-processing
+        if config.apply_postprocess:
+            pred_slice = post_process_pred(
+                pred_slice,
+                num_classes=config.num_classes,
+                min_object_size=config.min_object_size,
+                closing_kernel_size=config.closing_kernel_size,
+            )
+
+        # If model output is 256×256 but original slice is different size, resize back
+        if pred_slice.shape != (H, W):
+            import cv2
+            pred_slice = cv2.resize(
+                pred_slice.astype(np.float32), (W, H),
+                interpolation=cv2.INTER_NEAREST,
+            ).astype(np.uint8)
+
+        pred_volume[:, :, s] = pred_slice
+
+        # Binary masks
+        # Specialized_GM = class 1 in 2-class
+        gm_volume[:, :, s] = (pred_slice == 1).astype(np.uint8)
+
+    # ── Save outputs ─────────────────────────────────────────────────────────
+    gm_path = gm_out_dir / f"{patient_id}_gm_mask.nii.gz"
+
+    save_binary_nifti(gm_volume, gm_path, flair_img)
+
+    n_gm = int(gm_volume.sum())
+    print(
+        f"    Patient {patient_id}: "
+        f"GM voxels = {n_gm:6d}"
+    )
+    print(f"      → {gm_path}")
+
+
+###################### Main Prediction Pipeline ######################
+
+def run_prediction(config: PredictConfig, fold_ids: list = None):
+    """
+    Full prediction pipeline for all patients in HC and MS cohorts.
+
+    Args:
+        config   : PredictConfig object.
+        fold_ids : List of fold IDs to ensemble (e.g. [0, 1, 2, 3]).
+                   If None, defaults to [0, 1, 2, 3].
+    """
+    if fold_ids is None:
+        fold_ids = [0]
+
+    # ── Load all fold models ─────────────────────────────────────────────────
+    print(f"\nLoading models for folds: {fold_ids}")
+    models = []
+    for fold_id in fold_ids:
+        gen = load_model(config, fold_id)
+        models.append(gen)
+    print(f"✅ {len(models)} model(s) loaded\n")
+
+    # ── Iterate over cohorts ─────────────────────────────────────────────────
+    for cohort_name, cohort_flair_dir in config.cohorts.items():
+        files_dir       = cohort_flair_dir / "files"
+        brain_masks_dir = cohort_flair_dir / "Brain_Masks"
+        gm_out_dir    = cohort_flair_dir / "GM_Masks"
+
+        # Create output directories
+        gm_out_dir.mkdir(parents=True, exist_ok=True)
+
+        # Discover patients from the files directory
+        flair_files = sorted(files_dir.glob("*.nii.gz"))
+        if not flair_files:
+            print(f"⚠️  No FLAIR files found in {files_dir} – skipping {cohort_name} cohort")
+            continue
+
+        print(f"\n{'='*70}")
+        print(f"COHORT: {cohort_name}  ({len(flair_files)} patients found)")
+        print(f"  FLAIR dir        : {files_dir}")
+        print(f"  Brain masks dir  : {brain_masks_dir}")
+        print(f"  Output GM dir    : {gm_out_dir}")
+        print(f"{'='*70}")
+
+        skipped = 0
+        for flair_path in tqdm(flair_files, desc=f"{cohort_name} patients"):
+            # Extract 6-digit patient ID from filename
+            patient_id = flair_path.stem.replace(".nii", "")  # handles double .nii.gz
+
+            brain_mask_path = brain_masks_dir / f"{patient_id}_brain_mask.nii.gz"
+
+            if not brain_mask_path.exists():    # or patient_id != '110214':
+                print(
+                    f"\n  ⚠️  Brain mask not found for patient {patient_id} "
+                    f"(expected: {brain_mask_path}) – skipping"
+                )
+                skipped += 1
+                continue
+
+            try:
+                predict_patient(
+                    patient_id=patient_id,
+                    flair_path=flair_path,
+                    brain_mask_path=brain_mask_path,
+                    models=models,
+                    config=config,
+                    gm_out_dir=gm_out_dir,
+                )
+            except Exception as exc:
+                print(f"\n  ❌ Error processing patient {patient_id}: {exc}")
+                skipped += 1
+
+        done = len(flair_files) - skipped
+        print(
+            f"\n  ✅ {cohort_name} cohort done: {done} predicted, {skipped} skipped\n"
+        )
+
+    print("\n" + "="*70)
+    print("ALL COHORTS PROCESSED")
+    print("="*70)
+
+
+###################### Entry Point ######################
+
+if __name__ == "__main__":
+
+    parser = argparse.ArgumentParser(
+        description="P4 – Predict Specialized_GM for new HC / MS cohort data"
+    )
+    parser.add_argument("--variant",          type=int,   default=1)
+    parser.add_argument("--preprocessing",    type=str,   default="standard")
+    parser.add_argument("--class_scenario",   type=str,   default="binary",
+                        choices=["binary"])
+    parser.add_argument("--architecture",     type=str,   default="unet",
+                        choices=["unet", "attnunet", "dlv3unet", "transunet"])
+    parser.add_argument("--model_name",       type=str,   default="best_dice_generator.h5")
+    parser.add_argument("--folds",            type=int,   nargs="+", default=[0],
+                        help="Fold IDs to ensemble (e.g. --folds 0 1 2 3)")
+    parser.add_argument("--slice_start",      type=int,   default=1,
+                        help="First slice to predict (1-based, inclusive)")
+    parser.add_argument("--slice_end",        type=int,   default=20,
+                        help="Last slice to predict (1-based, inclusive)")
+    parser.add_argument("--data_root",        type=str,   default="/mnt/d/TEMP_P4")
+    parser.add_argument("--no_postprocess",   action="store_false",
+                        help="Disable morphological post-processing")
+    parser.add_argument("--min_object_size",  type=int,   default=5)
+    parser.add_argument("--closing_size",     type=int,   default=2)
+    args = parser.parse_args()
+
+    config = PredictConfig(
+        variant=args.variant,
+        preprocessing=args.preprocessing,
+        class_scenario=args.class_scenario,
+        architecture_name=args.architecture,
+        model_name=args.model_name,
+        slice_start=args.slice_start,
+        slice_end=args.slice_end,
+        data_root=args.data_root,
+        apply_postprocess=not args.no_postprocess,
+        min_object_size=args.min_object_size,
+        closing_kernel_size=args.closing_size,
+    )
+
+    run_prediction(config, fold_ids=args.folds)

models/for_GM/model_training_scripts/unet_model.py

@@ -0,0 +1,87 @@
+###################### Libraries ######################
+# Deep Learning
+import keras
+from keras.models import Model
+from keras.layers import Input, Conv2D, MaxPooling2D, Conv2DTranspose, concatenate
+
+
+def build_unet_3class(input_shape=(256, 256, 1), num_classes=3):
+    """Enhanced U-Net architecture with batch normalization and dropout"""
+    inputs = Input(input_shape)
+
+    # Encoder with batch normalization
+    c1 = Conv2D(64, 3, activation='relu', padding='same')(inputs)
+    # c1 = keras.layers.BatchNormalization()(c1)
+    c1 = Conv2D(64, 3, activation='relu', padding='same')(c1)
+    # c1 = keras.layers.BatchNormalization()(c1)
+    p1 = MaxPooling2D()(c1)
+    p1 = keras.layers.Dropout(0.1)(p1)
+
+    c2 = Conv2D(128, 3, activation='relu', padding='same')(p1)
+    # c2 = keras.layers.BatchNormalization()(c2)
+    c2 = Conv2D(128, 3, activation='relu', padding='same')(c2)
+    # c2 = keras.layers.BatchNormalization()(c2)
+    p2 = MaxPooling2D()(c2)
+    p2 = keras.layers.Dropout(0.1)(p2)
+
+    c3 = Conv2D(256, 3, activation='relu', padding='same')(p2)
+    # c3 = keras.layers.BatchNormalization()(c3)
+    c3 = Conv2D(256, 3, activation='relu', padding='same')(c3)
+    # c3 = keras.layers.BatchNormalization()(c3)
+    p3 = MaxPooling2D()(c3)
+    p3 = keras.layers.Dropout(0.2)(p3)
+
+    c4 = Conv2D(512, 3, activation='relu', padding='same')(p3)
+    # c4 = keras.layers.BatchNormalization()(c4)
+    c4 = Conv2D(512, 3, activation='relu', padding='same')(c4)
+    # c4 = keras.layers.BatchNormalization()(c4)
+    p4 = MaxPooling2D()(c4)
+    p4 = keras.layers.Dropout(0.2)(p4)
+
+    # Bottleneck
+    c5 = Conv2D(1024, 3, activation='relu', padding='same')(p4)
+    # c5 = keras.layers.BatchNormalization()(c5)
+    c5 = Conv2D(1024, 3, activation='relu', padding='same')(c5)
+    # c5 = keras.layers.BatchNormalization()(c5)
+    c5 = keras.layers.Dropout(0.3)(c5)
+
+    # Decoder
+    u6 = Conv2DTranspose(512, 2, strides=2, padding='same')(c5)
+    u6 = concatenate([u6, c4])
+    u6 = keras.layers.Dropout(0.2)(u6)
+    c6 = Conv2D(512, 3, activation='relu', padding='same')(u6)
+    # c6 = keras.layers.BatchNormalization()(c6)
+    c6 = Conv2D(512, 3, activation='relu', padding='same')(c6)
+    # c6 = keras.layers.BatchNormalization()(c6)
+
+    u7 = Conv2DTranspose(256, 2, strides=2, padding='same')(c6)
+    u7 = concatenate([u7, c3])
+    u7 = keras.layers.Dropout(0.2)(u7)
+    c7 = Conv2D(256, 3, activation='relu', padding='same')(u7)
+    # c7 = keras.layers.BatchNormalization()(c7)
+    c7 = Conv2D(256, 3, activation='relu', padding='same')(c7)
+    # c7 = keras.layers.BatchNormalization()(c7)
+
+    u8 = Conv2DTranspose(128, 2, strides=2, padding='same')(c7)
+    u8 = concatenate([u8, c2])
+    u8 = keras.layers.Dropout(0.1)(u8)
+    c8 = Conv2D(128, 3, activation='relu', padding='same')(u8)
+    # c8 = keras.layers.BatchNormalization()(c8)
+    c8 = Conv2D(128, 3, activation='relu', padding='same')(c8)
+    # c8 = keras.layers.BatchNormalization()(c8)
+
+    u9 = Conv2DTranspose(64, 2, strides=2, padding='same')(c8)
+    u9 = concatenate([u9, c1])
+    u9 = keras.layers.Dropout(0.1)(u9)
+    c9 = Conv2D(64, 3, activation='relu', padding='same')(u9)
+    # c9 = keras.layers.BatchNormalization()(c9)
+    c9 = Conv2D(64, 3, activation='relu', padding='same')(c9)
+    # c9 = keras.layers.BatchNormalization()(c9)
+
+    # Output layer
+    if num_classes == 1:
+        outputs = Conv2D(1, 1, activation='sigmoid')(c9)
+    else:
+        outputs = Conv2D(num_classes, 1, activation='softmax')(c9)
+    
+    return Model(inputs, outputs, name='UNet')

models/for_GM/model_training_scripts/utility_functions.py

@@ -0,0 +1,97 @@
+"""
+P1 Article - Utility Functions
+
+
+Developer:
+"Mahdi Bashiri Bawil"
+"""
+
+import gc
+import tensorflow as tf
+from tensorflow.keras import backend as K
+
+
+print("TensorFlow Version:", tf.__version__)
+
+###################### GPU Configuration ######################
+
+# Configure GPU memory growth
+physical_devices = tf.config.list_physical_devices('GPU')
+if physical_devices:
+    try:
+        for device in physical_devices:
+            tf.config.experimental.set_memory_growth(device, True)
+        print("✅ GPU memory growth enabled")
+        print(f"   Available GPUs: {len(physical_devices)}")
+    except RuntimeError as e:
+        print(f"GPU configuration error: {e}")
+else:
+    print("⚠️  No GPU detected - training will be slow")
+ 
+"""
+GPU Memory Management for Sequential Experiments
+To properly release memory between experiments
+"""
+
+
+def clear_gpu_memory():
+    """
+    Comprehensive GPU memory cleanup between experiments
+    Call this after each experiment completes
+    """
+    print("\n" + "="*70)
+    print("CLEANING UP GPU MEMORY")
+    print("="*70)
+    
+    # Clear Keras session
+    K.clear_session()
+    print("✅ Cleared Keras session")
+    
+    # Force garbage collection multiple times
+    for _ in range(3):
+        gc.collect()
+    print("✅ Ran garbage collection (3 passes)")
+    
+    # Reset TensorFlow graphs
+    tf.compat.v1.reset_default_graph()
+    print("✅ Reset default graph")
+    
+    # Additional cleanup for TF 2.x
+    try:
+        # Clear any cached tensors
+        tf.config.experimental.reset_memory_stats('GPU:0')
+        print("✅ Reset GPU memory stats")
+    except:
+        pass
+    
+    # CRITICAL: Reset GPU memory allocator
+    # This forces TensorFlow to release memory back to the system
+    try:
+        physical_devices = tf.config.list_physical_devices('GPU')
+        if physical_devices:
+            # Disable and re-enable memory growth to flush allocator
+            for device in physical_devices:
+                tf.config.experimental.set_memory_growth(device, False)
+                tf.config.experimental.set_memory_growth(device, True)
+            print("✅ Reset memory growth (flushed allocator)")
+    except Exception as e:
+        print(f"⚠️  Could not reset memory growth: {e}")
+    
+    print("="*70 + "\n")
+
+
+def get_gpu_memory_info():
+    """
+    Print current GPU memory usage
+    Useful for monitoring memory leaks
+    """
+    try:
+        gpu_devices = tf.config.list_physical_devices('GPU')
+        if gpu_devices:
+            for device in gpu_devices:
+                details = tf.config.experimental.get_memory_info(device.name.replace('/physical_device:', ''))
+                current_mb = details['current'] / 1024**2
+                peak_mb = details['peak'] / 1024**2
+                print(f"GPU Memory - Current: {current_mb:.1f} MB, Peak: {peak_mb:.1f} MB")
+    except Exception as e:
+        print(f"Could not get GPU memory info: {e}")

models/for_GM/results_fold_0_var_1_bet_zscore_gm/models/standard_binary/fold_0/best_dice_discriminator.h5

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

models/for_GM/results_fold_0_var_1_bet_zscore_gm/models/standard_binary/fold_0/best_dice_generator.h5

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

models/for_GM/results_fold_0_var_1_bet_zscore_gm/models/standard_binary/fold_0/config.json

@@ -0,0 +1,19 @@
+{
+  "variant": 1,
+  "variant_name": "Multiclass_AttentionD_AdaptiveLoss",
+  "preprocessing": "standard",
+  "class_scenario": "binary",
+  "fold_id": 0,
+  "num_classes": 2,
+  "batch_size": 4,
+  "epochs": 20,
+  "lambda_seg": 50,
+  "lambda_gan": 1,
+  "focal_gamma": 0.5,
+  "beta_threshold": 0.25,
+  "beta_smoothness": 0.05,
+  "learning_rate": 0.0002,
+  "beta_1": 0.9,
+  "attention_weight": 2.0,
+  "innovation": "Phase-transitioning segmentation loss (Weighted CE \u2192 Focal Loss)"
+}

models/for_GM/results_fold_0_var_1_bet_zscore_gm/models/standard_binary/fold_0/download_models.txt

@@ -0,0 +1 @@
+Visit our Hugging Face link for downloading the trained models.

models/for_GM/results_fold_0_var_1_bet_zscore_gm/models/standard_binary/fold_0/history.json

@@ -0,0 +1,145 @@
+{
+  "gen_total_loss": [
+    16.160808563232422,
+    15.84605598449707,
+    15.596329689025879,
+    15.1962308883667,
+    15.236580848693848
+  ],
+  "gen_gan_loss": [
+    1.4460713863372803,
+    1.3656171560287476,
+    1.3531222343444824,
+    1.1605579853057861,
+    1.2858413457870483
+  ],
+  "gen_seg_loss": [
+    0.2942947447299957,
+    0.28960874676704407,
+    0.2848641574382782,
+    0.2807134687900543,
+    0.27901479601860046
+  ],
+  "gen_wce_loss": [
+    0.427320659160614,
+    0.5918631553649902,
+    0.6427512764930725,
+    0.6484421491622925,
+    0.6594918966293335
+  ],
+  "gen_focal_loss": [
+    0.2933984398841858,
+    0.28957146406173706,
+    0.28486335277557373,
+    0.2807134687900543,
+    0.27901479601860046
+  ],
+  "disc_loss": [
+    0.9733297228813171,
+    0.9525837898254395,
+    0.9791364669799805,
+    1.0745328664779663,
+    0.9908205270767212
+  ],
+  "val_loss": [
+    0.2753802239894867,
+    0.28040140867233276,
+    0.28456518054008484,
+    0.28689467906951904,
+    0.2823749780654907
+  ],
+  "beta_value": [
+    0.9933071732521057,
+    0.9998766183853149,
+    0.9999977350234985,
+    1.0,
+    1.0
+  ],
+  "val_metrics": [
+    {
+      "dice": {
+        "class_0": 0.9691289499147928,
+        "class_1": 0.752369057690533,
+        "mean": 0.8607490038026628
+      },
+      "precision": {
+        "class_0": 0.9797553013827063,
+        "class_1": 0.6921517437594977,
+        "mean": 0.835953522571102
+      },
+      "recall": {
+        "class_0": 0.9587306304286759,
+        "class_1": 0.8240626410757951,
+        "mean": 0.8913966357522355
+      }
+    },
+    {
+      "dice": {
+        "class_0": 0.9697302587837198,
+        "class_1": 0.7479798920589907,
+        "mean": 0.8588550754213553
+      },
+      "precision": {
+        "class_0": 0.976320417478653,
+        "class_1": 0.708180715854344,
+        "mean": 0.8422505666664984
+      },
+      "recall": {
+        "class_0": 0.9632284706744223,
+        "class_1": 0.7925187994877733,
+        "mean": 0.8778736350810978
+      }
+    },
+    {
+      "dice": {
+        "class_0": 0.9700212734386713,
+        "class_1": 0.7450693229965066,
+        "mean": 0.857545298217589
+      },
+      "precision": {
+        "class_0": 0.9743977498147104,
+        "class_1": 0.7176589260174784,
+        "mean": 0.8460283379160944
+      },
+      "recall": {
+        "class_0": 0.9656839348841134,
+        "class_1": 0.7746567035718136,
+        "mean": 0.8701703192279635
+      }
+    },
+    {
+      "dice": {
+        "class_0": 0.9707925785575585,
+        "class_1": 0.7425312591148605,
+        "mean": 0.8566619188362095
+      },
+      "precision": {
+        "class_0": 0.9715280350271916,
+        "class_1": 0.7376090600933536,
+        "mean": 0.8545685475602727
+      },
+      "recall": {
+        "class_0": 0.9700582347414827,
+        "class_1": 0.7475195929191307,
+        "mean": 0.8587889138303066
+      }
+    },
+    {
+      "dice": {
+        "class_0": 0.9707689737822686,
+        "class_1": 0.7466375133242413,
+        "mean": 0.8587032435532549
+      },
+      "precision": {
+        "class_0": 0.9731953621432797,
+        "class_1": 0.730843840931104,
+        "mean": 0.8520196015371919
+      },
+      "recall": {
+        "class_0": 0.9683546543618544,
+        "class_1": 0.7631288712746304,
+        "mean": 0.8657417628182424
+      }
+    }
+  ]
+}