Upload 18 files

.gitignore

@@ -0,0 +1,4 @@
+__pycache__/
+*.py[cod]
+.pytest_cache/
+.cache/

milk10k_effb2_dermoscopic_metadata/data.py

@@ -113,6 +113,10 @@ def synthetic_mask(df: pd.DataFrame) -> np.ndarray:
     return mask
 
 
+def source_lesion_id(value: Any) -> str:
+    return str(value).split("__sdpair_", 1)[0]
+
+
 def create_or_load_split(
     df: pd.DataFrame, manifest: Path, val_size: float, seed: int,
     synthetic_train_only: bool = False, fold_index: int = 0, k_folds: int = 1,
@@ -138,12 +142,18 @@ def create_or_load_split(
             raise ValueError(f"Split manifest has overlapping train/validation IDs: {manifest}")
         unknown = (train_ids | val_ids) - all_ids
         missing = all_ids - (train_ids | val_ids)
-        if unknown or missing:
+        allowed_missing = set()
+        if synthetic_train_only:
+            allowed_missing = {
+                lesion_id for lesion_id in missing
+                if "__sdpair_" in lesion_id and source_lesion_id(lesion_id) in val_ids
+            }
+        unexpected_missing = missing - allowed_missing
+        if unknown or unexpected_missing:
             raise ValueError(f"Split manifest does not match dataset (unknown={len(unknown)}, missing={len(missing)}).")
     else:
         synthetic = synthetic_mask(df)
         base = df.loc[~synthetic].copy() if synthetic_train_only else df.copy()
-        extra_train_ids = set(df.loc[synthetic, "lesion_id"].astype(str)) if synthetic_train_only else set()
         folds = []
         if k_folds == 1:
             train_rows, val_rows = train_test_split(base, test_size=val_size, stratify=base["label"], random_state=seed)
@@ -155,9 +165,23 @@ def create_or_load_split(
             splitter = StratifiedKFold(k_folds, shuffle=True, random_state=seed)
             pairs = [(base.iloc[tr], base.iloc[va]) for tr, va in splitter.split(base, base["label"])]
         for train_rows, val_rows in pairs:
+            train_real_ids = set(train_rows["lesion_id"].astype(str))
+            val_real_ids = set(val_rows["lesion_id"].astype(str))
+            extra_train_ids = set()
+            excluded_synthetic_ids = set()
+            if synthetic_train_only:
+                for lesion_id in df.loc[synthetic, "lesion_id"].astype(str):
+                    source_id = source_lesion_id(lesion_id)
+                    if source_id in train_real_ids:
+                        extra_train_ids.add(lesion_id)
+                    elif source_id in val_real_ids:
+                        excluded_synthetic_ids.add(lesion_id)
+                    else:
+                        raise ValueError(f"Synthetic lesion has unknown source ID: {lesion_id}")
             folds.append({
                 "train_lesion_ids": sorted(set(train_rows["lesion_id"].astype(str)) | extra_train_ids),
                 "val_lesion_ids": sorted(set(val_rows["lesion_id"].astype(str))),
+                "excluded_synthetic_lesion_ids": sorted(excluded_synthetic_ids),
             })
         train_ids = set(folds[fold_index]["train_lesion_ids"]); val_ids = set(folds[fold_index]["val_lesion_ids"])
         manifest.parent.mkdir(parents=True, exist_ok=True)
@@ -180,6 +204,14 @@ def append_augmented_rows(base_df: pd.DataFrame, train_df: pd.DataFrame, args) -
     if args.augmented_data_dir is None: return train_df
     augmented = load_dermoscopic_dataframe(args.augmented_data_dir)
     augmented = augmented[~augmented["lesion_id"].astype(str).isin(set(base_df["lesion_id"].astype(str)))].copy()
+    train_source_ids = set(train_df["lesion_id"].astype(str).map(source_lesion_id))
+    base_source_ids = set(base_df["lesion_id"].astype(str).map(source_lesion_id))
+    augmented["source_lesion_id"] = augmented["lesion_id"].astype(str).map(source_lesion_id)
+    unknown = ~augmented["source_lesion_id"].isin(base_source_ids)
+    if unknown.any():
+        examples = augmented.loc[unknown, "lesion_id"].astype(str).head(5).tolist()
+        raise ValueError(f"Augmented lesions have unknown source IDs. Examples: {examples}")
+    augmented = augmented[augmented["source_lesion_id"].isin(train_source_ids)].copy()
     if args.augmented_classes:
         allowed = {name.upper() for name in args.augmented_classes}
         unknown = allowed - {name.upper() for name in base_df["label"].unique()}

requirements.txt

@@ -0,0 +1,8 @@
+numpy
+pandas
+pillow
+scikit-learn
+timm
+torch
+torchvision
+tqdm

tests/test_parity.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+import argparse,json,tempfile,unittest
+from pathlib import Path
+from unittest.mock import patch
+import numpy as np,pandas as pd,torch
+from PIL import Image
+from torch import nn
+
+from milk10k_effb2_dermoscopic_metadata.data import (DermoscopicMetadataDataset,append_augmented_rows,
+    create_or_load_split,fit_metadata_spec,metadata_vector,source_lesion_id,synthetic_mask)
+from milk10k_effb2_dermoscopic_metadata.losses import LDAMLoss,build_loss
+from milk10k_effb2_dermoscopic_metadata.model import DermoscopicMetadataClassifier
+from milk10k_effb2_dermoscopic_metadata.training import parse_args,train_split
+from milk10k_effb2_dermoscopic_metadata.inference import parse_args as parse_inference_args,run as run_inference
+
+
+class FakeEncoder(nn.Module):
+    num_features=8
+    def forward(self,x):
+        pooled=x.mean((2,3));return torch.cat([pooled,pooled,pooled[:,:2]],1)
+
+
+def rows(root,count=12):
+    result=[]
+    for i in range(count):
+        path=root/f"{i}.jpg";Image.fromarray(np.full((24,24,3),100+i,dtype=np.uint8)).save(path)
+        result.append({"lesion_id":f"L{i}","isic_id":f"I{i}","image_path":str(path),"label":"A" if i%2==0 else "B",
+                       "age_approx":50,"sex":"x","skin_tone_class":2,"site":"arm","MONET_hair":.1,
+                       "is_augmented":False,"ignore_metadata":False})
+    return pd.DataFrame(result)
+
+
+class ParityTests(unittest.TestCase):
+    def test_manifest_v2_synthetic_never_in_validation_and_kfold_reuses(self):
+        df=pd.DataFrame([{"lesion_id":f"R{i}","label":"A" if i%2==0 else "B"} for i in range(20)]+[
+            {"lesion_id":f"R{i}__sdpair_{i}","label":"A" if i%2==0 else "B"} for i in range(4)])
+        with tempfile.TemporaryDirectory() as tmp:
+            path=Path(tmp)/"split.json"
+            for fold in range(3):
+                tr,va=create_or_load_split(df,path,.2,42,True,fold,3)
+                self.assertFalse(synthetic_mask(va).any())
+                train_sources=set(tr.loc[~synthetic_mask(tr),"lesion_id"].astype(str))
+                val_sources=set(va["lesion_id"].astype(str))
+                synthetic_sources={source_lesion_id(x) for x in tr.loc[synthetic_mask(tr),"lesion_id"]}
+                self.assertTrue(synthetic_sources <= train_sources)
+                self.assertFalse(synthetic_sources & val_sources)
+            payload=json.loads(path.read_text());self.assertEqual(payload["schema_version"],2);self.assertEqual(len(payload["folds"]),3)
+
+    def test_legacy_manifest_with_synthetic_validation_is_rejected(self):
+        df=pd.DataFrame([{"lesion_id":"A","label":"X"},{"lesion_id":"B__sdpair_1","label":"X"}])
+        with tempfile.TemporaryDirectory() as tmp:
+            path=Path(tmp)/"split.json";path.write_text(json.dumps({"train_lesion_ids":["A"],"val_lesion_ids":["B__sdpair_1"]}))
+            with self.assertRaisesRegex(ValueError,"synthetic validation"):create_or_load_split(df,path,.2,1,True)
+
+    def test_appended_augmentation_cap_and_zero_metadata(self):
+        base=pd.DataFrame([{"lesion_id":"base","label":"A"}]);aug=pd.DataFrame([
+            {"lesion_id":f"base__sdpair_{i}","label":"A","age_approx":1} for i in range(4)])
+        args=argparse.Namespace(augmented_data_dir=Path("x"),augmented_classes=["A"],augmented_max_per_class=2,seed=1,zero_augmented_metadata=True)
+        with patch("milk10k_effb2_dermoscopic_metadata.data.load_dermoscopic_dataframe",return_value=aug):
+            result=append_augmented_rows(base,base.copy(),args)
+        self.assertEqual(len(result),3);self.assertEqual(sum(bool(x) for x in result.ignore_metadata if pd.notna(x)),2)
+
+    def test_sampler_power_and_zero_metadata_dataset(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            df=rows(Path(tmp),4);df.loc[0,"ignore_metadata"]=True;spec=fit_metadata_spec(df)
+            ds=DermoscopicMetadataDataset(df,{"A":0,"B":1},spec,lambda _:torch.zeros(3,8,8))
+            self.assertTrue(torch.all(ds[0]["metadata"]==0))
+
+    def test_all_losses_and_ldam_epoch_switch(self):
+        df=pd.DataFrame({"label":["A","A","B","B"]});mapping={"A":0,"B":1};device=torch.device("cpu")
+        base=dict(class_weight=True,focal_gamma=2.,dice_weight=.3,f1_weight=.3,f1_ignore_classes=[],f1_class_weight=[],
+                  ldam_beta=.9,ldam_max_margin=.5,ldam_drw_start_epoch=2,ldam_alpha_max=10.)
+        logits=torch.randn(4,2,requires_grad=True);labels=torch.tensor([0,0,1,1])
+        for name in ("ce","focal","ldam","ce_dice","ce_f1"):
+            loss=build_loss(df,mapping,argparse.Namespace(loss=name,**base),device);value=loss(logits,labels);self.assertTrue(torch.isfinite(value))
+        ldam=build_loss(df,mapping,argparse.Namespace(loss="ldam",**base),device);self.assertIsInstance(ldam,LDAMLoss);ldam.set_epoch(3);self.assertEqual(ldam.current_epoch,3)
+
+    def test_model_modes_and_old_checkpoint_shape(self):
+        with patch("milk10k_effb2_dermoscopic_metadata.model.timm.create_model",return_value=FakeEncoder()):
+            for mode in ("none","concat","gated_concat","gated_only"):
+                model=DermoscopicMetadataClassifier(2,7,mode,imagenet_pretrained=False,branch_dim=8,metadata_dim=4,classifier_hidden_dim=6,metadata_gate_hidden_dim=3)
+                self.assertEqual(tuple(model(torch.rand(2,3,8,8),torch.rand(2,7)).shape),(2,2))
+
+    def test_training_outputs_checkpoint_v2_and_resume(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root=Path(tmp);df=rows(root);train=df.iloc[:8].copy();val=df.iloc[8:].copy();out=root/"run"
+            args=parse_args(["--data-dir",str(root),"--output-dir",str(out),"--split-manifest",str(root/"split.json"),
+                "--metadata-mode","concat","--image-size","16","--batch-size","4","--freeze-epochs","1","--finetune-epochs","0","--patience","0"])
+            with patch("milk10k_effb2_dermoscopic_metadata.model.timm.create_model",return_value=FakeEncoder()):
+                train_split(df,train,val,["A","B"],{"A":0,"B":1},args,torch.device("cpu"),"timm",out)
+            checkpoint=torch.load(out/"last.pt",map_location="cpu",weights_only=False)
+            self.assertEqual(checkpoint["schema_version"],2);self.assertIn("scheduler_state",checkpoint);self.assertIn("scaler_state",checkpoint)
+            args.resume_checkpoint=out/"last.pt";args.freeze_epochs=2
+            with patch("milk10k_effb2_dermoscopic_metadata.model.timm.create_model",return_value=FakeEncoder()):
+                train_split(df,train,val,["A","B"],{"A":0,"B":1},args,torch.device("cpu"),"timm",out)
+            self.assertEqual(int(pd.read_csv(out/"history.csv").epoch.max()),2)
+            for name in ("best.pt","history.csv","metrics.json","data_summary.json","split_summary.md","run_report.md","prediction_summary.json","confusion_analysis.json"):
+                self.assertTrue((out/name).exists(),name)
+
+    def test_inference_old_checkpoint_tta_calibration_and_debug_columns(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root=Path(tmp);inputs=root/"input";lesion=inputs/"L1";lesion.mkdir(parents=True)
+            Image.fromarray(np.full((20,20,3),120,dtype=np.uint8)).save(lesion/"I1.jpg")
+            metadata_csv=root/"metadata.csv";pd.DataFrame([{"lesion_id":"L1","isic_id":"I1","image_type":"dermoscopic",
+                "age_approx":50,"sex":"x","skin_tone_class":2,"site":"arm","MONET_hair":.1}]).to_csv(metadata_csv,index=False)
+            spec={"sex_values":["unknown","x"],"site_values":["arm","unknown"],"monet_columns":["MONET_hair"]}
+            with patch("milk10k_effb2_dermoscopic_metadata.model.timm.create_model",return_value=FakeEncoder()):
+                model=DermoscopicMetadataClassifier(2,7,"concat",imagenet_pretrained=False,branch_dim=8,metadata_dim=4,classifier_hidden_dim=6)
+            checkpoint=root/"old.pt";torch.save({"model_state":model.state_dict(),"class_names":["A","B"],"metadata_spec":spec,
+                "args":{"metadata_mode":"concat","backbone":"efficientnet_b2","backbone_backend":"timm","branch_dim":8,"metadata_dim":4,"classifier_hidden_dim":6,"dropout":.3,"image_size":16}},checkpoint)
+            calibration=root/"bias.json";calibration.write_text(json.dumps({"class_names":["A","B"],"class_bias":[0,0]}))
+            output=root/"pred.csv";args=parse_inference_args(["--checkpoint",str(checkpoint),"--input-dir",str(inputs),"--metadata-csv",str(metadata_csv),
+                "--output",str(output),"--tta-flips","--calibration-file",str(calibration),"--include-debug-columns"])
+            with patch("milk10k_effb2_dermoscopic_metadata.model.timm.create_model",return_value=FakeEncoder()):run_inference(args)
+            columns=pd.read_csv(output).columns.tolist();self.assertIn("predicted_label",columns);self.assertIn("confidence",columns);self.assertIn("isic_id",columns)
+
+
+if __name__=="__main__":unittest.main()