Add files using upload-large-folder tool

metadata/splits/split_summary.csv

@@ -0,0 +1,4 @@
+split,samples,subjects
+train,710,710
+val,152,152
+test,153,153

metadata/splits/val.csv

@@ -0,0 +1,153 @@
+sample_id,subject_id,visit,pet_path,suvr_csv_path,shape,zooms,dtype,region_rows,suvr_min,suvr_max,suvr_mean,split
+002S2010_M00_fdg_pet,002S2010,M00,fdgpet_M00_112/fdgpet_M00_112/002S2010_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/002S2010_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.6130855784696692,1.5451448653597737,1.1682682216133549,val
+002S4229_M00_fdg_pet,002S4229,M00,fdgpet_M00_112/fdgpet_M00_112/002S4229_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/002S4229_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.5225892881067787,1.534046360703765,1.1661183716382657,val
+002S4746_M00_fdg_pet,002S4746,M00,fdgpet_M00_112/fdgpet_M00_112/002S4746_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/002S4746_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.5143933219705673,1.5033518056400488,1.201207369624356,val
+003S4350_M00_fdg_pet,003S4350,M00,fdgpet_M00_112/fdgpet_M00_112/003S4350_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/003S4350_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.4978755604137074,1.5317810454558618,1.142299611667552,val
+005S0222_M00_fdg_pet,005S0222,M00,fdgpet_M00_112/fdgpet_M00_112/005S0222_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/005S0222_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,int16,121,0.5854023717441501,1.3816601057325315,1.0188035806258344,val
+005S0610_M00_fdg_pet,005S0610,M00,fdgpet_M00_112/fdgpet_M00_112/005S0610_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/005S0610_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,int16,121,0.6258189432784691,1.776341307607395,1.2159099603775638,val
+005S2390_M00_fdg_pet,005S2390,M00,fdgpet_M00_112/fdgpet_M00_112/005S2390_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/005S2390_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,int16,121,0.7625209530454408,1.685342033916314,1.2260925282244046,val
+006S4150_M00_fdg_pet,006S4150,M00,fdgpet_M00_112/fdgpet_M00_112/006S4150_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/006S4150_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,int16,121,0.6621003634684804,1.4837714401475992,1.148945196622542,val
+006S4192_M00_fdg_pet,006S4192,M00,fdgpet_M00_112/fdgpet_M00_112/006S4192_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/006S4192_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,int16,121,0.5378416657672205,1.1426088559675982,0.8852363958184436,val
+006S4546_M00_fdg_pet,006S4546,M00,fdgpet_M00_112/fdgpet_M00_112/006S4546_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/006S4546_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,int16,121,0.6580099365291551,1.822839651964547,1.211820323770937,val
+007S0293_M00_fdg_pet,007S0293,M00,fdgpet_M00_112/fdgpet_M00_112/007S0293_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/007S0293_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.5903835194633607,1.4180257025371028,1.0203066208629363,val
+007S1339_M00_fdg_pet,007S1339,M00,fdgpet_M00_112/fdgpet_M00_112/007S1339_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/007S1339_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.675830742138085,1.4161981378944175,1.1148515529208387,val
+007S4488_M00_fdg_pet,007S4488,M00,fdgpet_M00_112/fdgpet_M00_112/007S4488_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/007S4488_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.6111476714598304,1.7246942338959952,1.1932071360565562,val
+007S4516_M00_fdg_pet,007S4516,M00,fdgpet_M00_112/fdgpet_M00_112/007S4516_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/007S4516_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.4678168475309158,1.631630071429505,1.0975409605412367,val
+009S1199_M00_fdg_pet,009S1199,M00,fdgpet_M00_112/fdgpet_M00_112/009S1199_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/009S1199_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.5846835865693933,1.577944664514867,1.2045100547151335,val
+009S2208_M00_fdg_pet,009S2208,M00,fdgpet_M00_112/fdgpet_M00_112/009S2208_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/009S2208_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.6622150033553016,1.4999867787346997,1.1168063457431243,val
+009S4359_M00_fdg_pet,009S4359,M00,fdgpet_M00_112/fdgpet_M00_112/009S4359_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/009S4359_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.5810416318516043,1.3874002621061168,1.0744753861978642,val
+009S4612_M00_fdg_pet,009S4612,M00,fdgpet_M00_112/fdgpet_M00_112/009S4612_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/009S4612_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.6179723507020531,1.497322253818545,1.0967472360442414,val
+010S4345_M00_fdg_pet,010S4345,M00,fdgpet_M00_112/fdgpet_M00_112/010S4345_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/010S4345_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,int16,121,0.7771201977934759,1.710800654166846,1.244100253230879,val
+011S0053_M00_fdg_pet,011S0053,M00,fdgpet_M00_112/fdgpet_M00_112/011S0053_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/011S0053_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,int16,121,0.4053546826827675,1.1916210153548297,0.8599013369002707,val
+011S0861_M00_fdg_pet,011S0861,M00,fdgpet_M00_112/fdgpet_M00_112/011S0861_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/011S0861_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,int16,121,0.4439952516761041,1.4138248932822108,0.9441382904545598,val
+011S4222_M00_fdg_pet,011S4222,M00,fdgpet_M00_112/fdgpet_M00_112/011S4222_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/011S4222_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.5688305154471063,1.5817856804582986,1.1051181256525382,val
+012S4128_M00_fdg_pet,012S4128,M00,fdgpet_M00_112/fdgpet_M00_112/012S4128_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/012S4128_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.5277128984583891,1.326189830517328,1.0491980518804167,val
+012S4987_M00_fdg_pet,012S4987,M00,fdgpet_M00_112/fdgpet_M00_112/012S4987_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/012S4987_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.5695403494485994,1.3722362937692392,1.102449829741389,val
+013S1161_M00_fdg_pet,013S1161,M00,fdgpet_M00_112/fdgpet_M00_112/013S1161_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/013S1161_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.5620511712874958,1.2866886610968855,0.993835889794818,val
+013S4595_M00_fdg_pet,013S4595,M00,fdgpet_M00_112/fdgpet_M00_112/013S4595_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/013S4595_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.5609056974712171,1.5450846354166667,1.075773496497761,val
+013S5071_M00_fdg_pet,013S5071,M00,fdgpet_M00_112/fdgpet_M00_112/013S5071_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/013S5071_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.7172918472698028,1.5706837708468264,1.1617727473594244,val
+014S4080_M00_fdg_pet,014S4080,M00,fdgpet_M00_112/fdgpet_M00_112/014S4080_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/014S4080_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.3298627806872856,1.662185586820506,1.1896105448759615,val
+016S0590_M00_fdg_pet,016S0590,M00,fdgpet_M00_112/fdgpet_M00_112/016S0590_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/016S0590_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.5314887117084703,1.5859719706322863,1.0550571821372674,val
+016S4121_M00_fdg_pet,016S4121,M00,fdgpet_M00_112/fdgpet_M00_112/016S4121_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/016S4121_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.6222262783641682,1.4118782710103157,1.011479981689829,val
+016S4353_M00_fdg_pet,016S4353,M00,fdgpet_M00_112/fdgpet_M00_112/016S4353_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/016S4353_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.6706020251472565,1.5926721952081788,1.0906204220308515,val
+016S4601_M00_fdg_pet,016S4601,M00,fdgpet_M00_112/fdgpet_M00_112/016S4601_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/016S4601_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.7421343111734081,1.7780829081965928,1.2076785810022754,val
+016S4951_M00_fdg_pet,016S4951,M00,fdgpet_M00_112/fdgpet_M00_112/016S4951_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/016S4951_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.6365926813951788,1.5770693764167747,1.20615236511728,val
+018S4696_M00_fdg_pet,018S4696,M00,fdgpet_M00_112/fdgpet_M00_112/018S4696_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/018S4696_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.5789904561244861,1.4161918920816785,0.9960260668339004,val
+018S4733_M00_fdg_pet,018S4733,M00,fdgpet_M00_112/fdgpet_M00_112/018S4733_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/018S4733_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.5680867159430356,1.3670695123066472,0.9714958647829468,val
+018S4889_M00_fdg_pet,018S4889,M00,fdgpet_M00_112/fdgpet_M00_112/018S4889_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/018S4889_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.5211284453856116,1.5090284594600063,1.148163944117111,val
+019S4285_M00_fdg_pet,019S4285,M00,fdgpet_M00_112/fdgpet_M00_112/019S4285_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/019S4285_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.7139396463485963,1.5090529156884176,1.0956450271365106,val
+019S4477_M00_fdg_pet,019S4477,M00,fdgpet_M00_112/fdgpet_M00_112/019S4477_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/019S4477_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.5998719304064872,1.5426449983016304,1.071282532163102,val
+021S0141_M00_fdg_pet,021S0141,M00,fdgpet_M00_112/fdgpet_M00_112/021S0141_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/021S0141_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.4105021838835854,1.3590590719114313,0.9765538960952778,val
+021S0642_M00_fdg_pet,021S0642,M00,fdgpet_M00_112/fdgpet_M00_112/021S0642_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/021S0642_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.5605707866389577,1.6061984248637482,1.173559266807612,val
+021S0647_M00_fdg_pet,021S0647,M00,fdgpet_M00_112/fdgpet_M00_112/021S0647_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/021S0647_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.5130969368837734,1.4764638481811865,1.080991620166608,val
+021S2142_M00_fdg_pet,021S2142,M00,fdgpet_M00_112/fdgpet_M00_112/021S2142_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/021S2142_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.5734769851766168,1.6987708569987945,1.1846469824077337,val
+022S0219_M00_fdg_pet,022S0219,M00,fdgpet_M00_112/fdgpet_M00_112/022S0219_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/022S0219_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.3945540973846925,1.6207760201648724,1.0582901740640809,val
+022S0543_M00_fdg_pet,022S0543,M00,fdgpet_M00_112/fdgpet_M00_112/022S0543_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/022S0543_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.3678792861693683,1.7979144737368724,1.1634697318265086,val
+022S4444_M00_fdg_pet,022S4444,M00,fdgpet_M00_112/fdgpet_M00_112/022S4444_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/022S4444_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.5842867711915916,1.546184813422996,1.1479727698502424,val
+022S4922_M00_fdg_pet,022S4922,M00,fdgpet_M00_112/fdgpet_M00_112/022S4922_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/022S4922_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.423281909310244,1.5846322481749489,1.106813814388958,val
+023S4448_M00_fdg_pet,023S4448,M00,fdgpet_M00_112/fdgpet_M00_112/023S4448_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/023S4448_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.7046644241414606,1.6551035088784545,1.194730830729444,val
+024S1393_M00_fdg_pet,024S1393,M00,fdgpet_M00_112/fdgpet_M00_112/024S1393_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/024S1393_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,int16,121,0.5372143251481758,1.4514011817141663,1.0371309525824086,val
+024S1400_M00_fdg_pet,024S1400,M00,fdgpet_M00_112/fdgpet_M00_112/024S1400_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/024S1400_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,int16,121,0.5228917732659765,1.4166587168039204,1.0687254805438935,val
+024S4169_M00_fdg_pet,024S4169,M00,fdgpet_M00_112/fdgpet_M00_112/024S4169_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/024S4169_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,int16,121,0.5561296661819755,1.29814074096249,0.9748994127975952,val
+024S4905_M00_fdg_pet,024S4905,M00,fdgpet_M00_112/fdgpet_M00_112/024S4905_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/024S4905_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,int16,121,0.7050304897010968,1.569188636912482,1.1374760610343813,val
+027S0408_M00_fdg_pet,027S0408,M00,fdgpet_M00_112/fdgpet_M00_112/027S0408_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/027S0408_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.3817983617119611,1.2828499051365447,1.0130704951830156,val
+027S4873_M00_fdg_pet,027S4873,M00,fdgpet_M00_112/fdgpet_M00_112/027S4873_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/027S4873_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.4804024109865892,1.5185279220831198,1.1179255351095194,val
+027S4964_M00_fdg_pet,027S4964,M00,fdgpet_M00_112/fdgpet_M00_112/027S4964_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/027S4964_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.5026347114440591,1.2965290376925356,0.9862690706540546,val
+029S1056_M00_fdg_pet,029S1056,M00,fdgpet_M00_112/fdgpet_M00_112/029S1056_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/029S1056_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,int16,121,0.5048055371424912,1.2723824327457578,0.9051783996276244,val
+031S2018_M00_fdg_pet,031S2018,M00,fdgpet_M00_112/fdgpet_M00_112/031S2018_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/031S2018_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,int16,121,0.5676287554394153,1.4849969779627792,1.033595681228472,val
+031S2022_M00_fdg_pet,031S2022,M00,fdgpet_M00_112/fdgpet_M00_112/031S2022_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/031S2022_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,int16,121,0.6763742980501726,1.5995309015313413,1.1602281726684385,val
+031S4005_M00_fdg_pet,031S4005,M00,fdgpet_M00_112/fdgpet_M00_112/031S4005_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/031S4005_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,int16,121,0.4353031376085295,1.1506237801586394,0.821157213340859,val
+031S4032_M00_fdg_pet,031S4032,M00,fdgpet_M00_112/fdgpet_M00_112/031S4032_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/031S4032_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,int16,121,0.555698337275871,1.29195621535911,0.937925081898764,val
+031S4203_M00_fdg_pet,031S4203,M00,fdgpet_M00_112/fdgpet_M00_112/031S4203_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/031S4203_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,int16,121,0.5745257627747518,1.3915173175607762,1.0490015623098627,val
+032S0400_M00_fdg_pet,032S0400,M00,fdgpet_M00_112/fdgpet_M00_112/032S0400_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/032S0400_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,int16,121,0.5739163152785505,1.6272965175550165,1.214966748280907,val
+032S0978_M00_fdg_pet,032S0978,M00,fdgpet_M00_112/fdgpet_M00_112/032S0978_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/032S0978_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,int16,121,0.4045239149200693,1.3067335617127915,1.0455938402574425,val
+032S2119_M00_fdg_pet,032S2119,M00,fdgpet_M00_112/fdgpet_M00_112/032S2119_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/032S2119_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,int16,121,0.4416101918765262,1.569079931636668,1.1388093713741976,val
+032S4429_M00_fdg_pet,032S4429,M00,fdgpet_M00_112/fdgpet_M00_112/032S4429_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/032S4429_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,int16,121,0.5051268098023309,1.8301627275083088,1.3055162211119191,val
+032S4755_M00_fdg_pet,032S4755,M00,fdgpet_M00_112/fdgpet_M00_112/032S4755_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/032S4755_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,int16,121,0.4089400664784784,1.825936730528781,1.3021404695416718,val
+032S4823_M00_fdg_pet,032S4823,M00,fdgpet_M00_112/fdgpet_M00_112/032S4823_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/032S4823_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,int16,121,0.4417573498649679,1.6437236499503214,1.148885191034538,val
+035S4783_M00_fdg_pet,035S4783,M00,fdgpet_M00_112/fdgpet_M00_112/035S4783_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/035S4783_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.4383173243884734,1.439151760560961,1.0304223246945436,val
+036S0760_M00_fdg_pet,036S0760,M00,fdgpet_M00_112/fdgpet_M00_112/036S0760_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/036S0760_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,int16,121,0.5054986706014652,1.3193502040685416,0.8956313910147379,val
+036S1135_M00_fdg_pet,036S1135,M00,fdgpet_M00_112/fdgpet_M00_112/036S1135_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/036S1135_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,int16,121,0.5039047631514859,1.5342718339256909,1.1086934880674837,val
+036S2380_M00_fdg_pet,036S2380,M00,fdgpet_M00_112/fdgpet_M00_112/036S2380_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/036S2380_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,int16,121,0.7703633465491176,1.911245874998516,1.4498632640524112,val
+036S5112_M00_fdg_pet,036S5112,M00,fdgpet_M00_112/fdgpet_M00_112/036S5112_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/036S5112_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,int16,121,0.6158807737349631,1.4660782985007046,1.0333091842698912,val
+041S0282_M00_fdg_pet,041S0282,M00,fdgpet_M00_112/fdgpet_M00_112/041S0282_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/041S0282_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,int16,121,0.5495281869767583,1.5061889853666233,1.1108215379165187,val
+041S0407_M00_fdg_pet,041S0407,M00,fdgpet_M00_112/fdgpet_M00_112/041S0407_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/041S0407_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,int16,121,0.5679679031553942,1.6956683488239577,1.2530847878740117,val
+041S0598_M00_fdg_pet,041S0598,M00,fdgpet_M00_112/fdgpet_M00_112/041S0598_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/041S0598_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,int16,121,0.5679166197371529,1.444278337256197,1.0301996420513455,val
+041S1010_M00_fdg_pet,041S1010,M00,fdgpet_M00_112/fdgpet_M00_112/041S1010_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/041S1010_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,int16,121,0.6185995083861808,1.638986196858923,1.156266154296135,val
+041S1412_M00_fdg_pet,041S1412,M00,fdgpet_M00_112/fdgpet_M00_112/041S1412_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/041S1412_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,int16,121,0.6134029317119303,1.3265960277432156,1.0302420086082866,val
+041S4200_M00_fdg_pet,041S4200,M00,fdgpet_M00_112/fdgpet_M00_112/041S4200_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/041S4200_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,int16,121,0.6810143758292029,1.6490700042270794,1.178864886735488,val
+041S4877_M00_fdg_pet,041S4877,M00,fdgpet_M00_112/fdgpet_M00_112/041S4877_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/041S4877_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,int16,121,0.4124853430435561,1.4667605582551864,1.0283716224833042,val
+041S4989_M00_fdg_pet,041S4989,M00,fdgpet_M00_112/fdgpet_M00_112/041S4989_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/041S4989_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,int16,121,0.6472930838067952,1.4331789702430895,1.076331521958383,val
+051S4929_M00_fdg_pet,051S4929,M00,fdgpet_M00_112/fdgpet_M00_112/051S4929_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/051S4929_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.5789701762952303,1.369352497038294,1.067986713716914,val
+052S1346_M00_fdg_pet,052S1346,M00,fdgpet_M00_112/fdgpet_M00_112/052S1346_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/052S1346_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.6076386149336652,1.4018627405166626,1.1382859515836234,val
+053S4578_M00_fdg_pet,053S4578,M00,fdgpet_M00_112/fdgpet_M00_112/053S4578_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/053S4578_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,int16,121,0.4609880364375049,1.4006361467364046,1.061689848879346,val
+067S4184_M00_fdg_pet,067S4184,M00,fdgpet_M00_112/fdgpet_M00_112/067S4184_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/067S4184_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.4428812352622427,1.6309098686784866,1.159896988364192,val
+067S4212_M00_fdg_pet,067S4212,M00,fdgpet_M00_112/fdgpet_M00_112/067S4212_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/067S4212_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.1772498522306743,1.8723115623318085,1.0794208113985475,val
+068S2248_M00_fdg_pet,068S2248,M00,fdgpet_M00_112/fdgpet_M00_112/068S2248_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/068S2248_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.6845126503392269,1.6193848848342896,1.1818247371148678,val
+068S4174_M00_fdg_pet,068S4174,M00,fdgpet_M00_112/fdgpet_M00_112/068S4174_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/068S4174_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.5411551980411305,1.4675192450911072,1.161298411959886,val
+072S2072_M00_fdg_pet,072S2072,M00,fdgpet_M00_112/fdgpet_M00_112/072S2072_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/072S2072_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.6077061629876858,1.399373338374007,1.0571593516817444,val
+072S4613_M00_fdg_pet,072S4613,M00,fdgpet_M00_112/fdgpet_M00_112/072S4613_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/072S4613_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.5433775273765006,1.4657371395924053,1.1538627477343724,val
+073S1357_M00_fdg_pet,073S1357,M00,fdgpet_M00_112/fdgpet_M00_112/073S1357_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/073S1357_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,int16,121,0.5662989568581079,1.339159479071526,1.002903207113124,val
+073S2182_M00_fdg_pet,073S2182,M00,fdgpet_M00_112/fdgpet_M00_112/073S2182_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/073S2182_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.5031846806327289,1.5561907147290588,1.1539756350565389,val
+073S4403_M00_fdg_pet,073S4403,M00,fdgpet_M00_112/fdgpet_M00_112/073S4403_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/073S4403_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.4937209152593845,1.5351263310477756,1.1761409862406955,val
+073S4540_M00_fdg_pet,073S4540,M00,fdgpet_M00_112/fdgpet_M00_112/073S4540_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/073S4540_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.5101386085551053,1.4398923780097337,1.047882823219493,val
+073S4559_M00_fdg_pet,073S4559,M00,fdgpet_M00_112/fdgpet_M00_112/073S4559_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/073S4559_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.4675567953344335,1.3798722710222366,1.0540255544479424,val
+073S4986_M00_fdg_pet,073S4986,M00,fdgpet_M00_112/fdgpet_M00_112/073S4986_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/073S4986_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.5338241250757227,1.41495638946227,1.0631568401516394,val
+094S0531_M00_fdg_pet,094S0531,M00,fdgpet_M00_112/fdgpet_M00_112/094S0531_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/094S0531_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,int16,121,0.5052946195434699,1.2238196123576015,0.875657722975816,val
+094S4858_M00_fdg_pet,094S4858,M00,fdgpet_M00_112/fdgpet_M00_112/094S4858_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/094S4858_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,int16,121,0.6619102815776791,1.940497220527476,1.326667960782625,val
+100S4469_M00_fdg_pet,100S4469,M00,fdgpet_M00_112/fdgpet_M00_112/100S4469_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/100S4469_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.7536898280607606,1.804717021455397,1.344321368509906,val
+100S4556_M00_fdg_pet,100S4556,M00,fdgpet_M00_112/fdgpet_M00_112/100S4556_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/100S4556_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.5435223502908798,1.475380071429505,1.130673812076885,val
+109S1157_M00_fdg_pet,109S1157,M00,fdgpet_M00_112/fdgpet_M00_112/109S1157_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/109S1157_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.4337788150185033,1.3988137133544103,0.9478397009436418,val
+109S2237_M00_fdg_pet,109S2237,M00,fdgpet_M00_112/fdgpet_M00_112/109S2237_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/109S2237_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.4798310631736714,1.685610756355246,1.1225317736301104,val
+109S4260_M00_fdg_pet,109S4260,M00,fdgpet_M00_112/fdgpet_M00_112/109S4260_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/109S4260_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.4950967472504805,1.7405294583538389,1.2100268724842629,val
+114S0228_M00_fdg_pet,114S0228,M00,fdgpet_M00_112/fdgpet_M00_112/114S0228_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/114S0228_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.524557511436748,1.495211482048035,1.1276781969014715,val
+114S1118_M00_fdg_pet,114S1118,M00,fdgpet_M00_112/fdgpet_M00_112/114S1118_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/114S1118_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.4376195407806233,1.6392725843577212,1.2343341195663948,val
+116S0360_M00_fdg_pet,116S0360,M00,fdgpet_M00_112/fdgpet_M00_112/116S0360_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/116S0360_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.4846747495273855,1.4036995547902271,1.022745936383321,val
+116S0657_M00_fdg_pet,116S0657,M00,fdgpet_M00_112/fdgpet_M00_112/116S0657_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/116S0657_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.5399971212295287,1.416969426898255,0.9706298423192268,val
+116S4043_M00_fdg_pet,116S4043,M00,fdgpet_M00_112/fdgpet_M00_112/116S4043_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/116S4043_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.4753644402651863,1.7511268028846154,1.2110825744743683,val
+116S4199_M00_fdg_pet,116S4199,M00,fdgpet_M00_112/fdgpet_M00_112/116S4199_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/116S4199_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.5648776375673672,1.6977729231384455,1.2737383207357618,val
+116S4635_M00_fdg_pet,116S4635,M00,fdgpet_M00_112/fdgpet_M00_112/116S4635_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/116S4635_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.5161281320500501,1.7169289597163753,1.2344654290410213,val
+116S4732_M00_fdg_pet,116S4732,M00,fdgpet_M00_112/fdgpet_M00_112/116S4732_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/116S4732_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.5868162675337358,1.608450286763169,1.1045684747210942,val
+123S4170_M00_fdg_pet,123S4170,M00,fdgpet_M00_112/fdgpet_M00_112/123S4170_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/123S4170_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.6829346912663158,1.7965946367303411,1.3500708110370545,val
+123S4362_M00_fdg_pet,123S4362,M00,fdgpet_M00_112/fdgpet_M00_112/123S4362_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/123S4362_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.694824730477682,1.8650774519822435,1.4285392933849432,val
+123S4780_M00_fdg_pet,123S4780,M00,fdgpet_M00_112/fdgpet_M00_112/123S4780_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/123S4780_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.7042832723477992,1.9239496802478904,1.27720279734896,val
+123S4904_M00_fdg_pet,123S4904,M00,fdgpet_M00_112/fdgpet_M00_112/123S4904_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/123S4904_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.6255590857529059,1.6529105187968998,1.2394333926132743,val
+127S0431_M00_fdg_pet,127S0431,M00,fdgpet_M00_112/fdgpet_M00_112/127S0431_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/127S0431_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.5503240983116435,1.472652174952476,1.0648580411321882,val
+127S1210_M00_fdg_pet,127S1210,M00,fdgpet_M00_112/fdgpet_M00_112/127S1210_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/127S1210_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.5482238730925838,1.320639729499817,0.9291197957206524,val
+127S4197_M00_fdg_pet,127S4197,M00,fdgpet_M00_112/fdgpet_M00_112/127S4197_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/127S4197_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,int16,121,0.4084707661133439,1.18600368867535,0.897133590951844,val
+127S4198_M00_fdg_pet,127S4198,M00,fdgpet_M00_112/fdgpet_M00_112/127S4198_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/127S4198_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,int16,121,0.4979782093326511,1.2664426811857878,0.9125774256956306,val
+127S4210_M00_fdg_pet,127S4210,M00,fdgpet_M00_112/fdgpet_M00_112/127S4210_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/127S4210_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,int16,121,0.6138714312117683,1.591755743789814,1.2084713262473576,val
+127S4624_M00_fdg_pet,127S4624,M00,fdgpet_M00_112/fdgpet_M00_112/127S4624_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/127S4624_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,int16,121,0.4591505602158557,1.2500750758767936,0.9694744655191088,val
+127S5058_M00_fdg_pet,127S5058,M00,fdgpet_M00_112/fdgpet_M00_112/127S5058_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/127S5058_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,int16,121,0.4761749900273648,1.6911816650064828,1.1572378090000996,val
+128S0227_M00_fdg_pet,128S0227,M00,fdgpet_M00_112/fdgpet_M00_112/128S0227_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/128S0227_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,int16,121,0.5185130373461949,1.3465168515174355,1.0010940927230323,val
+128S0230_M00_fdg_pet,128S0230,M00,fdgpet_M00_112/fdgpet_M00_112/128S0230_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/128S0230_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,int16,121,0.4604968938831863,1.2730979720718163,0.959332270233602,val
+128S0272_M00_fdg_pet,128S0272,M00,fdgpet_M00_112/fdgpet_M00_112/128S0272_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/128S0272_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,int16,121,0.5506763940939425,1.1876595045064138,0.9694210373104556,val
+128S2003_M00_fdg_pet,128S2003,M00,fdgpet_M00_112/fdgpet_M00_112/128S2003_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/128S2003_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,int16,121,0.575459367077308,1.2925958462875815,0.9963333015582124,val
+128S2151_M00_fdg_pet,128S2151,M00,fdgpet_M00_112/fdgpet_M00_112/128S2151_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/128S2151_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,int16,121,0.7232723133972144,1.340928885241908,1.085806299715455,val
+128S4599_M00_fdg_pet,128S4599,M00,fdgpet_M00_112/fdgpet_M00_112/128S4599_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/128S4599_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,int16,121,0.594582282032615,1.59699999460274,1.1163305492852862,val
+128S4671_M00_fdg_pet,128S4671,M00,fdgpet_M00_112/fdgpet_M00_112/128S4671_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/128S4671_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,int16,121,0.5633445538686133,1.4194413575940672,0.993418694355821,val
+128S4745_M00_fdg_pet,128S4745,M00,fdgpet_M00_112/fdgpet_M00_112/128S4745_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/128S4745_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,int16,121,0.6917662457536914,1.5167277531869416,1.0765095321197755,val
+128S5123_M00_fdg_pet,128S5123,M00,fdgpet_M00_112/fdgpet_M00_112/128S5123_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/128S5123_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,int16,121,0.5966193675467124,1.2741808536678365,0.946831775912354,val
+130S2391_M00_fdg_pet,130S2391,M00,fdgpet_M00_112/fdgpet_M00_112/130S2391_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/130S2391_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.4855878289370613,1.577939048332254,1.1601395989064855,val
+130S4294_M00_fdg_pet,130S4294,M00,fdgpet_M00_112/fdgpet_M00_112/130S4294_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/130S4294_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.4219434784679878,1.4953330559874058,1.0662130284635571,val
+130S4352_M00_fdg_pet,130S4352,M00,fdgpet_M00_112/fdgpet_M00_112/130S4352_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/130S4352_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.4214410628864471,1.5602226191439983,1.1657892047736926,val
+130S4730_M00_fdg_pet,130S4730,M00,fdgpet_M00_112/fdgpet_M00_112/130S4730_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/130S4730_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.4738968221899022,1.5848032216556738,1.143266700274927,val
+130S4990_M00_fdg_pet,130S4990,M00,fdgpet_M00_112/fdgpet_M00_112/130S4990_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/130S4990_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.5055370636802307,1.5011500374215547,1.0573446766541,val
+130S5059_M00_fdg_pet,130S5059,M00,fdgpet_M00_112/fdgpet_M00_112/130S5059_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/130S5059_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.6791454323606512,1.638562120386684,1.1323196964466178,val
+137S1414_M00_fdg_pet,137S1414,M00,fdgpet_M00_112/fdgpet_M00_112/137S1414_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/137S1414_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.5921718577012659,1.554995205735913,1.177327861977282,val
+137S4211_M00_fdg_pet,137S4211,M00,fdgpet_M00_112/fdgpet_M00_112/137S4211_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/137S4211_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.4991976080093792,1.8417531909751248,1.132140618017005,val
+137S4258_M00_fdg_pet,137S4258,M00,fdgpet_M00_112/fdgpet_M00_112/137S4258_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/137S4258_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.510324773941448,1.6326896131636706,1.1064582068116495,val
+137S4351_M00_fdg_pet,137S4351,M00,fdgpet_M00_112/fdgpet_M00_112/137S4351_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/137S4351_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.5901373388932988,1.818250937540023,1.2603468312469357,val
+137S4587_M00_fdg_pet,137S4587,M00,fdgpet_M00_112/fdgpet_M00_112/137S4587_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/137S4587_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.5410589942320145,1.4834014392289958,1.092879867525642,val
+137S4678_M00_fdg_pet,137S4678,M00,fdgpet_M00_112/fdgpet_M00_112/137S4678_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/137S4678_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.5798987256507946,1.5253534409606342,1.114381609253059,val
+141S1245_M00_fdg_pet,141S1245,M00,fdgpet_M00_112/fdgpet_M00_112/141S1245_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/141S1245_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.5955459676324365,1.523713158779457,1.1623531693069742,val
+141S4976_M00_fdg_pet,141S4976,M00,fdgpet_M00_112/fdgpet_M00_112/141S4976_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/141S4976_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.6598377737769469,1.7956448156856797,1.3006220077852035,val
+153S2109_M00_fdg_pet,153S2109,M00,fdgpet_M00_112/fdgpet_M00_112/153S2109_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/153S2109_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.5687621825519092,1.4451423568470425,1.0767287103965644,val
+153S4125_M00_fdg_pet,153S4125,M00,fdgpet_M00_112/fdgpet_M00_112/153S4125_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/153S4125_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.6868296367366139,1.6014197928006533,1.167998578932741,val
+153S4139_M00_fdg_pet,153S4139,M00,fdgpet_M00_112/fdgpet_M00_112/153S4139_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/153S4139_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.5859117558933197,1.7202189263691472,1.2340255902012656,val
+153S4372_M00_fdg_pet,153S4372,M00,fdgpet_M00_112/fdgpet_M00_112/153S4372_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/153S4372_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.7064865030706885,1.516750693321228,1.1699427077555888,val
+941S1194_M00_fdg_pet,941S1194,M00,fdgpet_M00_112/fdgpet_M00_112/941S1194_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/941S1194_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.55352024343562,1.7806404649613294,1.2293535351933855,val
+941S1195_M00_fdg_pet,941S1195,M00,fdgpet_M00_112/fdgpet_M00_112/941S1195_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/941S1195_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.4789982352027281,1.47586802134528,1.1170504416312104,val
+941S1203_M00_fdg_pet,941S1203,M00,fdgpet_M00_112/fdgpet_M00_112/941S1203_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/941S1203_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.6127659063562421,1.5401486158370972,1.107546502340703,val
+941S4036_M00_fdg_pet,941S4036,M00,fdgpet_M00_112/fdgpet_M00_112/941S4036_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/941S4036_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.4613087700012533,1.7614303763330037,1.245207389085386,val
+941S4255_M00_fdg_pet,941S4255,M00,fdgpet_M00_112/fdgpet_M00_112/941S4255_M00_fdg_pet.nii.gz,petfdg_suvr_csv/petfdg_suvr_csv/941S4255_M00_fdg_pet.csv,112x128x112,1.5x1.5x1.5,float32,121,0.3891148694696273,1.3502883911132812,1.0257422868697763,val

requirements.txt

@@ -0,0 +1,5 @@
+nibabel
+numpy
+pandas
+torch
+scikit-learn

scripts/bootstrap_all_baselines.py

@@ -0,0 +1,174 @@
+"""Bootstrap 95% CI for ALL frozen baseline encoders (Stage-1 only: MAE + R@1).
+
+Runs 1000-resample bootstrap on the 153-subject test set for each baseline.
+
+Usage (from /data/Albus/Brain):
+    CUDA_VISIBLE_DEVICES=2 python scripts/bootstrap_all_baselines.py
+"""
+from __future__ import annotations
+
+import sys
+import time
+from pathlib import Path
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+from torch.utils.data import DataLoader
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from pet_vlm_dataset import PETSUVRDataset, collate_pet_suvr
+from train_pet_foundation import PETSUVRFoundationModel, build_encoder
+
+
+# -- baselines ---------------------------------------------------------------
+BASELINES = [
+    ("MedicalNet frozen",  "runs/foundation/medicalnet_frozen_mlp.pt"),
+    ("BrainIAC frozen",    "runs/foundation/brainiac_frozen_mlp.pt"),
+    ("BrainFM frozen",     "runs/foundation/brainfm_frozen_mlp_b4_best.pt"),
+    ("SAM-Med3D frozen",   "runs/foundation/sam_med3d_frozen_mlp_best.pt"),
+    ("SwinUNETR frozen",   "runs/foundation/swinunetr_frozen_mlp_best.pt"),
+]
+
+TEST_MANIFEST = Path("metadata/splits/test.csv")
+B = 1000
+SEED = 42
+BATCH_SIZE = 4
+
+
+def _retrieval_recall_at_1(logits: np.ndarray) -> float:
+    ranks = []
+    for i in range(logits.shape[0]):
+        order = np.argsort(-logits[i])
+        rank = int(np.where(order == i)[0][0]) + 1
+        ranks.append(rank)
+    return float(np.mean(np.asarray(ranks) <= 1))
+
+
+@torch.no_grad()
+def collect_stage1(model, loader, device):
+    model.eval()
+    pred_c, tgt_c, pz_c, sz_c = [], [], [], []
+    for batch in loader:
+        image = batch["image"].to(device, non_blocking=True)
+        suvr  = batch["suvr"].to(device, non_blocking=True)
+        outputs = model(image, suvr)
+        pred_c.append(outputs["pred_suvr"].cpu().numpy())
+        tgt_c.append(suvr.cpu().numpy())
+        pet_feat = model.pet_encoder(image)
+        pet_z  = F.normalize(model.pet_projector(pet_feat), dim=-1)
+        suvr_z = F.normalize(model.suvr_encoder(suvr), dim=-1)
+        pz_c.append(pet_z.cpu().numpy())
+        sz_c.append(suvr_z.cpu().numpy())
+    return {
+        "pred":   np.concatenate(pred_c),
+        "target": np.concatenate(tgt_c),
+        "pet_z":  np.concatenate(pz_c),
+        "suvr_z": np.concatenate(sz_c),
+    }
+
+
+def stage1_metrics(d, idx):
+    pred   = d["pred"][idx]
+    target = d["target"][idx]
+    uid    = np.unique(idx)
+    logits = d["pet_z"][uid] @ d["suvr_z"][uid].T
+    return {
+        "mae":         float(np.mean(np.abs(pred - target))),
+        "pet_suvr_r1": _retrieval_recall_at_1(logits),
+    }
+
+
+def bootstrap_ci(metric_fn, n, B=1000, seed=42):
+    rng = np.random.RandomState(seed)
+    all_idx = np.arange(n)
+    point = metric_fn(all_idx)
+    boots = np.empty(B)
+    for b in range(B):
+        idx = rng.choice(n, size=n, replace=True)
+        boots[b] = metric_fn(idx)
+    lo = float(np.percentile(boots, 2.5))
+    hi = float(np.percentile(boots, 97.5))
+    return point, lo, hi
+
+
+def load_model(ckpt_path, device):
+    ckpt = torch.load(ckpt_path, map_location="cpu", weights_only=False)
+    saved = ckpt.get("args", {})
+
+    class _A:
+        pass
+
+    a = _A()
+    a.backbone           = saved.get("backbone", "medicalnet")
+    a.medicalnet_weights = Path(saved.get("medicalnet_weights",
+                                          "pretrained/medicalnet/resnet_50_23dataset.pth"))
+    a.brainiac_weights   = Path(saved.get("brainiac_weights",
+                                          "pretrained/brainiac/backbone.safetensors"))
+    a.brainfm_weights    = Path(saved.get("brainfm_weights",
+                                          "pretrained/brainfm/assets/brainfm_pretrained.pth"))
+    a.brainfm_code_root  = Path(saved.get("brainfm_code_root", "pretrained/brainfm"))
+    a.swinunetr_weights  = Path(saved.get("swinunetr_weights",
+                                          "pretrained/swinunetr/model_swinvit.pt"))
+    a.sam_med3d_weights  = Path(saved.get("sam_med3d_weights",
+                                          "pretrained/sam-med3d/sam_med3d_turbo.pth"))
+    a.output_size        = tuple(saved.get("output_size", (96, 96, 96)))
+    embed_dim            = saved.get("embed_dim", 256)
+    freeze               = bool(saved.get("freeze_encoder", False))
+
+    ds_tmp    = PETSUVRDataset(TEST_MANIFEST, output_size=a.output_size)
+    n_regions = int(ds_tmp[0]["suvr"].numel())
+    encoder   = build_encoder(a)
+    model     = PETSUVRFoundationModel(encoder, n_regions, embed_dim, freeze).to(device)
+    model.load_state_dict(ckpt["model"], strict=True)
+    model.eval()
+    return model, a.output_size
+
+
+def main():
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"Device: {device}", flush=True)
+
+    results = []
+    for name, ckpt_path in BASELINES:
+        t0 = time.time()
+        print(f"\n{'='*60}", flush=True)
+        print(f"  {name}  ({ckpt_path})", flush=True)
+        print(f"{'='*60}", flush=True)
+
+        model, output_size = load_model(ckpt_path, device)
+        bs = 2 if "sam_med3d" in ckpt_path else BATCH_SIZE
+        ds     = PETSUVRDataset(TEST_MANIFEST, output_size=output_size)
+        loader = DataLoader(ds, batch_size=bs, shuffle=False,
+                            num_workers=2, collate_fn=collate_pet_suvr)
+        d = collect_stage1(model, loader, device)
+        N = d["pred"].shape[0]
+        print(f"  N = {N}", flush=True)
+
+        for metric_name in ("mae", "pet_suvr_r1"):
+            fn = lambda idx, _m=metric_name: stage1_metrics(d, idx)[_m]
+            pt, lo, hi = bootstrap_ci(fn, N, B=B, seed=SEED)
+            print(f"  {metric_name:20s}  {pt:.4f}   95% CI [{lo:.4f}, {hi:.4f}]", flush=True)
+            results.append((name, metric_name, pt, lo, hi))
+
+        # free GPU memory
+        del model
+        torch.cuda.empty_cache()
+        print(f"  elapsed: {time.time()-t0:.1f}s", flush=True)
+
+    # ---- summary table ----
+    print(f"\n\n{'='*70}", flush=True)
+    print(f"SUMMARY: Bootstrap 95% CI  (B={B}, seed={SEED})", flush=True)
+    print(f"{'='*70}", flush=True)
+    print(f"{'Model':<22s}  {'MAE':>8s}  {'MAE 95% CI':>18s}  {'R@1':>8s}  {'R@1 95% CI':>18s}", flush=True)
+    print("-"*70, flush=True)
+    for i in range(0, len(results), 2):
+        nm = results[i][0]
+        mae_pt, mae_lo, mae_hi = results[i][2], results[i][3], results[i][4]
+        r1_pt,  r1_lo,  r1_hi  = results[i+1][2], results[i+1][3], results[i+1][4]
+        print(f"{nm:<22s}  {mae_pt:8.4f}  [{mae_lo:.4f}, {mae_hi:.4f}]  {r1_pt:8.4f}  [{r1_lo:.4f}, {r1_hi:.4f}]", flush=True)
+    print(f"{'='*70}", flush=True)
+
+
+if __name__ == "__main__":
+    main()

scripts/bootstrap_ci.py

@@ -0,0 +1,343 @@
+"""Bootstrap 95 % confidence intervals for ReMAP-PET key metrics.
+
+Stage-1 metrics (153 test subjects):
+    - SUVR MAE
+    - Pearson r (voxel-level across all subjects x regions)
+    - PET->SUVR Recall@1  (retrieval)
+
+Clinical probe metrics:
+    - AD vs CN AUROC  (logistic regression on PET embeddings)
+    - 3-way (CN/MCI/AD) AUROC
+
+Usage (from /data/Albus/Brain):
+    CUDA_VISIBLE_DEVICES=1 python scripts/bootstrap_ci.py
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+import torch
+import torch.nn.functional as F
+from torch.utils.data import DataLoader
+from sklearn.linear_model import LogisticRegression
+from sklearn.metrics import balanced_accuracy_score, roc_auc_score
+from sklearn.pipeline import make_pipeline
+from sklearn.preprocessing import LabelEncoder, StandardScaler, label_binarize
+
+# -- project imports (scripts/ is the working dir's sibling) -----------------
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from pet_vlm_dataset import PETSUVRDataset, collate_pet_suvr
+from train_pet_foundation import PETSUVRFoundationModel, build_encoder
+
+
+# ---------------------------------------------------------------------------
+# helpers copied from evaluate_pet_foundation.py
+# ---------------------------------------------------------------------------
+
+def _pearson_flat(pred: np.ndarray, target: np.ndarray) -> float:
+    p = pred.reshape(-1)
+    t = target.reshape(-1)
+    if p.std() < 1e-8 or t.std() < 1e-8:
+        return float("nan")
+    return float(np.corrcoef(p, t)[0, 1])
+
+
+def _retrieval_recall_at_1(logits: np.ndarray) -> float:
+    ranks = []
+    for i in range(logits.shape[0]):
+        order = np.argsort(-logits[i])
+        rank = int(np.where(order == i)[0][0]) + 1
+        ranks.append(rank)
+    return float(np.mean(np.asarray(ranks) <= 1))
+
+
+# ---------------------------------------------------------------------------
+# Stage-1: forward pass -> per-subject arrays
+# ---------------------------------------------------------------------------
+
+@torch.no_grad()
+def collect_stage1(
+    model: PETSUVRFoundationModel,
+    loader: DataLoader,
+    device: torch.device,
+) -> dict[str, np.ndarray]:
+    """Return pred_suvr, target_suvr, pet_z, suvr_z  (all numpy, N-first)."""
+    model.eval()
+    pred_chunks, target_chunks = [], []
+    pet_z_chunks, suvr_z_chunks = [], []
+
+    for batch in loader:
+        image = batch["image"].to(device, non_blocking=True)
+        suvr = batch["suvr"].to(device, non_blocking=True)
+        outputs = model(image, suvr)
+        pred_chunks.append(outputs["pred_suvr"].cpu().numpy())
+        target_chunks.append(suvr.cpu().numpy())
+
+        pet_feat = model.pet_encoder(image)
+        pet_z = F.normalize(model.pet_projector(pet_feat), dim=-1)
+        suvr_z = F.normalize(model.suvr_encoder(suvr), dim=-1)
+        pet_z_chunks.append(pet_z.cpu().numpy())
+        suvr_z_chunks.append(suvr_z.cpu().numpy())
+
+    return {
+        "pred":   np.concatenate(pred_chunks,   axis=0),
+        "target": np.concatenate(target_chunks, axis=0),
+        "pet_z":  np.concatenate(pet_z_chunks,  axis=0),
+        "suvr_z": np.concatenate(suvr_z_chunks, axis=0),
+    }
+
+
+def stage1_metrics(d: dict[str, np.ndarray], idx: np.ndarray) -> dict[str, float]:
+    """Compute stage-1 metrics on a subset given by *idx*.
+
+    MAE and Pearson work fine with duplicate indices (bootstrap).
+    For retrieval R@1 we need unique subjects (duplicates would make the
+    diagonal ground-truth ambiguous), so we deduplicate *idx* first.
+    """
+    pred   = d["pred"][idx]
+    target = d["target"][idx]
+
+    # retrieval: use unique indices only
+    uid = np.unique(idx)
+    pet_z  = d["pet_z"][uid]
+    suvr_z = d["suvr_z"][uid]
+    logits = pet_z @ suvr_z.T
+
+    return {
+        "mae":     float(np.mean(np.abs(pred - target))),
+        "pearson": _pearson_flat(pred, target),
+        "pet_suvr_r1": _retrieval_recall_at_1(logits),
+    }
+
+
+# ---------------------------------------------------------------------------
+# Clinical: extract embeddings, train probe, evaluate
+# ---------------------------------------------------------------------------
+
+@torch.no_grad()
+def extract_embeddings(
+    model: PETSUVRFoundationModel,
+    manifest: Path,
+    output_size: tuple[int, int, int],
+    batch_size: int,
+    num_workers: int,
+    device: torch.device,
+) -> tuple[pd.DataFrame, np.ndarray]:
+    dataset = PETSUVRDataset(manifest, output_size=output_size)
+    loader  = DataLoader(dataset, batch_size=batch_size, shuffle=False,
+                         num_workers=num_workers, collate_fn=collate_pet_suvr)
+    feats = []
+    model.eval()
+    for batch in loader:
+        image = batch["image"].to(device, non_blocking=True)
+        pet_feat = model.pet_encoder(image)
+        pet_z = F.normalize(model.pet_projector(pet_feat), dim=-1)
+        feats.append(pet_z.cpu().numpy())
+    return pd.read_csv(manifest), np.concatenate(feats, axis=0)
+
+
+def _subset_cls(df, x, column, labels):
+    mask = df[column].isin(labels).to_numpy()
+    return x[mask], df.loc[mask, column].astype(str).to_numpy()
+
+
+def train_probe(x_train, y_train, x_val, y_val):
+    """Train logistic probe with C sweep; return best model + encoder."""
+    enc = LabelEncoder()
+    enc.fit(np.concatenate([y_train, y_val]))
+    y_tr = enc.transform(y_train)
+    y_v  = enc.transform(y_val)
+    best_m, best_s = None, -np.inf
+    for c in [0.01, 0.03, 0.1, 0.3, 1.0, 3.0, 10.0]:
+        m = make_pipeline(StandardScaler(),
+                          LogisticRegression(C=c, max_iter=5000,
+                                            class_weight="balanced"))
+        m.fit(x_train, y_tr)
+        s = balanced_accuracy_score(y_v, m.predict(x_val))
+        if s > best_s:
+            best_m, best_s = m, s
+    return best_m, enc
+
+
+def clinical_auroc(model_probe, encoder, x_test, y_test):
+    """Return AUROC (binary or macro-OVR)."""
+    y_int = encoder.transform(y_test)
+    proba = model_probe.predict_proba(x_test)
+    if len(encoder.classes_) == 2:
+        return roc_auc_score(y_int, proba[:, 1])
+    else:
+        y_bin = label_binarize(y_int, classes=np.arange(len(encoder.classes_)))
+        return roc_auc_score(y_bin, proba, average="macro", multi_class="ovr")
+
+
+# ---------------------------------------------------------------------------
+# Bootstrap
+# ---------------------------------------------------------------------------
+
+def bootstrap_ci(
+    metric_fn,
+    n: int,
+    B: int = 1000,
+    seed: int = 42,
+    alpha: float = 0.05,
+) -> tuple[float, float, float]:
+    """
+    metric_fn(idx) -> float   where idx is array of resampled indices.
+    Returns (point_estimate, lo, hi) for the (1-alpha) CI.
+    """
+    rng = np.random.RandomState(seed)
+    all_idx = np.arange(n)
+    point = metric_fn(all_idx)
+    boots = np.empty(B)
+    for b in range(B):
+        idx = rng.choice(n, size=n, replace=True)
+        boots[b] = metric_fn(idx)
+    lo = float(np.percentile(boots, 100 * alpha / 2))
+    hi = float(np.percentile(boots, 100 * (1 - alpha / 2)))
+    return point, lo, hi
+
+
+def bootstrap_clinical_auroc(
+    probe, encoder,
+    x_train, y_train_raw,
+    x_val, y_val_raw,
+    x_test, y_test_raw,
+    B: int = 1000,
+    seed: int = 42,
+    alpha: float = 0.05,
+) -> tuple[float, float, float]:
+    """
+    Bootstrap over the *test* set only (probe is fixed).
+    """
+    rng = np.random.RandomState(seed)
+    n = len(y_test_raw)
+    all_idx = np.arange(n)
+    point = clinical_auroc(probe, encoder, x_test, y_test_raw)
+
+    boots = np.empty(B)
+    for b in range(B):
+        idx = rng.choice(n, size=n, replace=True)
+        try:
+            boots[b] = clinical_auroc(probe, encoder, x_test[idx], y_test_raw[idx])
+        except ValueError:
+            # can happen if a resample has only one class
+            boots[b] = np.nan
+    boots = boots[~np.isnan(boots)]
+    lo = float(np.percentile(boots, 100 * alpha / 2))
+    hi = float(np.percentile(boots, 100 * (1 - alpha / 2)))
+    return point, lo, hi
+
+
+# ---------------------------------------------------------------------------
+# main
+# ---------------------------------------------------------------------------
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--checkpoint", type=Path,
+                        default=Path("runs/foundation/medicalnet_layer4_regalign_best.pt"))
+    parser.add_argument("--test-manifest", type=Path,
+                        default=Path("metadata/splits/test.csv"))
+    parser.add_argument("--train-clinical", type=Path,
+                        default=Path("data/metadata/splits/train_clinical_server.csv"))
+    parser.add_argument("--val-clinical", type=Path,
+                        default=Path("data/metadata/splits/val_clinical_server.csv"))
+    parser.add_argument("--test-clinical", type=Path,
+                        default=Path("data/metadata/splits/test_clinical_server.csv"))
+    parser.add_argument("--batch-size", type=int, default=4)
+    parser.add_argument("--num-workers", type=int, default=2)
+    parser.add_argument("--B", type=int, default=1000, help="bootstrap resamples")
+    parser.add_argument("--seed", type=int, default=42)
+    args = parser.parse_args()
+
+    # ---- load model -------------------------------------------------------
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    ckpt = torch.load(args.checkpoint, map_location="cpu", weights_only=False)
+    saved = ckpt.get("args", {})
+
+    class _Args:
+        pass
+    margs = _Args()
+    margs.backbone = saved.get("backbone", "medicalnet")
+    margs.medicalnet_weights = Path(saved.get("medicalnet_weights",
+                                               "pretrained/medicalnet/resnet_50_23dataset.pth"))
+    margs.brainiac_weights = Path(saved.get("brainiac_weights",
+                                             "pretrained/brainiac/backbone.safetensors"))
+    margs.brainfm_weights = Path("pretrained/brainfm/assets/brainfm_pretrained.pth")
+    margs.brainfm_code_root = Path("pretrained/brainfm")
+    margs.swinunetr_weights = Path("pretrained/swinunetr/model_swinvit.pt")
+    margs.sam_med3d_weights = Path("pretrained/sam-med3d/sam_med3d_turbo.pth")
+    margs.output_size = tuple(saved.get("output_size", (96, 96, 96)))
+    embed_dim = saved.get("embed_dim", 256)
+    freeze_encoder = bool(saved.get("freeze_encoder", False))
+
+    output_size = margs.output_size
+
+    # build model
+    dataset_tmp = PETSUVRDataset(args.test_manifest, output_size=output_size)
+    n_regions = int(dataset_tmp[0]["suvr"].numel())
+    encoder = build_encoder(margs)
+    model = PETSUVRFoundationModel(encoder, n_regions, embed_dim, freeze_encoder).to(device)
+    model.load_state_dict(ckpt["model"], strict=True)
+    model.eval()
+    print(f"Loaded checkpoint: {args.checkpoint}", flush=True)
+    print(f"backbone={margs.backbone}  embed_dim={embed_dim}  "
+          f"freeze={freeze_encoder}  output_size={output_size}", flush=True)
+
+    # ===== STAGE 1 =========================================================
+    print("\n===== Stage-1 evaluation (test set) =====", flush=True)
+    test_ds = PETSUVRDataset(args.test_manifest, output_size=output_size)
+    test_loader = DataLoader(test_ds, batch_size=args.batch_size, shuffle=False,
+                             num_workers=args.num_workers, collate_fn=collate_pet_suvr)
+    d = collect_stage1(model, test_loader, device)
+    N = d["pred"].shape[0]
+    print(f"  N = {N}", flush=True)
+
+    for name in ("mae", "pearson", "pet_suvr_r1"):
+        fn = lambda idx, _n=name: stage1_metrics(d, idx)[_n]
+        pt, lo, hi = bootstrap_ci(fn, N, B=args.B, seed=args.seed)
+        print(f"  {name:20s}  {pt:.4f}   95% CI [{lo:.4f}, {hi:.4f}]", flush=True)
+
+    # ===== CLINICAL ========================================================
+    print("\n===== Clinical downstream probes =====", flush=True)
+    train_df, x_train_all = extract_embeddings(
+        model, args.train_clinical, output_size, args.batch_size, args.num_workers, device)
+    val_df, x_val_all = extract_embeddings(
+        model, args.val_clinical, output_size, args.batch_size, args.num_workers, device)
+    test_df, x_test_all = extract_embeddings(
+        model, args.test_clinical, output_size, args.batch_size, args.num_workers, device)
+
+    # ---- AD vs CN ---------------------------------------------------------
+    print("\n  -- AD vs CN --", flush=True)
+    x_tr, y_tr = _subset_cls(train_df, x_train_all, "clinical_label", ["CN", "AD"])
+    x_v,  y_v  = _subset_cls(val_df,   x_val_all,   "clinical_label", ["CN", "AD"])
+    x_te, y_te = _subset_cls(test_df,  x_test_all,  "clinical_label", ["CN", "AD"])
+    print(f"     train={len(y_tr)}  val={len(y_v)}  test={len(y_te)}", flush=True)
+    probe_ad, enc_ad = train_probe(x_tr, y_tr, x_v, y_v)
+    pt, lo, hi = bootstrap_clinical_auroc(
+        probe_ad, enc_ad, x_tr, y_tr, x_v, y_v, x_te, y_te,
+        B=args.B, seed=args.seed)
+    print(f"     {'ad_vs_cn_auroc':20s}  {pt:.4f}   95% CI [{lo:.4f}, {hi:.4f}]", flush=True)
+
+    # ---- 3-way CN / MCI / AD ---------------------------------------------
+    print("\n  -- 3-way (CN / MCI / AD) --", flush=True)
+    x_tr3, y_tr3 = _subset_cls(train_df, x_train_all, "clinical_label", ["CN", "MCI", "AD"])
+    x_v3,  y_v3  = _subset_cls(val_df,   x_val_all,   "clinical_label", ["CN", "MCI", "AD"])
+    x_te3, y_te3 = _subset_cls(test_df,  x_test_all,  "clinical_label", ["CN", "MCI", "AD"])
+    print(f"     train={len(y_tr3)}  val={len(y_v3)}  test={len(y_te3)}", flush=True)
+    probe_3w, enc_3w = train_probe(x_tr3, y_tr3, x_v3, y_v3)
+    pt, lo, hi = bootstrap_clinical_auroc(
+        probe_3w, enc_3w, x_tr3, y_tr3, x_v3, y_v3, x_te3, y_te3,
+        B=args.B, seed=args.seed)
+    print(f"     {'3way_auroc':20s}  {pt:.4f}   95% CI [{lo:.4f}, {hi:.4f}]", flush=True)
+
+    print("\nDone.", flush=True)
+
+
+if __name__ == "__main__":
+    main()

scripts/evaluate_pet_text_alignment.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+import argparse
+import csv
+from pathlib import Path
+
+import numpy as np
+import torch
+from torch.utils.data import DataLoader
+
+from train_pet_text_alignment import PETTextAlignmentModel, PETTextDataset, collate_pet_text, load_pet_model
+
+
+def retrieval_metrics(logits: np.ndarray) -> dict[str, float]:
+    ranks = []
+    for i in range(logits.shape[0]):
+        order = np.argsort(-logits[i])
+        ranks.append(int(np.where(order == i)[0][0]) + 1)
+    ranks = np.asarray(ranks)
+    return {
+        "recall@1": float(np.mean(ranks <= 1)),
+        "recall@5": float(np.mean(ranks <= 5)),
+        "recall@10": float(np.mean(ranks <= 10)),
+        "mrr": float(np.mean(1.0 / ranks)),
+        "median_rank": float(np.median(ranks)),
+    }
+
+
+def split_regions(value: str) -> set[str]:
+    return {item for item in str(value).split("|") if item}
+
+
+def factuality(logits: np.ndarray, lows: list[str], highs: list[str], k: int = 5) -> dict[str, float]:
+    top_text = np.argmax(logits, axis=1)
+    low_scores = []
+    high_scores = []
+    for query_idx, text_idx in enumerate(top_text.tolist()):
+        query_low = split_regions(lows[query_idx])
+        query_high = split_regions(highs[query_idx])
+        text_low = split_regions(lows[text_idx])
+        text_high = split_regions(highs[text_idx])
+        low_scores.append(len(query_low & text_low) / max(min(k, len(query_low)), 1))
+        high_scores.append(len(query_high & text_high) / max(min(k, len(query_high)), 1))
+    return {
+        "retrieved_text_low_overlap": float(np.mean(low_scores)),
+        "retrieved_text_high_overlap": float(np.mean(high_scores)),
+    }
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Evaluate controlled PET-to-region-text alignment.")
+    parser.add_argument("--checkpoint", type=Path, required=True)
+    parser.add_argument("--test-csv", type=Path, required=True)
+    parser.add_argument("--csv-out", type=Path, default=None)
+    parser.add_argument("--batch-size", type=int, default=8)
+    parser.add_argument("--num-workers", type=int, default=2)
+    parser.add_argument("--max-length", type=int, default=None)
+    args = parser.parse_args()
+
+    from transformers import AutoTokenizer
+
+    ckpt = torch.load(args.checkpoint, map_location="cpu", weights_only=False)
+    saved = argparse.Namespace(**ckpt["args"])
+    saved.train_csv = saved.train_csv
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    pet_model = load_pet_model(saved.pet_checkpoint, saved, device)
+    tokenizer = AutoTokenizer.from_pretrained(saved.text_model)
+    model = PETTextAlignmentModel(pet_model, saved.text_model, saved.embed_dim or 256).to(device)
+    model.load_state_dict(ckpt["model"], strict=True)
+    model.eval()
+
+    output_size = tuple(saved.output_size)
+    dataset = PETTextDataset(args.test_csv, output_size=output_size)
+    loader = DataLoader(dataset, batch_size=args.batch_size, shuffle=False, num_workers=args.num_workers, collate_fn=collate_pet_text)
+    pet_chunks = []
+    text_chunks = []
+    lows: list[str] = []
+    highs: list[str] = []
+    max_length = args.max_length or saved.max_length
+
+    with torch.no_grad():
+        for batch in loader:
+            image = batch["image"].to(device, non_blocking=True)
+            tokens = tokenizer(batch["text"], padding=True, truncation=True, max_length=max_length, return_tensors="pt")
+            tokens = {k: v.to(device) for k, v in tokens.items()}
+            pet_chunks.append(model.encode_pet(image).cpu())
+            text_chunks.append(model.encode_text(tokens).cpu())
+            lows.extend(batch["low_regions"])
+            highs.extend(batch["high_regions"])
+
+    pet_z = torch.cat(pet_chunks, dim=0)
+    text_z = torch.cat(text_chunks, dim=0)
+    logits = (pet_z @ text_z.T).numpy()
+    metrics = {"samples": float(logits.shape[0])}
+    metrics.update({f"pet_to_text_{k}": v for k, v in retrieval_metrics(logits).items()})
+    metrics.update({f"text_to_pet_{k}": v for k, v in retrieval_metrics(logits.T).items()})
+    metrics.update(factuality(logits, lows, highs))
+
+    for key, value in metrics.items():
+        print(f"{key}={value:.6f}")
+
+    if args.csv_out:
+        args.csv_out.parent.mkdir(parents=True, exist_ok=True)
+        write_header = not args.csv_out.exists()
+        with args.csv_out.open("a", newline="", encoding="utf-8") as f:
+            writer = csv.DictWriter(f, fieldnames=["checkpoint", "test_csv", *metrics.keys()])
+            if write_header:
+                writer.writeheader()
+            writer.writerow({"checkpoint": str(args.checkpoint), "test_csv": str(args.test_csv), **metrics})
+
+
+if __name__ == "__main__":
+    main()

scripts/export_case_study.py

@@ -0,0 +1,92 @@
+"""Export one test subject's data for Figure 4 case study."""
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+import nibabel as nib
+import numpy as np
+import pandas as pd
+import torch
+from torch.utils.data import DataLoader
+
+from pet_vlm_dataset import PETSUVRDataset, collate_pet_suvr
+from train_pet_foundation import PETSUVRFoundationModel, build_encoder
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--checkpoint", type=Path, required=True)
+    parser.add_argument("--split", type=Path, default=Path("data/metadata/splits/test.csv"))
+    parser.add_argument("--subject-index", type=int, default=0, help="which test subject to use (0=first)")
+    parser.add_argument("--backbone", default=None)
+    parser.add_argument("--medicalnet-weights", type=Path, default=Path("pretrained/medicalnet/resnet_50_23dataset.pth"))
+    parser.add_argument("--batch-size", type=int, default=1)
+    parser.add_argument("--num-workers", type=int, default=0)
+    parser.add_argument("--output-size", type=int, nargs=3, default=None)
+    parser.add_argument("--embed-dim", type=int, default=None)
+    parser.add_argument("--freeze-encoder", type=bool, default=None)
+    parser.add_argument("--out", type=Path, required=True)
+    args = parser.parse_args()
+
+    ckpt = torch.load(args.checkpoint, map_location="cpu", weights_only=False)
+    saved_args = ckpt.get("args", {})
+    for name in ("backbone", "embed_dim", "freeze_encoder"):
+        if getattr(args, name, None) is None and name in saved_args:
+            setattr(args, name, saved_args[name])
+    if args.output_size is None:
+        args.output_size = tuple(saved_args.get("output_size", (96, 96, 96)))
+
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    manifest = pd.read_csv(args.split)
+    row = manifest.iloc[args.subject_index]
+
+    dataset = PETSUVRDataset(args.split, output_size=tuple(args.output_size))
+    sample = dataset[args.subject_index]
+    n_regions = int(sample["suvr"].numel())
+
+    encoder = build_encoder(args)
+    model = PETSUVRFoundationModel(encoder, n_regions, args.embed_dim or 256, bool(args.freeze_encoder)).to(device)
+    model.load_state_dict(ckpt["model"], strict=True)
+    model.eval()
+
+    image = sample["image"].unsqueeze(0).to(device)
+    suvr = sample["suvr"].unsqueeze(0).to(device)
+
+    with torch.no_grad():
+        outputs = model(image, suvr)
+
+    true_suvr_arr = suvr.cpu().numpy().flatten()
+    pred_suvr_arr = outputs["pred_suvr"].cpu().numpy().flatten()
+
+    # Load PET volume for slice extraction
+    pet_path = str(row["pet_path"])
+    pet_vol = nib.load(pet_path).get_fdata(dtype=np.float32)
+    # Extract middle slices in each orientation
+    d, h, w = pet_vol.shape
+    axial_slice = pet_vol[d // 2, :, :]
+    coronal_slice = pet_vol[:, h // 2, :]
+    sagittal_slice = pet_vol[:, :, w // 2]
+
+    # Load region labels from SUVR CSV
+    suvr_csv_path = str(row["suvr_csv_path"])
+    suvr_df = pd.read_csv(suvr_csv_path)
+    region_labels = [str(lbl) for lbl in suvr_df["label_name"].tolist() if str(lbl) != "Background"]
+
+    args.out.parent.mkdir(parents=True, exist_ok=True)
+    np.savez(args.out,
+             subject_id=str(row["sample_id"]),
+             true_suvr=true_suvr_arr,
+             pred_suvr=pred_suvr_arr,
+             region_labels=np.array(region_labels, dtype=object),
+             axial_slice=axial_slice,
+             coronal_slice=coronal_slice,
+             sagittal_slice=sagittal_slice)
+    print(f"wrote case study for subject {row['sample_id']} to {args.out}")
+    print(f"  true SUVR range: [{true_suvr_arr.min():.3f}, {true_suvr_arr.max():.3f}]")
+    print(f"  pred SUVR range: [{pred_suvr_arr.min():.3f}, {pred_suvr_arr.max():.3f}]")
+    print(f"  PET shape: {pet_vol.shape}, slices extracted")
+
+
+if __name__ == "__main__":
+    main()

scripts/export_embeddings.py

@@ -0,0 +1,81 @@
+"""Export PET and SUVR embeddings from Stage 1 checkpoints for Figure 2."""
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+import numpy as np
+import torch
+from torch.utils.data import DataLoader
+
+from pet_vlm_dataset import PETSUVRDataset, collate_pet_suvr
+from train_pet_foundation import PETSUVRFoundationModel, build_encoder
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--checkpoint", type=Path, required=True)
+    parser.add_argument("--split", type=Path, default=Path("data/metadata/splits/test.csv"))
+    parser.add_argument("--backbone", default=None)
+    parser.add_argument("--medicalnet-weights", type=Path, default=Path("pretrained/medicalnet/resnet_50_23dataset.pth"))
+    parser.add_argument("--brainfm-weights", type=Path, default=Path("pretrained/brainfm/assets/brainfm_pretrained.pth"))
+    parser.add_argument("--brainfm-code-root", type=Path, default=Path("pretrained/brainfm"))
+    parser.add_argument("--batch-size", type=int, default=4)
+    parser.add_argument("--num-workers", type=int, default=2)
+    parser.add_argument("--output-size", type=int, nargs=3, default=None)
+    parser.add_argument("--embed-dim", type=int, default=None)
+    parser.add_argument("--freeze-encoder", type=bool, default=None)
+    parser.add_argument("--out", type=Path, required=True)
+    args = parser.parse_args()
+
+    ckpt = torch.load(args.checkpoint, map_location="cpu", weights_only=False)
+    saved_args = ckpt.get("args", {})
+    for name in ("backbone", "embed_dim", "freeze_encoder"):
+        if getattr(args, name, None) is None and name in saved_args:
+            setattr(args, name, saved_args[name])
+    if args.output_size is None:
+        args.output_size = tuple(saved_args.get("output_size", (96, 96, 96)))
+
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    dataset = PETSUVRDataset(args.split, output_size=tuple(args.output_size))
+    loader = DataLoader(dataset, batch_size=args.batch_size, shuffle=False,
+                        num_workers=args.num_workers, collate_fn=collate_pet_suvr)
+    n_regions = int(dataset[0]["suvr"].numel())
+
+    encoder = build_encoder(args)
+    model = PETSUVRFoundationModel(encoder, n_regions, args.embed_dim or 256, bool(args.freeze_encoder)).to(device)
+    model.load_state_dict(ckpt["model"], strict=True)
+    model.eval()
+
+    pet_embeddings = []
+    suvr_embeddings = []
+    pred_suvr = []
+    true_suvr = []
+
+    with torch.no_grad():
+        for batch in loader:
+            image = batch["image"].to(device)
+            suvr = batch["suvr"].to(device)
+            outputs = model(image, suvr)
+
+            pet_feat = model.pet_encoder(image)
+            pet_z = torch.nn.functional.normalize(model.pet_projector(pet_feat), dim=-1)
+            suvr_z = torch.nn.functional.normalize(model.suvr_encoder(suvr), dim=-1)
+
+            pet_embeddings.append(pet_z.cpu().numpy())
+            suvr_embeddings.append(suvr_z.cpu().numpy())
+            pred_suvr.append(outputs["pred_suvr"].cpu().numpy())
+            true_suvr.append(suvr.cpu().numpy())
+
+    pet_z = np.concatenate(pet_embeddings, axis=0)
+    suvr_z = np.concatenate(suvr_embeddings, axis=0)
+    pred = np.concatenate(pred_suvr, axis=0)
+    true = np.concatenate(true_suvr, axis=0)
+
+    args.out.parent.mkdir(parents=True, exist_ok=True)
+    np.savez(args.out, pet_z=pet_z, suvr_z=suvr_z, pred_suvr=pred, true_suvr=true)
+    print(f"wrote {pet_z.shape[0]} samples, pet_z={pet_z.shape}, suvr_z={suvr_z.shape} to {args.out}")
+
+
+if __name__ == "__main__":
+    main()

scripts/launch_retrain.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+cd /data/Albus/Brain
+CUDA_VISIBLE_DEVICES=1 /data/Albus/miniconda3/bin/python -u scripts/train_pet_foundation_epoch_ckpt.py   --backbone medicalnet --encoder-train-scope layer4 --epochs 50 --batch-size 4 --lr 1e-5   --num-workers 2 --output-size 96 96 96 --contrastive-weight 0.2 --regression-weight 1.0   --train-csv metadata/splits/train.csv --val-csv metadata/splits/val.csv   --out-dir runs/foundation/remap_epochs   > logs/remap_epoch_training.log 2>&1

scripts/match_adni_metadata.py

@@ -0,0 +1,263 @@
+from __future__ import annotations
+
+import argparse
+import re
+from pathlib import Path
+
+import pandas as pd
+
+
+FULL_COLUMNS = [
+    "RID",
+    "PTID",
+    "label",
+    "VISCODE",
+    "EXAMDATE",
+    "DX_bl",
+    "DX",
+    "AGE",
+    "PTGENDER",
+    "PTEDUCAT",
+    "PTETHCAT",
+    "PTRACCAT",
+    "PTMARRY",
+    "APOE4",
+    "FDG",
+    "PIB",
+    "AV45",
+    "ABETA",
+    "TAU",
+    "PTAU",
+    "CDRSB",
+    "ADAS11",
+    "ADAS13",
+    "ADASQ4",
+    "MMSE",
+    "RAVLT_immediate",
+    "RAVLT_learning",
+    "RAVLT_forgetting",
+    "RAVLT_perc_forgetting",
+    "LDELTOTAL",
+    "DIGITSCOR",
+    "TRABSCOR",
+    "FAQ",
+    "MOCA",
+    "Years_bl",
+]
+
+CONVERSION_COLUMNS = [
+    "PTID",
+    "label",
+    "DX.1",
+    "mPACCdigit",
+    "mPACCtrailsB",
+    "Ventricles（心室）",
+    "Hippocampus（海马）",
+    "WholeBrain（全脑）",
+    "Entorhinal（内嗅觉）",
+    "Fusiform（梭形）",
+    "MidTemp（中点温度）",
+    "ICV",
+]
+
+
+def normalize_subject_id(value: object) -> str:
+    if pd.isna(value):
+        return ""
+    text = str(value).strip().upper()
+    text = text.replace("_S_", "S").replace("_", "")
+    return re.sub(r"[^A-Z0-9]", "", text)
+
+
+def clean_numeric(value: object) -> float | pd.NA:
+    if pd.isna(value):
+        return pd.NA
+    text = str(value).strip()
+    if not text:
+        return pd.NA
+    if text.startswith(">"):
+        text = text[1:]
+    try:
+        return float(text)
+    except ValueError:
+        return pd.NA
+
+
+def read_xlsx(path: Path, columns: list[str]) -> pd.DataFrame:
+    df = pd.read_excel(path)
+    available = [col for col in columns if col in df.columns]
+    if "PTID" not in available:
+        raise ValueError(f"{path} does not contain PTID.")
+    df = df[available].copy()
+    df["subject_id_norm"] = df["PTID"].map(normalize_subject_id)
+    df = df[df["subject_id_norm"] != ""].copy()
+    df = df.drop_duplicates("subject_id_norm", keep="first")
+    return df
+
+
+def add_numeric_clean_columns(df: pd.DataFrame) -> pd.DataFrame:
+    for col in ["FDG", "PIB", "AV45", "ABETA", "TAU", "PTAU"]:
+        if col in df.columns:
+            df[f"{col}_num"] = df[col].map(clean_numeric)
+    return df
+
+
+def write_split_manifests(enriched: pd.DataFrame, out_dir: Path) -> None:
+    out_dir.mkdir(parents=True, exist_ok=True)
+    for split_name, split_df in enriched.groupby("split", sort=False):
+        split_df.to_csv(out_dir / f"{split_name}_clinical.csv", index=False)
+
+
+def summarize(enriched: pd.DataFrame, out_md: Path, out_csv: Path) -> None:
+    rows = []
+    total = len(enriched)
+    for col in [
+        "clinical_label",
+        "dx",
+        "dx_bl",
+        "conversion_label",
+        "age",
+        "sex",
+        "apoe4",
+        "mmse",
+        "cdrsb",
+        "adas11",
+        "adas13",
+        "faq",
+        "moca",
+        "fdg_adni",
+        "av45",
+        "abeta_num",
+        "tau_num",
+        "ptau_num",
+        "hippocampus",
+        "wholebrain",
+    ]:
+        if col not in enriched.columns:
+            continue
+        non_missing = int(enriched[col].notna().sum())
+        rows.append({"field": col, "non_missing": non_missing, "coverage": non_missing / total})
+    report = pd.DataFrame(rows)
+    report.to_csv(out_csv, index=False)
+
+    label_counts = {}
+    for col in ["clinical_label", "dx", "dx_bl", "conversion_label"]:
+        if col in enriched.columns:
+            label_counts[col] = enriched[col].dropna().astype(str).value_counts().to_dict()
+
+    lines = [
+        "# ADNI Metadata Match Report",
+        "",
+        f"- PET/SUVR samples: {total}",
+        f"- Matched clinical rows: {int(enriched['clinical_label'].notna().sum())}",
+        "",
+        "## Field Coverage",
+        "",
+        "| field | non_missing | coverage |",
+        "|---|---:|---:|",
+    ]
+    for row in rows:
+        lines.append(f"| {row['field']} | {row['non_missing']} | {row['coverage']:.3f} |")
+    lines.extend([
+        "",
+        "## Label Counts",
+        "",
+    ])
+    for col, counts in label_counts.items():
+        lines.append(f"### {col}")
+        lines.append("")
+        for key, value in counts.items():
+            lines.append(f"- {key}: {value}")
+        lines.append("")
+    out_md.write_text("\n".join(lines), encoding="utf-8")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Match ADNI Excel metadata to the PET/SUVR manifest.")
+    parser.add_argument("--manifest", type=Path, default=Path("data/metadata/splits/pet_fdg_manifest_with_split.csv"))
+    parser.add_argument("--full-xlsx", type=Path, default=Path("data/ADNIbase1416_info.xlsx"))
+    parser.add_argument("--conversion-xlsx", type=Path, default=Path("data/adni_1203s_info_fix.xlsx"))
+    parser.add_argument("--out", type=Path, default=Path("data/metadata/adni_matched_clinical.csv"))
+    parser.add_argument("--split-out-dir", type=Path, default=Path("data/metadata/splits"))
+    parser.add_argument("--report-md", type=Path, default=Path("data/metadata/adni_match_report.md"))
+    parser.add_argument("--report-csv", type=Path, default=Path("data/metadata/adni_match_report.csv"))
+    args = parser.parse_args()
+
+    manifest = pd.read_csv(args.manifest)
+    manifest["subject_id_norm"] = manifest["subject_id"].map(normalize_subject_id)
+
+    full = read_xlsx(args.full_xlsx, FULL_COLUMNS)
+    full = add_numeric_clean_columns(full)
+    full = full.rename(
+        columns={
+            "label": "clinical_label",
+            "DX": "dx",
+            "DX_bl": "dx_bl",
+            "AGE": "age",
+            "PTGENDER": "sex",
+            "PTEDUCAT": "education",
+            "PTETHCAT": "ethnicity",
+            "PTRACCAT": "race",
+            "PTMARRY": "marital_status",
+            "APOE4": "apoe4",
+            "FDG": "fdg_adni",
+            "PIB": "pib",
+            "AV45": "av45",
+            "ABETA": "abeta",
+            "TAU": "tau",
+            "PTAU": "ptau",
+            "ABETA_num": "abeta_num",
+            "TAU_num": "tau_num",
+            "PTAU_num": "ptau_num",
+            "CDRSB": "cdrsb",
+            "ADAS11": "adas11",
+            "ADAS13": "adas13",
+            "ADASQ4": "adasq4",
+            "MMSE": "mmse",
+            "RAVLT_immediate": "ravlt_immediate",
+            "RAVLT_learning": "ravlt_learning",
+            "RAVLT_forgetting": "ravlt_forgetting",
+            "RAVLT_perc_forgetting": "ravlt_perc_forgetting",
+            "LDELTOTAL": "ldeltotal",
+            "DIGITSCOR": "digitscor",
+            "TRABSCOR": "trabscor",
+            "FAQ": "faq",
+            "MOCA": "moca",
+            "Years_bl": "years_bl",
+        }
+    )
+
+    conversion = read_xlsx(args.conversion_xlsx, CONVERSION_COLUMNS)
+    conversion = conversion.rename(
+        columns={
+            "label": "conversion_label",
+            "DX.1": "dx_followup",
+            "mPACCdigit": "mpacc_digit",
+            "mPACCtrailsB": "mpacc_trailsb",
+            "Ventricles（心室）": "ventricles",
+            "Hippocampus（海马）": "hippocampus",
+            "WholeBrain（全脑）": "wholebrain",
+            "Entorhinal（内嗅觉）": "entorhinal",
+            "Fusiform（梭形）": "fusiform",
+            "MidTemp（中点温度）": "midtemp",
+        }
+    )
+    conversion = conversion.drop(columns=["PTID"], errors="ignore")
+
+    enriched = manifest.merge(full.drop(columns=["PTID"], errors="ignore"), on="subject_id_norm", how="left")
+    enriched = enriched.merge(conversion, on="subject_id_norm", how="left")
+    enriched = enriched.drop(columns=["subject_id_norm"])
+
+    args.out.parent.mkdir(parents=True, exist_ok=True)
+    enriched.to_csv(args.out, index=False)
+    write_split_manifests(enriched, args.split_out_dir)
+    summarize(enriched, args.report_md, args.report_csv)
+
+    print(f"wrote={args.out}")
+    print(f"wrote_splits={args.split_out_dir}/*_clinical.csv")
+    print(f"wrote_report={args.report_md}")
+    print(f"samples={len(enriched)} matched={int(enriched['clinical_label'].notna().sum())}")
+
+
+if __name__ == "__main__":
+    main()

scripts/pet_vlm_dataset.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import nibabel as nib
+import numpy as np
+import pandas as pd
+import torch
+import torch.nn.functional as F
+from torch.utils.data import Dataset
+
+
+def normalize_pet(volume: np.ndarray, eps: float = 1e-6) -> np.ndarray:
+    volume = np.asarray(volume, dtype=np.float32)
+    finite = np.isfinite(volume)
+    if not finite.any():
+        return np.zeros_like(volume, dtype=np.float32)
+    lo, hi = np.percentile(volume[finite], [0.5, 99.5])
+    volume = np.clip(volume, lo, hi)
+    volume = (volume - lo) / max(float(hi - lo), eps)
+    return volume.astype(np.float32, copy=False)
+
+
+def resize_volume(volume: np.ndarray, output_size: tuple[int, int, int]) -> torch.Tensor:
+    tensor = torch.from_numpy(volume)[None, None]
+    tensor = F.interpolate(tensor, size=output_size, mode="trilinear", align_corners=False)
+    return tensor[0]
+
+
+def load_suvr_vector(csv_path: str | Path, include_background: bool = False) -> tuple[list[str], torch.Tensor]:
+    df = pd.read_csv(csv_path)
+    if not include_background:
+        df = df[df["label_name"] != "Background"].copy()
+    labels = df["label_name"].astype(str).tolist()
+    values = torch.tensor(df["mean_scalar"].astype(float).to_numpy(), dtype=torch.float32)
+    return labels, values
+
+
+def suvr_to_text(labels: list[str], values: torch.Tensor, top_k: int = 8) -> str:
+    pairs = sorted(zip(labels, values.tolist()), key=lambda x: x[1], reverse=True)
+    high = ", ".join(f"{name} {value:.3f}" for name, value in pairs[:top_k])
+    low = ", ".join(f"{name} {value:.3f}" for name, value in pairs[-top_k:])
+    mean_value = float(values.mean())
+    return f"FDG-PET regional SUVR summary. Mean SUVR {mean_value:.3f}. Highest regions: {high}. Lowest regions: {low}."
+
+
+class PETSUVRDataset(Dataset):
+    def __init__(
+        self,
+        manifest_path: str | Path,
+        output_size: tuple[int, int, int] = (96, 96, 96),
+        include_background: bool = False,
+    ) -> None:
+        self.manifest = pd.read_csv(manifest_path)
+        self.output_size = output_size
+        self.include_background = include_background
+
+    def __len__(self) -> int:
+        return len(self.manifest)
+
+    def __getitem__(self, index: int) -> dict[str, object]:
+        row = self.manifest.iloc[index]
+        volume = nib.load(str(row["pet_path"])).get_fdata(dtype=np.float32)
+        volume = normalize_pet(volume)
+        image = resize_volume(volume, self.output_size)
+        labels, suvr = load_suvr_vector(row["suvr_csv_path"], self.include_background)
+        text = suvr_to_text(labels, suvr)
+        return {
+            "sample_id": row["sample_id"],
+            "image": image,
+            "suvr": suvr,
+            "region_labels": labels,
+            "text": text,
+        }
+
+
+def collate_pet_suvr(batch: list[dict[str, object]]) -> dict[str, object]:
+    return {
+        "sample_id": [item["sample_id"] for item in batch],
+        "image": torch.stack([item["image"] for item in batch]),
+        "suvr": torch.stack([item["suvr"] for item in batch]),
+        "text": [item["text"] for item in batch],
+        "region_labels": batch[0]["region_labels"],
+    }

scripts/probe_mlp_remap.py

@@ -0,0 +1,166 @@
+"""
+Two-layer MLP probe for ReMAP-PET 3-way classification.
+Compares linear vs non-linear probing on the same embeddings.
+"""
+from __future__ import annotations
+
+import argparse, json
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+import torch
+from sklearn.neural_network import MLPClassifier
+from sklearn.linear_model import LogisticRegression
+from sklearn.preprocessing import LabelEncoder, StandardScaler
+from sklearn.metrics import balanced_accuracy_score, roc_auc_score, accuracy_score
+from sklearn.pipeline import make_pipeline
+from torch.utils.data import DataLoader
+
+from pet_vlm_dataset import PETSUVRDataset, collate_pet_suvr
+from train_pet_foundation import PETSUVRFoundationModel, build_encoder
+
+
+def extract_embeddings(checkpoint, split_csv, output_size, device):
+    ckpt = torch.load(checkpoint, map_location="cpu", weights_only=False)
+    saved_args = argparse.Namespace(**ckpt.get("args", {}))
+    for name in ("backbone", "embed_dim", "freeze_encoder"):
+        if not hasattr(saved_args, name) or getattr(saved_args, name) is None:
+            setattr(saved_args, name, ckpt.get("args", {}).get(name))
+    embed_dim = getattr(saved_args, "embed_dim", None) or 256
+    backbone = getattr(saved_args, "backbone", "medicalnet")
+    freeze = getattr(saved_args, "freeze_encoder", True)
+
+    manifest = pd.read_csv(split_csv)
+    dataset = PETSUVRDataset(split_csv, output_size=output_size)
+    loader = DataLoader(dataset, batch_size=4, shuffle=False, num_workers=2, collate_fn=collate_pet_suvr)
+
+    encoder = build_encoder(saved_args)
+    model = PETSUVRFoundationModel(encoder, int(dataset[0]["suvr"].numel()), embed_dim, freeze).to(device)
+    model.load_state_dict(ckpt["model"], strict=True)
+    model.eval()
+
+    pet_embs, suvr_preds = [], []
+    with torch.no_grad():
+        for batch in loader:
+            image = batch["image"].to(device)
+            suvr = batch["suvr"].to(device)
+            pet_feat = model.pet_encoder(image)
+            pet_z = torch.nn.functional.normalize(model.pet_projector(pet_feat), dim=-1)
+            pet_embs.append(pet_z.cpu().numpy())
+            suvr_preds.append(model(image, suvr)["pred_suvr"].cpu().numpy())
+
+    pet_z = np.concatenate(pet_embs, axis=0)
+    pred_suvr = np.concatenate(suvr_preds, axis=0)
+    return manifest, pet_z, pred_suvr
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--checkpoint", type=Path, required=True)
+    parser.add_argument("--train", type=Path, default=Path("data/metadata/splits/train_clinical.csv"))
+    parser.add_argument("--val", type=Path, default=Path("data/metadata/splits/val_clinical.csv"))
+    parser.add_argument("--test", type=Path, default=Path("data/metadata/splits/test_clinical.csv"))
+    parser.add_argument("--output-size", type=int, nargs=3, default=(96, 96, 96))
+    args = parser.parse_args()
+
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"Loading checkpoint: {args.checkpoint}")
+
+    train_df, train_pet, train_suvr = extract_embeddings(args.checkpoint, args.train, tuple(args.output_size), device)
+    val_df, val_pet, val_suvr = extract_embeddings(args.checkpoint, args.val, tuple(args.output_size), device)
+    test_df, test_pet, test_suvr = extract_embeddings(args.checkpoint, args.test, tuple(args.output_size), device)
+
+    # Extract labels for 3-way classification
+    encoder = LabelEncoder()
+    all_labels = pd.concat([train_df["clinical_label"], val_df["clinical_label"], test_df["clinical_label"]])
+    encoder.fit(all_labels.astype(str))
+    y_train = encoder.transform(train_df["clinical_label"].astype(str))
+    y_val = encoder.transform(val_df["clinical_label"].astype(str))
+    y_test = encoder.transform(test_df["clinical_label"].astype(str))
+    n_classes = len(encoder.classes_)
+
+    # ---- Linear probe (baseline) ----
+    print("\n=== Linear Probe (Logistic Regression) ===")
+    best_bal, best_c = 0, 0.01
+    for c in [0.01, 0.03, 0.1, 0.3, 1.0, 3.0, 10.0, 30.0]:
+        pipe = make_pipeline(StandardScaler(), LogisticRegression(C=c, max_iter=5000, solver="lbfgs"))
+        pipe.fit(train_pet, y_train)
+        val_pred = pipe.predict(val_pet)
+        bal = balanced_accuracy_score(y_val, val_pred)
+        print(f"  C={c:.2f} val_bal={bal:.4f}")
+        if bal > best_bal:
+            best_bal, best_c = bal, c
+
+    pipe = make_pipeline(StandardScaler(), LogisticRegression(C=best_c, max_iter=5000, solver="lbfgs"))
+    pipe.fit(train_pet, y_train)
+    test_pred = pipe.predict(test_pet)
+    test_prob = pipe.predict_proba(test_pet)
+    linear_bal = balanced_accuracy_score(y_test, test_pred)
+    linear_auroc = roc_auc_score(y_test, test_prob, multi_class="ovr", average="macro")
+    print(f"  Best C={best_c}, Test BalAcc={linear_bal:.4f}, AUROC={linear_auroc:.4f}")
+
+    # ---- MLP probe ----
+    print("\n=== MLP Probe (2-layer) ===")
+    best_bal2, best_alpha = 0, 0.01
+    for alpha in [0.0001, 0.001, 0.01, 0.1, 1.0]:
+        for hidden in [64, 128, 256]:
+            pipe2 = make_pipeline(
+                StandardScaler(),
+                MLPClassifier(hidden_layer_sizes=(hidden, hidden // 2),
+                            alpha=alpha, max_iter=2000,
+                            early_stopping=True, validation_fraction=0.1,
+                            random_state=42)
+            )
+            pipe2.fit(train_pet, y_train)
+            val_pred2 = pipe2.predict(val_pet)
+            bal2 = balanced_accuracy_score(y_val, val_pred2)
+            if bal2 > best_bal2:
+                best_bal2, best_alpha, best_hidden = bal2, alpha, hidden
+    print(f"  Best alpha={best_alpha}, hidden={best_hidden}, val_bal={best_bal2:.4f}")
+
+    pipe2 = make_pipeline(
+        StandardScaler(),
+        MLPClassifier(hidden_layer_sizes=(best_hidden, best_hidden // 2),
+                    alpha=best_alpha, max_iter=5000, random_state=42)
+    )
+    pipe2.fit(train_pet, y_train)
+    test_pred2 = pipe2.predict(test_pet)
+    test_prob2 = pipe2.predict_proba(test_pet)
+    mlp_bal = balanced_accuracy_score(y_test, test_pred2)
+    mlp_auroc = roc_auc_score(y_test, test_prob2, multi_class="ovr", average="macro")
+    print(f"  Test BalAcc={mlp_bal:.4f}, AUROC={mlp_auroc:.4f}")
+
+    # ---- Combined features probe ----
+    print("\n=== Linear Probe (PET + Predicted SUVR) ===")
+    train_comb = np.concatenate([train_pet, train_suvr], axis=1)
+    val_comb = np.concatenate([val_pet, val_suvr], axis=1)
+    test_comb = np.concatenate([test_pet, test_suvr], axis=1)
+
+    best_bal3, best_c3 = 0, 0.01
+    for c in [0.01, 0.03, 0.1, 0.3, 1.0, 3.0, 10.0, 30.0]:
+        pipe3 = make_pipeline(StandardScaler(), LogisticRegression(C=c, max_iter=5000, solver="lbfgs"))
+        pipe3.fit(train_comb, y_train)
+        val_pred3 = pipe3.predict(val_comb)
+        bal3 = balanced_accuracy_score(y_val, val_pred3)
+        if bal3 > best_bal3:
+            best_bal3, best_c3 = bal3, c
+
+    pipe3 = make_pipeline(StandardScaler(), LogisticRegression(C=best_c3, max_iter=5000, solver="lbfgs"))
+    pipe3.fit(train_comb, y_train)
+    test_pred3 = pipe3.predict(test_comb)
+    test_prob3 = pipe3.predict_proba(test_comb)
+    comb_bal = balanced_accuracy_score(y_test, test_pred3)
+    comb_auroc = roc_auc_score(y_test, test_prob3, multi_class="ovr", average="macro")
+    print(f"  Best C={best_c3}, Test BalAcc={comb_bal:.4f}, AUROC={comb_auroc:.4f}")
+
+    # Summary
+    print(f"\n=== Summary (3-way test AUROC) ===")
+    print(f"  Linear probe (original):     {linear_auroc:.4f}")
+    print(f"  MLP probe (2-layer):         {mlp_auroc:.4f}")
+    print(f"  Linear probe (PET+SUVR):     {comb_auroc:.4f}")
+    print(f"  MedicalNet frozen baseline:   0.7567")
+
+
+if __name__ == "__main__":
+    main()

scripts/run_clinical_probes_v3.sh

@@ -0,0 +1,38 @@
+#!/usr/bin/env bash
+set -euo pipefail
+cd /data/Albus/Brain
+PY=/data/Albus/miniconda3/bin/python
+mkdir -p runs/clinical logs
+
+echo "[2026-05-20 23:23:42] start suvr_baseline" | tee logs/clinical_suvr_baseline.log
+"" -u scripts/evaluate_suvr_clinical_probe.py   --train data/metadata/splits/train_clinical_server.csv   --val data/metadata/splits/val_clinical_server.csv   --test data/metadata/splits/test_clinical_server.csv   --out runs/clinical/suvr_clinical_probe.csv >> logs/clinical_suvr_baseline.log 2>&1
+echo "[2026-05-20 23:23:42] done suvr_baseline" >> logs/clinical_suvr_baseline.log
+
+TRAIN=data/metadata/splits/train_clinical_server.csv
+VAL=data/metadata/splits/val_clinical_server.csv
+TEST=data/metadata/splits/test_clinical_server.csv
+
+run_probe() {
+  local gpu="$1"
+  local name="$2"
+  local ckpt="$3"
+  local log="logs/clinical_${name}.log"
+  local out="runs/clinical/${name}_clinical_probe.csv"
+  echo "[2026-05-20 23:23:42] start ${name} gpu=${gpu} ckpt=${ckpt}" | tee "${log}"
+  CUDA_VISIBLE_DEVICES="${gpu}" "${PY}" -u scripts/evaluate_pet_clinical_probe.py     --checkpoint "${ckpt}"     --train "${TRAIN}"     --val "${VAL}"     --test "${TEST}"     --batch-size 4     --num-workers 2     --out "${out}" >> "${log}" 2>&1
+  echo "[2026-05-20 23:23:42] done ${name}" >> "${log}"
+}
+
+( run_probe 0 remap_pet runs/foundation/medicalnet_layer4_regalign_best.pt
+  run_probe 0 medicalnet_frozen runs/foundation/medicalnet_frozen_mlp.pt
+  run_probe 0 brainiac_frozen runs/foundation/brainiac_frozen_mlp.pt
+) > logs/clinical_queue_gpu0.log 2>&1 &
+echo $! > logs/clinical_queue_gpu0.pid
+
+( run_probe 1 brainfm_frozen runs/foundation/brainfm_frozen_mlp_b4_best.pt
+  run_probe 1 sam_med3d_frozen runs/foundation/sam_med3d_frozen_mlp_best.pt
+  run_probe 1 swinunetr_frozen runs/foundation/swinunetr_frozen_mlp_best.pt
+) > logs/clinical_queue_gpu1.log 2>&1 &
+echo $! > logs/clinical_queue_gpu1.pid
+
+echo "gpu0_pid=$(cat logs/clinical_queue_gpu0.pid) gpu1_pid=$(cat logs/clinical_queue_gpu1.pid)"

scripts/train_pet_foundation.py

@@ -0,0 +1,531 @@
+from __future__ import annotations
+
+import argparse
+import inspect
+import importlib.util
+from pathlib import Path
+import sys
+import types
+
+import torch
+from torch import nn
+from torch.utils.data import DataLoader
+
+from pet_vlm_dataset import PETSUVRDataset, collate_pet_suvr
+
+
+class MedicalNetBottleneck(nn.Module):
+    expansion = 4
+
+    def __init__(self, inplanes: int, planes: int, stride: int = 1, downsample: nn.Module | None = None) -> None:
+        super().__init__()
+        self.conv1 = nn.Conv3d(inplanes, planes, kernel_size=1, bias=False)
+        self.bn1 = nn.BatchNorm3d(planes)
+        self.conv2 = nn.Conv3d(planes, planes, kernel_size=3, stride=stride, padding=1, bias=False)
+        self.bn2 = nn.BatchNorm3d(planes)
+        self.conv3 = nn.Conv3d(planes, planes * self.expansion, kernel_size=1, bias=False)
+        self.bn3 = nn.BatchNorm3d(planes * self.expansion)
+        self.relu = nn.ReLU(inplace=True)
+        self.downsample = downsample
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        residual = x
+        out = self.relu(self.bn1(self.conv1(x)))
+        out = self.relu(self.bn2(self.conv2(out)))
+        out = self.bn3(self.conv3(out))
+        if self.downsample is not None:
+            residual = self.downsample(x)
+        out = self.relu(out + residual)
+        return out
+
+
+class MedicalNetResNet50(nn.Module):
+    out_dim = 2048
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.inplanes = 64
+        self.conv1 = nn.Conv3d(1, 64, kernel_size=7, stride=(2, 2, 2), padding=(3, 3, 3), bias=False)
+        self.bn1 = nn.BatchNorm3d(64)
+        self.relu = nn.ReLU(inplace=True)
+        self.maxpool = nn.MaxPool3d(kernel_size=3, stride=2, padding=1)
+        self.layer1 = self._make_layer(64, 3)
+        self.layer2 = self._make_layer(128, 4, stride=2)
+        self.layer3 = self._make_layer(256, 6, stride=2)
+        self.layer4 = self._make_layer(512, 3, stride=2)
+        self.pool = nn.AdaptiveAvgPool3d(1)
+
+    def _make_layer(self, planes: int, blocks: int, stride: int = 1) -> nn.Sequential:
+        downsample = None
+        if stride != 1 or self.inplanes != planes * MedicalNetBottleneck.expansion:
+            downsample = nn.Sequential(
+                nn.Conv3d(self.inplanes, planes * MedicalNetBottleneck.expansion, kernel_size=1, stride=stride, bias=False),
+                nn.BatchNorm3d(planes * MedicalNetBottleneck.expansion),
+            )
+        layers = [MedicalNetBottleneck(self.inplanes, planes, stride, downsample)]
+        self.inplanes = planes * MedicalNetBottleneck.expansion
+        for _ in range(1, blocks):
+            layers.append(MedicalNetBottleneck(self.inplanes, planes))
+        return nn.Sequential(*layers)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        x = self.maxpool(self.relu(self.bn1(self.conv1(x))))
+        x = self.layer1(x)
+        x = self.layer2(x)
+        x = self.layer3(x)
+        x = self.layer4(x)
+        return self.pool(x).flatten(1)
+
+
+def load_medicalnet(path: Path) -> MedicalNetResNet50:
+    model = MedicalNetResNet50()
+    obj = torch.load(path, map_location="cpu")
+    state = obj.get("state_dict", obj)
+    state = {k.removeprefix("module."): v for k, v in state.items()}
+    missing, unexpected = model.load_state_dict(state, strict=False)
+    if unexpected:
+        print(f"unexpected_keys={unexpected[:8]}", flush=True)
+    if missing:
+        print(f"missing_keys={missing[:8]}", flush=True)
+    return model
+
+
+class BrainIACEncoder(nn.Module):
+    out_dim = 768
+
+    def __init__(self, weights_path: Path) -> None:
+        super().__init__()
+        from monai.networks.nets import ViT
+        from safetensors.torch import load_file
+
+        self.model = ViT(
+            in_channels=1,
+            img_size=(96, 96, 96),
+            patch_size=(16, 16, 16),
+            hidden_size=768,
+            mlp_dim=3072,
+            num_layers=12,
+            num_heads=12,
+        )
+        weights = load_file(str(weights_path))
+        missing, unexpected = self.model.load_state_dict(weights, strict=False)
+        if unexpected:
+            print(f"brainiac_unexpected_keys={unexpected[:8]}", flush=True)
+        if missing:
+            print(f"brainiac_missing_keys={missing[:8]}", flush=True)
+
+    def forward(self, image: torch.Tensor) -> torch.Tensor:
+        output = self.model(image)
+        tokens = output[0] if isinstance(output, tuple) else output
+        return tokens[:, 0]
+
+
+class SwinUNETREncoder(nn.Module):
+    out_dim = 768
+
+    def __init__(self, weights_path: Path, img_size: tuple[int, int, int]) -> None:
+        super().__init__()
+        from monai.networks.nets import SwinUNETR
+
+        kwargs = {
+            "in_channels": 1,
+            "out_channels": 2,
+            "feature_size": 48,
+            "use_checkpoint": False,
+            "spatial_dims": 3,
+        }
+        if "img_size" in inspect.signature(SwinUNETR).parameters:
+            kwargs["img_size"] = img_size
+        self.model = SwinUNETR(**kwargs)
+        weights = torch.load(weights_path, map_location="cpu", weights_only=False)
+        if hasattr(self.model, "load_from"):
+            self.model.load_from(weights)
+        else:
+            state = weights.get("state_dict", weights.get("model", weights))
+            remapped = {}
+            for key, value in state.items():
+                key = key.removeprefix("module.")
+                if key.startswith("encoder."):
+                    key = "swinViT." + key[len("encoder.") :]
+                remapped[key] = value
+            missing, unexpected = self.model.load_state_dict(remapped, strict=False)
+            if unexpected:
+                print(f"swinunetr_unexpected_keys={unexpected[:8]}", flush=True)
+            if missing:
+                print(f"swinunetr_missing_keys={missing[:8]}", flush=True)
+        self.pool = nn.AdaptiveAvgPool3d(1)
+
+    def forward(self, image: torch.Tensor) -> torch.Tensor:
+        hidden = self.model.swinViT(image, self.model.normalize)
+        feat = hidden[-1]
+        return self.pool(feat).flatten(1)
+
+
+class SAMMed3DEncoder(nn.Module):
+    out_dim = 384
+
+    def __init__(self, weights_path: Path) -> None:
+        super().__init__()
+        try:
+            import medim
+        except ImportError as exc:
+            raise ImportError("SAM-Med3D requires `medim`. Install it before using --backbone sam_med3d.") from exc
+
+        self.model = medim.create_model("SAM-Med3D", pretrained=True, checkpoint_path=str(weights_path))
+        self.image_encoder = getattr(self.model, "image_encoder", self.model)
+        self.pool = nn.AdaptiveAvgPool3d(1)
+
+    def forward(self, image: torch.Tensor) -> torch.Tensor:
+        output = self.image_encoder(image)
+        if isinstance(output, dict):
+            output = output.get("image_embeddings", output.get("embeddings", next(iter(output.values()))))
+        if isinstance(output, (list, tuple)):
+            output = output[0]
+        if output.ndim == 2:
+            return output
+        if output.ndim == 3:
+            return output.mean(dim=1)
+        return self.pool(output).flatten(1)
+
+
+class BrainFMEncoder(nn.Module):
+    out_dim = 2048
+
+    def __init__(self, weights_path: Path, code_root: Path) -> None:
+        super().__init__()
+        unet_root = (code_root / "Trainer" / "models" / "unet3d").resolve()
+        package = types.ModuleType("brainfm_unet")
+        package.__path__ = [str(unet_root)]
+        sys.modules.setdefault("brainfm_unet", package)
+        spec = importlib.util.spec_from_file_location("brainfm_unet.model", unet_root / "model.py")
+        if spec is None or spec.loader is None:
+            raise RuntimeError(f"Could not load BrainFM model code from {unet_root}")
+        module = importlib.util.module_from_spec(spec)
+        sys.modules["brainfm_unet.model"] = module
+        spec.loader.exec_module(module)
+
+        ckpt = torch.load(weights_path, map_location="cpu", weights_only=False)
+        train_args = ckpt["train_args"]
+        self.model = module.UNet3D(
+            train_args.in_channels,
+            train_args.f_maps,
+            train_args.layer_order,
+            train_args.num_groups,
+            train_args.num_levels,
+            train_args.unit_feat,
+        )
+        state = {k.removeprefix("backbone."): v for k, v in ckpt["model"].items() if k.startswith("backbone.")}
+        missing, unexpected = self.model.load_state_dict(state, strict=False)
+        if unexpected:
+            print(f"brainfm_unexpected_keys={unexpected[:8]}", flush=True)
+        if missing:
+            print(f"brainfm_missing_keys={missing[:8]}", flush=True)
+        self.pool = nn.AdaptiveAvgPool3d(1)
+
+    def forward(self, image: torch.Tensor) -> torch.Tensor:
+        features = self.model.get_feature(image)
+        bottleneck = features[0]
+        return self.pool(bottleneck).flatten(1)
+
+
+class Small3DPETEncoder(nn.Module):
+    out_dim = 256
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.Conv3d(1, 16, 3, stride=2, padding=1),
+            nn.BatchNorm3d(16),
+            nn.GELU(),
+            nn.Conv3d(16, 32, 3, stride=2, padding=1),
+            nn.BatchNorm3d(32),
+            nn.GELU(),
+            nn.Conv3d(32, 64, 3, stride=2, padding=1),
+            nn.BatchNorm3d(64),
+            nn.GELU(),
+            nn.Conv3d(64, 128, 3, stride=2, padding=1),
+            nn.BatchNorm3d(128),
+            nn.GELU(),
+            nn.AdaptiveAvgPool3d(1),
+        )
+        self.proj = nn.Linear(128, self.out_dim)
+
+    def forward(self, image: torch.Tensor) -> torch.Tensor:
+        return self.proj(self.net(image).flatten(1))
+
+
+class RegionSUVREncoder(nn.Module):
+    def __init__(self, n_regions: int, embed_dim: int) -> None:
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.LayerNorm(n_regions),
+            nn.Linear(n_regions, embed_dim),
+            nn.GELU(),
+            nn.Linear(embed_dim, embed_dim),
+        )
+
+    def forward(self, suvr: torch.Tensor) -> torch.Tensor:
+        return self.net(suvr)
+
+
+class PETSUVRFoundationModel(nn.Module):
+    def __init__(self, pet_encoder: nn.Module, n_regions: int, embed_dim: int = 256, freeze_encoder: bool = True) -> None:
+        super().__init__()
+        self.pet_encoder = pet_encoder
+        self.freeze_encoder = freeze_encoder
+        if freeze_encoder:
+            for p in self.pet_encoder.parameters():
+                p.requires_grad = False
+            self.pet_encoder.eval()
+        self.pet_projector = nn.Sequential(nn.LayerNorm(pet_encoder.out_dim), nn.Linear(pet_encoder.out_dim, embed_dim))
+        self.suvr_encoder = RegionSUVREncoder(n_regions, embed_dim)
+        self.suvr_head = nn.Sequential(nn.LayerNorm(embed_dim), nn.Linear(embed_dim, n_regions))
+        self.temperature = nn.Parameter(torch.tensor(0.07))
+
+    def forward(self, image: torch.Tensor, suvr: torch.Tensor) -> dict[str, torch.Tensor]:
+        if self.freeze_encoder:
+            with torch.no_grad():
+                pet_feat = self.pet_encoder(image)
+        else:
+            pet_feat = self.pet_encoder(image)
+        pet_z = nn.functional.normalize(self.pet_projector(pet_feat), dim=-1)
+        suvr_z = nn.functional.normalize(self.suvr_encoder(suvr), dim=-1)
+        pred_suvr = self.suvr_head(pet_z)
+        logits = pet_z @ suvr_z.T / self.temperature.clamp_min(0.01)
+        return {"logits": logits, "pred_suvr": pred_suvr}
+
+
+def alignment_loss(
+    outputs: dict[str, torch.Tensor],
+    suvr: torch.Tensor,
+    contrastive_weight: float = 1.0,
+    regression_weight: float = 1.0,
+) -> tuple[torch.Tensor, dict[str, float]]:
+    labels = torch.arange(suvr.shape[0], device=suvr.device)
+    loss_i = nn.functional.cross_entropy(outputs["logits"], labels)
+    loss_t = nn.functional.cross_entropy(outputs["logits"].T, labels)
+    loss_contrastive = 0.5 * (loss_i + loss_t)
+    loss_reg = nn.functional.mse_loss(outputs["pred_suvr"], suvr)
+    loss = contrastive_weight * loss_contrastive + regression_weight * loss_reg
+    return loss, {
+        "contrastive": float(loss_contrastive.detach()),
+        "regression": float(loss_reg.detach()),
+    }
+
+
+def build_encoder(args: argparse.Namespace) -> nn.Module:
+    if args.backbone == "small_cnn":
+        return Small3DPETEncoder()
+    if args.backbone == "medicalnet":
+        return load_medicalnet(args.medicalnet_weights)
+    if args.backbone == "brainiac":
+        return BrainIACEncoder(args.brainiac_weights)
+    if args.backbone == "swinunetr":
+        return SwinUNETREncoder(args.swinunetr_weights, tuple(args.output_size))
+    if args.backbone == "sam_med3d":
+        return SAMMed3DEncoder(args.sam_med3d_weights)
+    if args.backbone == "brainfm":
+        return BrainFMEncoder(args.brainfm_weights, args.brainfm_code_root)
+    raise ValueError(f"Unsupported backbone: {args.backbone}")
+
+
+def _set_trainable(module: nn.Module | None, trainable: bool) -> None:
+    if module is None:
+        return
+    for p in module.parameters():
+        p.requires_grad = trainable
+
+
+def _last_vit_block(module: nn.Module) -> nn.Module | None:
+    blocks = getattr(module, "blocks", None)
+    if isinstance(blocks, (nn.ModuleList, list, tuple)) and len(blocks) > 0:
+        return blocks[-1]
+    return None
+
+
+def _last_swin_stage(module: nn.Module) -> nn.Module | None:
+    swin = getattr(module, "swinViT", None)
+    if swin is None:
+        return None
+    for name in ("layers4", "layers3", "layers2", "layers1"):
+        layer = getattr(swin, name, None)
+        if layer is not None:
+            return layer
+    return None
+
+
+def _brainfm_last_stage(module: nn.Module) -> nn.Module | None:
+    for name in ("encoders", "encoder", "down_path"):
+        stage = getattr(module, name, None)
+        if isinstance(stage, (nn.ModuleList, nn.Sequential)) and len(stage) > 0:
+            return stage[-1]
+    return None
+
+
+def _sam_last_stage(module: nn.Module) -> nn.Module | None:
+    for name in ("blocks", "layers", "neck"):
+        stage = getattr(module, name, None)
+        if isinstance(stage, (nn.ModuleList, list, tuple)) and len(stage) > 0:
+            return stage[-1]
+        if isinstance(stage, nn.Module):
+            return stage
+    return None
+
+
+def unfreeze_last_block(encoder: nn.Module) -> None:
+    _set_trainable(encoder, False)
+    target = None
+    if isinstance(encoder, MedicalNetResNet50):
+        target = encoder.layer4
+    elif isinstance(encoder, BrainIACEncoder):
+        target = _last_vit_block(encoder.model)
+    elif isinstance(encoder, SwinUNETREncoder):
+        target = _last_swin_stage(encoder.model)
+    elif isinstance(encoder, BrainFMEncoder):
+        target = _brainfm_last_stage(encoder.model)
+    elif isinstance(encoder, SAMMed3DEncoder):
+        target = _sam_last_stage(encoder.image_encoder)
+    if target is None:
+        raise ValueError(f"Could not identify a last block for {encoder.__class__.__name__}.")
+    _set_trainable(target, True)
+
+
+def configure_encoder_training(model: PETSUVRFoundationModel, scope: str) -> None:
+    if scope == "none":
+        for p in model.pet_encoder.parameters():
+            p.requires_grad = False
+        return
+    if scope == "all":
+        for p in model.pet_encoder.parameters():
+            p.requires_grad = True
+        return
+    if scope == "layer4":
+        for p in model.pet_encoder.parameters():
+            p.requires_grad = False
+        if not hasattr(model.pet_encoder, "layer4"):
+            raise ValueError("encoder_train_scope=layer4 is only supported for MedicalNet-style encoders.")
+        for p in model.pet_encoder.layer4.parameters():
+            p.requires_grad = True
+        return
+    if scope == "last_block":
+        unfreeze_last_block(model.pet_encoder)
+        return
+    raise ValueError(f"Unsupported encoder training scope: {scope}")
+
+
+def set_encoder_mode_for_scope(model: PETSUVRFoundationModel, scope: str) -> None:
+    if scope == "none":
+        model.pet_encoder.eval()
+    elif scope in {"layer4", "last_block"}:
+        model.pet_encoder.eval()
+        for module in model.pet_encoder.modules():
+            if any(p.requires_grad for p in module.parameters(recurse=False)):
+                module.train()
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Train PET-SUVR alignment with pretrained 3D backbones.")
+    parser.add_argument("--backbone", choices=["small_cnn", "medicalnet", "brainiac", "brainfm", "swinunetr", "sam_med3d"], default="medicalnet")
+    parser.add_argument("--medicalnet-weights", type=Path, default=Path("pretrained/medicalnet/resnet_50_23dataset.pth"))
+    parser.add_argument("--brainiac-weights", type=Path, default=Path("pretrained/brainiac/backbone.safetensors"))
+    parser.add_argument("--brainfm-weights", type=Path, default=Path("pretrained/brainfm/assets/brainfm_pretrained.pth"))
+    parser.add_argument("--brainfm-code-root", type=Path, default=Path("pretrained/brainfm"))
+    parser.add_argument("--swinunetr-weights", type=Path, default=Path("pretrained/swinunetr/model_swinvit.pt"))
+    parser.add_argument("--sam-med3d-weights", type=Path, default=Path("pretrained/sam-med3d/sam_med3d_turbo.pth"))
+    parser.add_argument("--manifest", type=Path, default=Path("metadata/splits/train.csv"))
+    parser.add_argument("--val-manifest", type=Path, default=Path("metadata/splits/val.csv"))
+    parser.add_argument("--epochs", type=int, default=10)
+    parser.add_argument("--batch-size", type=int, default=2)
+    parser.add_argument("--lr", type=float, default=1e-4)
+    parser.add_argument("--num-workers", type=int, default=2)
+    parser.add_argument("--output-size", type=int, nargs=3, default=(96, 96, 96))
+    parser.add_argument("--embed-dim", type=int, default=256)
+    parser.add_argument("--freeze-encoder", action=argparse.BooleanOptionalAction, default=True)
+    parser.add_argument("--encoder-train-scope", choices=["none", "layer4", "last_block", "all"], default=None)
+    parser.add_argument("--contrastive-weight", type=float, default=1.0)
+    parser.add_argument("--regression-weight", type=float, default=1.0)
+    parser.add_argument("--log-every", type=int, default=10)
+    parser.add_argument("--out", type=Path, default=Path("runs/foundation.pt"))
+    parser.add_argument("--best-out", type=Path, default=None)
+    args = parser.parse_args()
+    if args.encoder_train_scope is None:
+        args.encoder_train_scope = "none" if args.freeze_encoder else "all"
+    args.freeze_encoder = args.encoder_train_scope == "none"
+
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    train_dataset = PETSUVRDataset(args.manifest, output_size=tuple(args.output_size))
+    val_dataset = PETSUVRDataset(args.val_manifest, output_size=tuple(args.output_size))
+    train_loader = DataLoader(train_dataset, batch_size=args.batch_size, shuffle=True, num_workers=args.num_workers, collate_fn=collate_pet_suvr)
+    val_loader = DataLoader(val_dataset, batch_size=args.batch_size, shuffle=False, num_workers=args.num_workers, collate_fn=collate_pet_suvr)
+
+    sample = train_dataset[0]
+    encoder = build_encoder(args)
+    model = PETSUVRFoundationModel(encoder, int(sample["suvr"].numel()), args.embed_dim, args.freeze_encoder).to(device)
+    configure_encoder_training(model, args.encoder_train_scope)
+    optimizer = torch.optim.AdamW((p for p in model.parameters() if p.requires_grad), lr=args.lr, weight_decay=1e-4)
+
+    best_val_loss = float("inf")
+    best_out = args.best_out or args.out.with_name(args.out.stem + "_best" + args.out.suffix)
+    print(
+        f"device={device} backbone={args.backbone} encoder_scope={args.encoder_train_scope} "
+        f"contrastive_weight={args.contrastive_weight} regression_weight={args.regression_weight} "
+        f"train={len(train_dataset)} val={len(val_dataset)}",
+        flush=True,
+    )
+    for epoch in range(1, args.epochs + 1):
+        model.train()
+        set_encoder_mode_for_scope(model, args.encoder_train_scope)
+        train_loss = 0.0
+        train_contrastive = 0.0
+        train_regression = 0.0
+        for step, batch in enumerate(train_loader, start=1):
+            image = batch["image"].to(device, non_blocking=True)
+            suvr = batch["suvr"].to(device, non_blocking=True)
+            outputs = model(image, suvr)
+            loss, parts = alignment_loss(outputs, suvr, args.contrastive_weight, args.regression_weight)
+            optimizer.zero_grad(set_to_none=True)
+            loss.backward()
+            optimizer.step()
+            train_loss += float(loss.detach()) * image.shape[0]
+            train_contrastive += parts["contrastive"] * image.shape[0]
+            train_regression += parts["regression"] * image.shape[0]
+            if args.log_every and step % args.log_every == 0:
+                print(f"epoch={epoch} step={step}/{len(train_loader)} loss={float(loss.detach()):.4f}", flush=True)
+        train_loss /= len(train_dataset)
+        train_contrastive /= len(train_dataset)
+        train_regression /= len(train_dataset)
+
+        model.eval()
+        val_loss = 0.0
+        val_contrastive = 0.0
+        val_regression = 0.0
+        with torch.no_grad():
+            for batch in val_loader:
+                image = batch["image"].to(device, non_blocking=True)
+                suvr = batch["suvr"].to(device, non_blocking=True)
+                loss, parts = alignment_loss(model(image, suvr), suvr, args.contrastive_weight, args.regression_weight)
+                val_loss += float(loss) * image.shape[0]
+                val_contrastive += parts["contrastive"] * image.shape[0]
+                val_regression += parts["regression"] * image.shape[0]
+        val_loss /= len(val_dataset)
+        val_contrastive /= len(val_dataset)
+        val_regression /= len(val_dataset)
+        print(
+            f"epoch={epoch} train_loss={train_loss:.4f} train_contrastive={train_contrastive:.4f} "
+            f"train_regression={train_regression:.4f} val_loss={val_loss:.4f} "
+            f"val_contrastive={val_contrastive:.4f} val_regression={val_regression:.4f}",
+            flush=True,
+        )
+        if val_loss < best_val_loss:
+            best_val_loss = val_loss
+            best_out.parent.mkdir(parents=True, exist_ok=True)
+            torch.save({"model": model.state_dict(), "args": vars(args), "best_val_loss": best_val_loss, "epoch": epoch}, best_out)
+            print(f"saved_best {best_out} val_loss={best_val_loss:.4f} epoch={epoch}", flush=True)
+
+    args.out.parent.mkdir(parents=True, exist_ok=True)
+    torch.save({"model": model.state_dict(), "args": vars(args), "best_val_loss": best_val_loss}, args.out)
+    print(f"saved {args.out}", flush=True)
+
+
+if __name__ == "__main__":
+    main()

scripts/train_pet_foundation_epoch_ckpt.py

@@ -0,0 +1,122 @@
+"""
+ReMAP-PET training with per-epoch checkpointing.
+Saves a checkpoint every epoch for later clinical probe selection.
+"""
+from __future__ import annotations
+
+import argparse, inspect, importlib.util, sys, types
+from pathlib import Path
+
+import torch
+from torch import nn
+from torch.utils.data import DataLoader
+
+from pet_vlm_dataset import PETSUVRDataset, collate_pet_suvr
+from train_pet_foundation import (
+    PETSUVRFoundationModel, build_encoder, alignment_loss,
+)
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--backbone", default="medicalnet")
+    parser.add_argument("--encoder-train-scope", default="layer4")
+    parser.add_argument("--epochs", type=int, default=50)
+    parser.add_argument("--batch-size", type=int, default=4)
+    parser.add_argument("--lr", type=float, default=1e-5)
+    parser.add_argument("--num-workers", type=int, default=2)
+    parser.add_argument("--output-size", type=int, nargs=3, default=(96, 96, 96))
+    parser.add_argument("--embed-dim", type=int, default=256)
+    parser.add_argument("--contrastive-weight", type=float, default=0.2)
+    parser.add_argument("--regression-weight", type=float, default=1.0)
+    parser.add_argument("--temperature", type=float, default=0.07)
+    parser.add_argument("--medicalnet-weights", type=Path, default=Path("pretrained/medicalnet/resnet_50_23dataset.pth"))
+    parser.add_argument("--train-csv", type=Path, default=Path("metadata/splits/train.csv"))
+    parser.add_argument("--val-csv", type=Path, default=Path("metadata/splits/val.csv"))
+    parser.add_argument("--out-dir", type=Path, default=Path("runs/foundation/remap_epochs"))
+    args = parser.parse_args()
+
+    args.out_dir.mkdir(parents=True, exist_ok=True)
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+    train_set = PETSUVRDataset(args.train_csv, output_size=tuple(args.output_size))
+    val_set = PETSUVRDataset(args.val_csv, output_size=tuple(args.output_size))
+    train_loader = DataLoader(train_set, batch_size=args.batch_size, shuffle=True,
+                              num_workers=args.num_workers, collate_fn=collate_pet_suvr)
+    val_loader = DataLoader(val_set, batch_size=args.batch_size, shuffle=False,
+                            num_workers=args.num_workers, collate_fn=collate_pet_suvr)
+    n_regions = int(train_set[0]["suvr"].numel())
+
+    encoder = build_encoder(args)
+    model = PETSUVRFoundationModel(encoder, n_regions, args.embed_dim, False).to(device)
+
+    # Apply MedicalNet layer4 partial tuning
+    for name, param in model.pet_encoder.named_parameters():
+        param.requires_grad = ("layer4" in name)
+
+    trainable = sum(p.numel() for p in model.parameters() if p.requires_grad)
+    total = sum(p.numel() for p in model.parameters())
+    print(f"Trainable params: {trainable:,} / {total:,} ({100*trainable/total:.1f}%)")
+
+    optimizer = torch.optim.AdamW(
+        [p for p in model.parameters() if p.requires_grad],
+        lr=args.lr, weight_decay=1e-4,
+    )
+
+    model.temperature.data.fill_(args.temperature)
+    best_val_loss = float("inf")
+
+    for epoch in range(1, args.epochs + 1):
+        model.train()
+        model.pet_encoder.train()
+        train_loss = 0.0
+        for batch in train_loader:
+            image = batch["image"].to(device, non_blocking=True)
+            suvr = batch["suvr"].to(device, non_blocking=True)
+            outputs = model(image, suvr)
+            loss, _ = alignment_loss(outputs, suvr, args.contrastive_weight, args.regression_weight)
+            optimizer.zero_grad(set_to_none=True)
+            loss.backward()
+            optimizer.step()
+            train_loss += float(loss) * image.shape[0]
+
+        train_loss /= len(train_set)
+
+        model.eval()
+        val_loss = 0.0
+        with torch.no_grad():
+            for batch in val_loader:
+                image = batch["image"].to(device, non_blocking=True)
+                suvr = batch["suvr"].to(device, non_blocking=True)
+                outputs = model(image, suvr)
+                loss, _ = alignment_loss(outputs, suvr, args.contrastive_weight, args.regression_weight)
+                val_loss += float(loss) * image.shape[0]
+        val_loss /= len(val_set)
+
+        print(f"epoch={epoch} train_loss={train_loss:.6f} val_loss={val_loss:.6f}", flush=True)
+
+        # Save every epoch
+        ckpt_path = args.out_dir / f"epoch_{epoch:02d}.pt"
+        torch.save({
+            "model": model.state_dict(),
+            "args": vars(args),
+            "epoch": epoch,
+            "val_loss": val_loss,
+        }, ckpt_path)
+
+        if val_loss < best_val_loss:
+            best_val_loss = val_loss
+            best_path = args.out_dir / "best.pt"
+            torch.save({
+                "model": model.state_dict(),
+                "args": vars(args),
+                "epoch": epoch,
+                "val_loss": val_loss,
+            }, best_path)
+            print(f"  -> best (val_loss={val_loss:.6f})", flush=True)
+
+    print(f"Done. Saved {args.epochs} checkpoints to {args.out_dir}")
+
+
+if __name__ == "__main__":
+    main()

scripts/train_pet_vlm_baseline.py

@@ -0,0 +1,141 @@
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+import torch
+from torch import nn
+from torch.utils.data import DataLoader
+
+from pet_vlm_dataset import PETSUVRDataset, collate_pet_suvr
+
+
+class Small3DPETEncoder(nn.Module):
+    def __init__(self, embed_dim: int = 256) -> None:
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.Conv3d(1, 16, 3, stride=2, padding=1),
+            nn.BatchNorm3d(16),
+            nn.GELU(),
+            nn.Conv3d(16, 32, 3, stride=2, padding=1),
+            nn.BatchNorm3d(32),
+            nn.GELU(),
+            nn.Conv3d(32, 64, 3, stride=2, padding=1),
+            nn.BatchNorm3d(64),
+            nn.GELU(),
+            nn.Conv3d(64, 128, 3, stride=2, padding=1),
+            nn.BatchNorm3d(128),
+            nn.GELU(),
+            nn.AdaptiveAvgPool3d(1),
+        )
+        self.proj = nn.Linear(128, embed_dim)
+
+    def forward(self, image: torch.Tensor) -> torch.Tensor:
+        x = self.net(image).flatten(1)
+        return self.proj(x)
+
+
+class RegionSUVREncoder(nn.Module):
+    def __init__(self, n_regions: int = 120, embed_dim: int = 256) -> None:
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.LayerNorm(n_regions),
+            nn.Linear(n_regions, 256),
+            nn.GELU(),
+            nn.Linear(256, embed_dim),
+        )
+
+    def forward(self, suvr: torch.Tensor) -> torch.Tensor:
+        return self.net(suvr)
+
+
+class PETSUVRAlignmentModel(nn.Module):
+    def __init__(self, n_regions: int = 120, embed_dim: int = 256) -> None:
+        super().__init__()
+        self.pet_encoder = Small3DPETEncoder(embed_dim)
+        self.suvr_encoder = RegionSUVREncoder(n_regions, embed_dim)
+        self.suvr_head = nn.Linear(embed_dim, n_regions)
+        self.temperature = nn.Parameter(torch.tensor(0.07))
+
+    def forward(self, image: torch.Tensor, suvr: torch.Tensor) -> dict[str, torch.Tensor]:
+        pet_z = nn.functional.normalize(self.pet_encoder(image), dim=-1)
+        suvr_z = nn.functional.normalize(self.suvr_encoder(suvr), dim=-1)
+        pred_suvr = self.suvr_head(pet_z)
+        logits = pet_z @ suvr_z.T / self.temperature.clamp_min(0.01)
+        return {"pet_z": pet_z, "suvr_z": suvr_z, "pred_suvr": pred_suvr, "logits": logits}
+
+
+def alignment_loss(outputs: dict[str, torch.Tensor], suvr: torch.Tensor) -> torch.Tensor:
+    labels = torch.arange(suvr.shape[0], device=suvr.device)
+    loss_i = nn.functional.cross_entropy(outputs["logits"], labels)
+    loss_t = nn.functional.cross_entropy(outputs["logits"].T, labels)
+    loss_reg = nn.functional.mse_loss(outputs["pred_suvr"], suvr)
+    return 0.5 * (loss_i + loss_t) + loss_reg
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Train a minimal FDG-PET + SUVR alignment baseline.")
+    parser.add_argument("--manifest", type=Path, default=Path("metadata/splits/train.csv"))
+    parser.add_argument("--val-manifest", type=Path, default=Path("metadata/splits/val.csv"))
+    parser.add_argument("--epochs", type=int, default=2)
+    parser.add_argument("--batch-size", type=int, default=2)
+    parser.add_argument("--lr", type=float, default=1e-4)
+    parser.add_argument("--num-workers", type=int, default=0)
+    parser.add_argument("--output-size", type=int, nargs=3, default=(96, 96, 96))
+    parser.add_argument("--max-samples", type=int, default=0, help="Use the first N samples for a quick smoke test.")
+    parser.add_argument("--log-every", type=int, default=10)
+    parser.add_argument("--out", type=Path, default=Path("runs/pet_suvr_baseline.pt"))
+    args = parser.parse_args()
+
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    dataset = PETSUVRDataset(args.manifest, output_size=tuple(args.output_size))
+    val_dataset = PETSUVRDataset(args.val_manifest, output_size=tuple(args.output_size))
+    if args.max_samples > 0:
+        max_samples = min(args.max_samples, len(dataset))
+        dataset = torch.utils.data.Subset(dataset, range(max_samples))
+        val_max_samples = min(max(1, args.max_samples // 4), len(val_dataset))
+        val_dataset = torch.utils.data.Subset(val_dataset, range(val_max_samples))
+    train_loader = DataLoader(dataset, batch_size=args.batch_size, shuffle=True, num_workers=args.num_workers, collate_fn=collate_pet_suvr)
+    val_loader = DataLoader(val_dataset, batch_size=args.batch_size, shuffle=False, num_workers=args.num_workers, collate_fn=collate_pet_suvr)
+
+    sample = dataset[0]
+    model = PETSUVRAlignmentModel(n_regions=int(sample["suvr"].numel())).to(device)
+    optimizer = torch.optim.AdamW(model.parameters(), lr=args.lr, weight_decay=1e-4)
+
+    for epoch in range(1, args.epochs + 1):
+        model.train()
+        train_loss = 0.0
+        for step, batch in enumerate(train_loader, start=1):
+            image = batch["image"].to(device)
+            suvr = batch["suvr"].to(device)
+            outputs = model(image, suvr)
+            loss = alignment_loss(outputs, suvr)
+            optimizer.zero_grad(set_to_none=True)
+            loss.backward()
+            optimizer.step()
+            train_loss += float(loss.detach()) * image.shape[0]
+            if args.log_every > 0 and step % args.log_every == 0:
+                print(
+                    f"epoch={epoch} step={step}/{len(train_loader)} loss={float(loss.detach()):.4f}",
+                    flush=True,
+                )
+        train_loss /= len(dataset)
+
+        model.eval()
+        val_loss = 0.0
+        with torch.no_grad():
+            for batch in val_loader:
+                image = batch["image"].to(device)
+                suvr = batch["suvr"].to(device)
+                outputs = model(image, suvr)
+                val_loss += float(alignment_loss(outputs, suvr)) * image.shape[0]
+        val_loss = val_loss / max(1, len(val_dataset))
+        print(f"epoch={epoch} train_loss={train_loss:.4f} val_loss={val_loss:.4f}")
+
+    args.out.parent.mkdir(parents=True, exist_ok=True)
+    torch.save({"model": model.state_dict(), "args": vars(args)}, args.out)
+    print(f"saved {args.out}", flush=True)
+
+
+if __name__ == "__main__":
+    main()