Upload 171 files

milk10k_effb2_metadata/cli.py

@@ -83,6 +83,8 @@ def parse_args() -> argparse.Namespace:
             "adaptive_gate",
             "moe",
             "shared_private",
+            "single_encoder_canvas",
+            "shared_encoder_pool",
         ],
         default="concat",
         help="Image representation fusion mode. concat keeps the baseline final fusion.",

milk10k_effb2_metadata/inference.py

@@ -29,6 +29,7 @@ from milk10k_effb2_metadata.metrics import apply_class_bias, compute_metrics
 from milk10k_effb2_metadata.model_setup import load_model_state_compat
 from milk10k_effb2_metadata.models import (
     DualEffB2MetadataClassifier,
+    is_one_encoder_image_fusion,
     model_class_for_backbone,
     normalize_backbone_name,
     resolve_image_size,
@@ -198,9 +199,15 @@ def build_model_from_checkpoint(checkpoint: dict[str, Any], metadata_dim: int, d
     state = checkpoint["model_state"]
     checkpoint_args = checkpoint.get("args", {})
     class_names = checkpoint["class_names"]
-    clinical_backend = infer_backend_from_model_state(state, "clinical_encoder.")
-    dermoscopic_backend = infer_backend_from_model_state(state, "dermoscopic_encoder.")
     backbone = normalize_backbone_name(checkpoint_arg(checkpoint_args, "backbone", "efficientnet_b2"))
+    image_fusion = checkpoint_arg(checkpoint_args, "image_fusion", "concat")
+    if is_one_encoder_image_fusion(image_fusion):
+        shared_backend = infer_backend_from_model_state(state, "shared_encoder.")
+        clinical_backend = shared_backend
+        dermoscopic_backend = shared_backend
+    else:
+        clinical_backend = infer_backend_from_model_state(state, "clinical_encoder.")
+        dermoscopic_backend = infer_backend_from_model_state(state, "dermoscopic_encoder.")
     model_class = model_class_for_backbone(backbone)
     saved_model_type = checkpoint.get("model_type")
     if saved_model_type is not None and saved_model_type != model_class.__name__:
@@ -221,7 +228,7 @@ def build_model_from_checkpoint(checkpoint: dict[str, Any], metadata_dim: int, d
         backbone=backbone,
         disable_metadata=checkpoint_arg(checkpoint_args, "disable_metadata", False),
         metadata_fusion=checkpoint_arg(checkpoint_args, "metadata_fusion", "concat"),
-        image_fusion=checkpoint_arg(checkpoint_args, "image_fusion", "concat"),
+        image_fusion=image_fusion,
         metadata_gate_hidden_dim=checkpoint_args.get("metadata_gate_hidden_dim"),
         classifier_style=checkpoint_arg(checkpoint_args, "classifier_style", "legacy"),
         logit_fusion_mode=checkpoint_arg(checkpoint_args, "logit_fusion_mode", "single"),

milk10k_effb2_metadata/milk10k_effb2_metadata/cli.py

@@ -9,6 +9,18 @@ from pathlib import Path
 def parse_args() -> argparse.Namespace:
     parser = argparse.ArgumentParser(description="Train MILK10k dual-image backbones with metadata fusion.")
     parser.add_argument("--data-dir", type=Path, default=None)
+    parser.add_argument(
+        "--dermoscopic-mask-dir",
+        type=Path,
+        default=None,
+        help="Optional directory containing <lesion_id>_dermoscopic_mask.png files.",
+    )
+    parser.add_argument(
+        "--min-dermoscopic-mask-ratio",
+        type=float,
+        default=0.01,
+        help="Fallback to the original dermoscopic image when mask foreground ratio is below this value.",
+    )
     parser.add_argument(
         "--clinical-checkpoint",
         type=Path,
@@ -35,7 +47,10 @@ def parse_args() -> argparse.Namespace:
     parser.add_argument(
         "--backbone",
         default="efficientnet_b2",
-        help="Backbone model architecture (efficientnet_b2, efficientnet_b1, resnet50, convnext_base).",
+        help=(
+            "Backbone model architecture (efficientnet_b2, tf_efficientnetv2_b2, "
+            "efficientnet_b1, resnet50, convnext_base)."
+        ),
     )
     parser.add_argument(
         "--num-workers",
@@ -68,6 +83,8 @@ def parse_args() -> argparse.Namespace:
             "adaptive_gate",
             "moe",
             "shared_private",
+            "single_encoder_canvas",
+            "shared_encoder_pool",
         ],
         default="concat",
         help="Image representation fusion mode. concat keeps the baseline final fusion.",
@@ -95,10 +112,42 @@ def parse_args() -> argparse.Namespace:
         action="store_true",
         help="Keep synthetic lesion IDs containing __sdpair_ in train only; validation is split from real lesions.",
     )
+    parser.add_argument(
+        "--augmented-data-dir",
+        type=Path,
+        default=None,
+        help="Optional augmented MILK10k-style data dir. Only extra lesion IDs are appended to the train split.",
+    )
+    parser.add_argument(
+        "--augmented-max-per-class",
+        type=int,
+        default=0,
+        help="Cap extra augmented lesions per class. 0 keeps all extra rows from --augmented-data-dir.",
+    )
+    parser.add_argument(
+        "--augmented-classes",
+        nargs="*",
+        default=[],
+        help="Optional class-name allowlist for appended augmented lesions, e.g. --augmented-classes INF BEN_OTH DF VASC.",
+    )
+    parser.add_argument(
+        "--zero-augmented-metadata",
+        action="store_true",
+        help="Set metadata vectors to all zeros for rows appended from --augmented-data-dir.",
+    )
     parser.add_argument("--seed", type=int, default=42)
     parser.add_argument("--branch-dim", type=int, default=512)
     parser.add_argument("--metadata-dim", type=int, default=64)
     parser.add_argument("--classifier-hidden-dim", type=int, default=512)
+    parser.add_argument(
+        "--classifier-style",
+        choices=["legacy", "simple"],
+        default="legacy",
+        help=(
+            "Final fused classifier architecture. legacy keeps the existing LayerNorm/GELU head; "
+            "simple uses Linear-ReLU-Dropout-Linear."
+        ),
+    )
     parser.add_argument("--dropout", type=float, default=0.3)
     parser.add_argument(
         "--logit-fusion-mode",
@@ -112,6 +161,30 @@ def parse_args() -> argparse.Namespace:
     parser.add_argument("--class-weight", action="store_true")
     parser.add_argument("--weighted-sampler", action="store_true")
     parser.add_argument("--sampler-power", type=float, default=1.0)
+    parser.add_argument(
+        "--balance-mode",
+        choices=["none", "hybrid"],
+        default="none",
+        help="Train-only epoch balancing. hybrid caps the largest class and mildly oversamples eligible tail classes.",
+    )
+    parser.add_argument(
+        "--balance-head-ratio",
+        type=float,
+        default=2.0,
+        help="In hybrid mode, cap the largest class at this multiple of the second-largest class.",
+    )
+    parser.add_argument(
+        "--balance-tail-floor",
+        type=int,
+        default=100,
+        help="In hybrid mode, oversample eligible classes below this count up to this many rows per epoch.",
+    )
+    parser.add_argument(
+        "--balance-min-source-count",
+        type=int,
+        default=20,
+        help="Do not oversample a class with fewer real train rows than this value.",
+    )
     parser.add_argument("--loss", choices=["ce", "focal", "ldam", "ce_dice", "ce_f1"], default="ce")
     parser.add_argument("--focal-gamma", type=float, default=2.0)
     parser.add_argument("--dice-weight", type=float, default=0.3)
@@ -172,4 +245,13 @@ def parse_args() -> argparse.Namespace:
     parser.add_argument("--calibration-step", type=float, default=0.25)
     parser.add_argument("--calibration-passes", type=int, default=3)
     parser.add_argument("--patience", type=int, default=6)
+    parser.add_argument("--tau", type=float, default=0.0, help="Generalized Balanced Softmax strength in [0, 0.5].")
+    parser.add_argument("--lws-epochs", type=int, default=0, help="Number of LWS post-training epochs; 0 disables LWS.")
+    parser.add_argument("--lws-lr", type=float, default=1e-2)
+    parser.add_argument("--lws-sampler-power", type=float, default=0.5)
+    parser.add_argument("--lws-min-scale", type=float, default=0.75)
+    parser.add_argument("--lws-max-scale", type=float, default=1.5)
+    parser.add_argument("--ema", action="store_true", help="Enable Exponential Moving Average (EMA) for model weights")
+    parser.add_argument("--ema-decay", type=float, default=0.999, help="Decay rate for EMA")
+    parser.add_argument("--fit-temperature", action="store_true", help="Fit one positive validation temperature per checkpoint variant.")
     return parser.parse_args()

milk10k_effb2_metadata/milk10k_effb2_metadata/inference.py

@@ -15,10 +15,21 @@ from torch.utils.data import DataLoader, Dataset
 from tqdm.auto import tqdm
 
 from datasets import LABEL_COLUMNS, normalize_image_type
-from milk10k_effb2_metadata.data import METADATA_COLUMNS, make_transforms, metadata_vector, resolve_monet_columns
+from milk10k_effb2_metadata.data import (
+    DERMOSCOPIC_MASK_PATH_COLUMN,
+    METADATA_COLUMNS,
+    apply_dermoscopic_mask,
+    audit_dermoscopic_masks,
+    make_transforms,
+    metadata_vector,
+    print_mask_audit_summary,
+    resolve_monet_columns,
+)
 from milk10k_effb2_metadata.metrics import apply_class_bias, compute_metrics
+from milk10k_effb2_metadata.model_setup import load_model_state_compat
 from milk10k_effb2_metadata.models import (
     DualEffB2MetadataClassifier,
+    is_one_encoder_image_fusion,
     model_class_for_backbone,
     normalize_backbone_name,
     resolve_image_size,
@@ -35,9 +46,9 @@ class InferencePairedDataset(Dataset):
     def __len__(self) -> int:
         return len(self.df)
 
-    def _load_image(self, path: str) -> torch.Tensor:
+    def _load_image(self, path: str, mask_path: str | Path | None = None) -> torch.Tensor:
         with Image.open(path) as img:
-            image = img.convert("RGB")
+            image = apply_dermoscopic_mask(img, mask_path)
         if self.transform is not None:
             image = self.transform(image)
         return image
@@ -46,7 +57,10 @@ class InferencePairedDataset(Dataset):
         row = self.df.iloc[idx]
         return {
             "clinical": self._load_image(row["clinical_path"]),
-            "dermoscopic": self._load_image(row["dermoscopic_path"]),
+            "dermoscopic": self._load_image(
+                row["dermoscopic_path"],
+                row.get(DERMOSCOPIC_MASK_PATH_COLUMN),
+            ),
             "metadata": torch.from_numpy(self.metadata[idx]),
         }
 
@@ -63,6 +77,18 @@ def parse_args() -> argparse.Namespace:
     parser.add_argument("--data-dir", type=Path, default=None, help="Directory containing MILK10k input/metadata files.")
     parser.add_argument("--input-dir", type=Path, default=None, help="Image root. Overrides --data-dir/MILK10k_Training_Input.")
     parser.add_argument("--metadata-csv", type=Path, default=None, help="Metadata CSV. Overrides --data-dir/MILK10k_Training_Metadata.csv.")
+    parser.add_argument(
+        "--dermoscopic-mask-dir",
+        type=Path,
+        default=None,
+        help="Optional directory containing <lesion_id>_dermoscopic_mask.png files.",
+    )
+    parser.add_argument(
+        "--min-dermoscopic-mask-ratio",
+        type=float,
+        default=0.01,
+        help="Fallback to the original dermoscopic image when mask foreground ratio is below this value.",
+    )
     parser.add_argument("--groundtruth-csv", type=Path, default=None, help="Optional ground-truth CSV for metrics.")
     parser.add_argument("--output", type=Path, default=Path("test_predictions.csv"))
     parser.add_argument("--batch-size", type=int, default=16)
@@ -173,9 +199,15 @@ def build_model_from_checkpoint(checkpoint: dict[str, Any], metadata_dim: int, d
     state = checkpoint["model_state"]
     checkpoint_args = checkpoint.get("args", {})
     class_names = checkpoint["class_names"]
-    clinical_backend = infer_backend_from_model_state(state, "clinical_encoder.")
-    dermoscopic_backend = infer_backend_from_model_state(state, "dermoscopic_encoder.")
     backbone = normalize_backbone_name(checkpoint_arg(checkpoint_args, "backbone", "efficientnet_b2"))
+    image_fusion = checkpoint_arg(checkpoint_args, "image_fusion", "concat")
+    if is_one_encoder_image_fusion(image_fusion):
+        shared_backend = infer_backend_from_model_state(state, "shared_encoder.")
+        clinical_backend = shared_backend
+        dermoscopic_backend = shared_backend
+    else:
+        clinical_backend = infer_backend_from_model_state(state, "clinical_encoder.")
+        dermoscopic_backend = infer_backend_from_model_state(state, "dermoscopic_encoder.")
     model_class = model_class_for_backbone(backbone)
     saved_model_type = checkpoint.get("model_type")
     if saved_model_type is not None and saved_model_type != model_class.__name__:
@@ -196,20 +228,29 @@ def build_model_from_checkpoint(checkpoint: dict[str, Any], metadata_dim: int, d
         backbone=backbone,
         disable_metadata=checkpoint_arg(checkpoint_args, "disable_metadata", False),
         metadata_fusion=checkpoint_arg(checkpoint_args, "metadata_fusion", "concat"),
-        image_fusion=checkpoint_arg(checkpoint_args, "image_fusion", "concat"),
+        image_fusion=image_fusion,
         metadata_gate_hidden_dim=checkpoint_args.get("metadata_gate_hidden_dim"),
+        classifier_style=checkpoint_arg(checkpoint_args, "classifier_style", "legacy"),
         logit_fusion_mode=checkpoint_arg(checkpoint_args, "logit_fusion_mode", "single"),
         fusion_logit_weight=checkpoint_arg(checkpoint_args, "fusion_logit_weight", 0.6),
         clinical_logit_weight=checkpoint_arg(checkpoint_args, "clinical_logit_weight", 0.2),
         dermoscopic_logit_weight=checkpoint_arg(checkpoint_args, "dermoscopic_logit_weight", 0.2),
     ).to(device)
-    model.load_state_dict(state)
+    load_model_state_compat(model, state)
     model.eval()
     return model
 
 
 @torch.no_grad()
-def predict_dataframe(model: DualEffB2MetadataClassifier, loader: DataLoader, device: torch.device, tta_flips: bool = False) -> np.ndarray:
+def predict_dataframe(
+    model: DualEffB2MetadataClassifier,
+    loader: DataLoader,
+    device: torch.device,
+    tta_flips: bool = False,
+    temperature: float = 1.0,
+) -> np.ndarray:
+    if temperature <= 0.0:
+        raise ValueError(f"Checkpoint temperature must be positive, got {temperature}.")
     probs_all = []
     for batch in tqdm(loader, leave=False):
         clinical = batch["clinical"].to(device, non_blocking=True)
@@ -227,7 +268,7 @@ def predict_dataframe(model: DualEffB2MetadataClassifier, loader: DataLoader, de
         probs = None
         for clinical_view, dermoscopic_view in views:
             logits = model(clinical_view, dermoscopic_view, metadata)
-            view_prob = torch.softmax(logits, dim=1)
+            view_prob = torch.softmax(logits / temperature, dim=1)
             probs = view_prob if probs is None else probs + view_prob
         probs_all.append((probs / len(views)).cpu().numpy())
     return np.concatenate(probs_all)
@@ -294,6 +335,21 @@ def main() -> None:
     device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
     input_dir, metadata_csv, groundtruth_csv = resolve_input_paths(args)
     df = load_inference_dataframe(input_dir, metadata_csv, groundtruth_csv)
+    if not 0.0 <= args.min_dermoscopic_mask_ratio <= 1.0:
+        raise ValueError("--min-dermoscopic-mask-ratio must be between 0 and 1.")
+    if args.dermoscopic_mask_dir is not None:
+        args.dermoscopic_mask_dir = args.dermoscopic_mask_dir.expanduser().resolve()
+        df, mask_audit = audit_dermoscopic_masks(
+            df,
+            args.dermoscopic_mask_dir,
+            args.min_dermoscopic_mask_ratio,
+            mask_id_column="dermoscopic_isic_id",
+            mask_suffix="_mask.png",
+        )
+        audit_output = args.output.with_name(f"{args.output.stem}.mask_audit.csv")
+        audit_output.parent.mkdir(parents=True, exist_ok=True)
+        mask_audit.to_csv(audit_output, index=False)
+        print_mask_audit_summary(mask_audit, args.min_dermoscopic_mask_ratio)
     checkpoint_paths = resolve_checkpoint_paths(args)
     ensemble_probs = []
     class_names: list[str] | None = None
@@ -324,7 +380,18 @@ def main() -> None:
             shuffle=False,
         )
         model = build_model_from_checkpoint(checkpoint, dataset.metadata.shape[1], device)
-        y_prob = predict_dataframe(model, loader, device, tta_flips=args.tta_flips)
+        temperature = float(checkpoint.get("temperature", 1.0))
+        y_prob = predict_dataframe(
+            model,
+            loader,
+            device,
+            tta_flips=args.tta_flips,
+            temperature=temperature,
+        )
+        print(
+            f"Checkpoint {checkpoint_path.name}: variant={checkpoint.get('checkpoint_variant', 'legacy')}, "
+            f"temperature={temperature:.4f}"
+        )
         class_bias = load_calibration_bias(checkpoint_path, args, checkpoint_class_names)
         if class_bias is not None:
             y_prob = apply_class_bias(y_prob, class_bias)
@@ -334,6 +401,23 @@ def main() -> None:
     y_prob = np.mean(ensemble_probs, axis=0)
     save_inference_outputs(df, y_prob, class_names, args.output, args.include_debug_columns)
 
+    y_pred = y_prob.argmax(axis=1)
+    for tail_name in ("DF", "INF"):
+        if tail_name not in class_names:
+            continue
+        idx = class_names.index(tail_name)
+        predicted_count = int((y_pred == idx).sum())
+        max_probability = float(y_prob[:, idx].max())
+        mean_probability = float(y_prob[:, idx].mean())
+        print(
+            f"Tail audit {tail_name}: predicted_count={predicted_count}, "
+            f"mean_probability={mean_probability:.6f}, max_probability={max_probability:.6f}"
+        )
+        if predicted_count == 0:
+            print(f"WARNING: no sample is predicted as {tail_name}.")
+        if max_probability < 0.01:
+            print(f"WARNING: {tail_name} maximum probability is below 0.01.")
+
     print(f"Saved predictions: {args.output}")
     if "label" in df.columns and df["label"].notna().all():
         label_to_idx = {label: idx for idx, label in enumerate(class_names)}

milk10k_effb2_metadata/milk10k_effb2_metadata/model_setup.py

@@ -12,7 +12,25 @@ from milk10k_effb2_metadata.checkpoints import (
     load_encoder_checkpoint,
     resolve_backbone_backends,
 )
-from milk10k_effb2_metadata.models import DualEffB2MetadataClassifier, model_class_for_backbone
+from milk10k_effb2_metadata.models import (
+    DualEffB2MetadataClassifier,
+    is_one_encoder_image_fusion,
+    model_class_for_backbone,
+)
+
+
+def load_model_state_compat(model: DualEffB2MetadataClassifier, state: dict[str, torch.Tensor]) -> None:
+    """Load checkpoints created before LWS added the class_scales parameter."""
+    incompatible = model.load_state_dict(state, strict=False)
+    missing = set(incompatible.missing_keys)
+    unexpected = set(incompatible.unexpected_keys)
+    allowed_missing = {"class_scales"}
+    if missing - allowed_missing or unexpected:
+        raise RuntimeError(
+            f"Checkpoint state mismatch: missing={sorted(missing)}, unexpected={sorted(unexpected)}"
+        )
+    if "class_scales" in missing:
+        model.class_scales.data.fill_(1.0)
 
 
 def infer_branch_backend_from_state(state: dict[str, torch.Tensor], branch_prefix: str) -> str:
@@ -31,6 +49,21 @@ def infer_branch_backend_from_state(state: dict[str, torch.Tensor], branch_prefi
 
 
 def resolve_training_backbone_backends(args: argparse.Namespace, device: torch.device) -> tuple[str, str]:
+    image_fusion = getattr(args, "image_fusion", "concat")
+    if is_one_encoder_image_fusion(image_fusion):
+        if args.backbone_backend != "auto":
+            return args.backbone_backend, args.backbone_backend
+        if args.resume_checkpoint is not None:
+            checkpoint = torch.load(args.resume_checkpoint.expanduser().resolve(), map_location=device, weights_only=False)
+            state = checkpoint["model_state"]
+            backend = infer_branch_backend_from_state(state, "shared_encoder.")
+            checkpoint_args = checkpoint.get("args", {})
+            if checkpoint_args.get("backbone") and args.backbone == "efficientnet_b2":
+                args.backbone = checkpoint_args["backbone"]
+            print(f"Auto-detected resume shared backend: shared={backend}")
+            return backend, backend
+        print("One-encoder image fusion: using timm backbone initialized from ImageNet weights.")
+        return "timm", "timm"
     if args.backbone_backend != "auto":
         return args.backbone_backend, args.backbone_backend
     if args.clinical_checkpoint is not None and args.dermoscopic_checkpoint is not None:
@@ -74,9 +107,16 @@ def build_optimizer(
     for name, param in model.named_parameters():
         if not param.requires_grad:
             continue
-        if name.startswith(("clinical_encoder.", "dermoscopic_encoder.")):
+        if name.startswith(("clinical_encoder.", "dermoscopic_encoder.", "shared_encoder.")):
             encoder_params.append(param)
-        elif name.startswith(("metadata_head.", "clinical_metadata_gate.", "dermoscopic_metadata_gate.")):
+        elif name.startswith(
+            (
+                "metadata_head.",
+                "clinical_metadata_gate.",
+                "dermoscopic_metadata_gate.",
+                "shared_metadata_gate.",
+            )
+        ):
             metadata_params.append(param)
         else:
             head_params.append(param)
@@ -92,7 +132,7 @@ def build_optimizer(
 def set_metadata_head_trainable(model: DualEffB2MetadataClassifier, trainable: bool) -> None:
     for param in model.metadata_head.parameters():
         param.requires_grad = trainable
-    for module_name in ("clinical_metadata_gate", "dermoscopic_metadata_gate"):
+    for module_name in ("clinical_metadata_gate", "dermoscopic_metadata_gate", "shared_metadata_gate"):
         module = getattr(model, module_name, None)
         if module is not None:
             for param in module.parameters():
@@ -103,6 +143,7 @@ def load_resume_checkpoint(
     checkpoint_path: Path | None,
     model: DualEffB2MetadataClassifier,
     device: torch.device,
+    ema_model: torch.nn.Module | None = None,
 ) -> tuple[int, float, str | None]:
     if checkpoint_path is None:
         return 1, float("-inf"), None
@@ -110,7 +151,9 @@ def load_resume_checkpoint(
     if not checkpoint_path.exists():
         raise FileNotFoundError(f"Resume checkpoint not found: {checkpoint_path}")
     checkpoint = torch.load(checkpoint_path, map_location=device, weights_only=False)
-    model.load_state_dict(checkpoint["model_state"])
+    load_model_state_compat(model, checkpoint["model_state"])
+    if ema_model is not None and "ema_model_state" in checkpoint:
+        ema_model.load_state_dict(checkpoint["ema_model_state"])
     next_epoch = int(checkpoint.get("epoch", 0)) + 1
     best_val_f1 = float(
         checkpoint.get(
@@ -152,12 +195,13 @@ def build_model(
         metadata_fusion=args.metadata_fusion,
         image_fusion=getattr(args, "image_fusion", "concat"),
         metadata_gate_hidden_dim=args.metadata_gate_hidden_dim,
+        classifier_style=getattr(args, "classifier_style", "legacy"),
         logit_fusion_mode=args.logit_fusion_mode,
         fusion_logit_weight=args.fusion_logit_weight,
         clinical_logit_weight=args.clinical_logit_weight,
         dermoscopic_logit_weight=args.dermoscopic_logit_weight,
     ).to(device)
-    if args.resume_checkpoint is None:
+    if args.resume_checkpoint is None and not is_one_encoder_image_fusion(getattr(args, "image_fusion", "concat")):
         if args.clinical_checkpoint is not None:
             load_encoder_checkpoint(args.clinical_checkpoint, model.clinical_encoder, "clinical", device)
         if args.dermoscopic_checkpoint is not None:

milk10k_effb2_metadata/milk10k_effb2_metadata/models.py

@@ -7,6 +7,12 @@ import torch
 import torch.nn.functional as F
 from torch import nn
 
+ONE_ENCODER_IMAGE_FUSIONS = ("single_encoder_canvas", "shared_encoder_pool")
+
+
+def is_one_encoder_image_fusion(image_fusion: str) -> bool:
+    return image_fusion in ONE_ENCODER_IMAGE_FUSIONS
+
 
 class ProjectionHead(nn.Module):
     def __init__(self, in_dim: int, out_dim: int, dropout: float) -> None:
@@ -107,6 +113,7 @@ class DualEffB2MetadataClassifier(nn.Module):
         metadata_fusion: str = "concat",
         image_fusion: str = "concat",
         metadata_gate_hidden_dim: int | None = None,
+        classifier_style: str = "legacy",
         logit_fusion_mode: str = "single",
         fusion_logit_weight: float = 0.6,
         clinical_logit_weight: float = 0.2,
@@ -124,10 +131,15 @@ class DualEffB2MetadataClassifier(nn.Module):
             "adaptive_gate",
             "moe",
             "shared_private",
+            *ONE_ENCODER_IMAGE_FUSIONS,
         ):
             raise ValueError(f"Unsupported image_fusion: {image_fusion}")
         if logit_fusion_mode not in ("single", "fixed"):
             raise ValueError(f"Unsupported logit_fusion_mode: {logit_fusion_mode}")
+        if is_one_encoder_image_fusion(image_fusion) and logit_fusion_mode != "single":
+            raise ValueError(f"{image_fusion} supports only --logit-fusion-mode single.")
+        if classifier_style not in ("legacy", "simple"):
+            raise ValueError(f"Unsupported classifier_style: {classifier_style}")
         self.clinical_backbone_backend = clinical_backbone_backend
         self.dermoscopic_backbone_backend = dermoscopic_backbone_backend
         self.backbone = normalize_backbone_name(backbone)
@@ -135,38 +147,61 @@ class DualEffB2MetadataClassifier(nn.Module):
         self.metadata_dim = metadata_dim
         self.metadata_fusion = metadata_fusion
         self.image_fusion = image_fusion
+        self.classifier_style = classifier_style
         self.logit_fusion_mode = logit_fusion_mode
         self.fusion_logit_weight = fusion_logit_weight
         self.clinical_logit_weight = clinical_logit_weight
         self.dermoscopic_logit_weight = dermoscopic_logit_weight
-        self.clinical_encoder, clinical_feature_dim = build_feature_encoder(
-            backbone,
-            clinical_backbone_backend,
-            imagenet_pretrained,
-        )
-        self.dermoscopic_encoder, dermoscopic_feature_dim = build_feature_encoder(
-            backbone,
-            dermoscopic_backbone_backend,
-            imagenet_pretrained,
-        )
+        self.one_encoder = is_one_encoder_image_fusion(image_fusion)
+        if self.one_encoder:
+            if clinical_backbone_backend != dermoscopic_backbone_backend:
+                raise ValueError(f"{image_fusion} requires one shared backend, got different branch backends.")
+            self.shared_encoder, shared_feature_dim = build_feature_encoder(
+                backbone,
+                clinical_backbone_backend,
+                imagenet_pretrained,
+            )
+            clinical_feature_dim = shared_feature_dim
+            dermoscopic_feature_dim = shared_feature_dim
+        else:
+            self.clinical_encoder, clinical_feature_dim = build_feature_encoder(
+                backbone,
+                clinical_backbone_backend,
+                imagenet_pretrained,
+            )
+            self.dermoscopic_encoder, dermoscopic_feature_dim = build_feature_encoder(
+                backbone,
+                dermoscopic_backbone_backend,
+                imagenet_pretrained,
+            )
 
         self.clinical_head = ProjectionHead(clinical_feature_dim, branch_dim, dropout)
         self.dermoscopic_head = ProjectionHead(dermoscopic_feature_dim, branch_dim, dropout)
+        if self.one_encoder:
+            self.shared_head = ProjectionHead(shared_feature_dim, branch_dim, dropout)
         self.metadata_head = MetadataHead(metadata_input_dim, metadata_dim, dropout)
         if metadata_fusion in ("gated_concat", "gated_only"):
             gate_hidden_dim = metadata_gate_hidden_dim if metadata_gate_hidden_dim is not None else metadata_dim
-            self.clinical_metadata_gate = MetadataChannelGate(
-                metadata_input_dim,
-                clinical_feature_dim,
-                gate_hidden_dim,
-                dropout,
-            )
-            self.dermoscopic_metadata_gate = MetadataChannelGate(
-                metadata_input_dim,
-                dermoscopic_feature_dim,
-                gate_hidden_dim,
-                dropout,
-            )
+            if self.one_encoder:
+                self.shared_metadata_gate = MetadataChannelGate(
+                    metadata_input_dim,
+                    shared_feature_dim,
+                    gate_hidden_dim,
+                    dropout,
+                )
+            else:
+                self.clinical_metadata_gate = MetadataChannelGate(
+                    metadata_input_dim,
+                    clinical_feature_dim,
+                    gate_hidden_dim,
+                    dropout,
+                )
+                self.dermoscopic_metadata_gate = MetadataChannelGate(
+                    metadata_input_dim,
+                    dermoscopic_feature_dim,
+                    gate_hidden_dim,
+                    dropout,
+                )
         metadata_output_dim = 0 if metadata_fusion == "gated_only" else metadata_dim
         fused_dim = self._fusion_dim(branch_dim, metadata_output_dim, image_fusion)
         heads = 4 if branch_dim % 4 == 0 else 1
@@ -212,16 +247,37 @@ class DualEffB2MetadataClassifier(nn.Module):
             if clinical_feature_dim != dermoscopic_feature_dim:
                 raise ValueError("shared_private image fusion requires matching branch feature dimensions.")
             self.shared_head = ProjectionHead(clinical_feature_dim, branch_dim, dropout)
-        self.classifier = None if image_fusion == "moe" else self._classifier(fused_dim, classifier_hidden_dim, num_classes, dropout)
+        self.classifier = (
+            None
+            if image_fusion == "moe"
+            else self._classifier(fused_dim, classifier_hidden_dim, num_classes, dropout, classifier_style)
+        )
         if logit_fusion_mode == "fixed":
             self.clinical_classifier = BranchClassifier(branch_dim, num_classes, dropout)
             self.dermoscopic_classifier = BranchClassifier(branch_dim, num_classes, dropout)
         else:
             self.clinical_classifier = None
             self.dermoscopic_classifier = None
+            
+        # LWS is a post-training stage. Keep scales frozen during normal
+        # representation/classifier training and enable them explicitly later.
+        self.class_scales = nn.Parameter(torch.ones(num_classes), requires_grad=False)
 
     @staticmethod
-    def _classifier(in_dim: int, hidden_dim: int, num_classes: int, dropout: float) -> nn.Sequential:
+    def _classifier(
+        in_dim: int,
+        hidden_dim: int,
+        num_classes: int,
+        dropout: float,
+        classifier_style: str,
+    ) -> nn.Sequential:
+        if classifier_style == "simple":
+            return nn.Sequential(
+                nn.Linear(in_dim, hidden_dim),
+                nn.ReLU(),
+                nn.Dropout(dropout),
+                nn.Linear(hidden_dim, num_classes),
+            )
         return nn.Sequential(
             nn.LayerNorm(in_dim),
             nn.Dropout(dropout),
@@ -235,8 +291,16 @@ class DualEffB2MetadataClassifier(nn.Module):
     def _fusion_dim(branch_dim: int, metadata_dim: int, image_fusion: str) -> int:
         if image_fusion in ("concat", "cross_attention"):
             image_dim = branch_dim * 2
-        elif image_fusion in ("compact_bilinear", "low_rank_bilinear", "adaptive_gate", "shared_private"):
+        elif image_fusion in (
+            "compact_bilinear",
+            "low_rank_bilinear",
+            "adaptive_gate",
+            "shared_private",
+            "shared_encoder_pool",
+        ):
             image_dim = branch_dim * 3
+        elif image_fusion == "single_encoder_canvas":
+            image_dim = branch_dim
         elif image_fusion == "co_attention":
             image_dim = branch_dim * 4
         elif image_fusion == "moe":
@@ -251,6 +315,10 @@ class DualEffB2MetadataClassifier(nn.Module):
         dermoscopic: torch.Tensor,
         metadata: torch.Tensor,
     ) -> torch.Tensor:
+        if self.one_encoder:
+            fusion_logits = self._one_encoder_logits(clinical, dermoscopic, metadata)
+            return fusion_logits * self.class_scales
+
         if self.metadata_fusion in ("gated_concat", "gated_only"):
             clinical_features = self.encode_with_metadata_gate(
                 self.clinical_encoder,
@@ -287,14 +355,64 @@ class DualEffB2MetadataClassifier(nn.Module):
             fused = self._fused_features(clinical_features, dermoscopic_features, clinical_repr, dermoscopic_repr, metadata_repr)
             fusion_logits = self.classifier(fused)
         if self.logit_fusion_mode != "fixed":
-            return fusion_logits
+            return fusion_logits * self.class_scales
         clinical_logits = self.clinical_classifier(clinical_repr)
         dermoscopic_logits = self.dermoscopic_classifier(dermoscopic_repr)
         return (
             self.fusion_logit_weight * fusion_logits
             + self.clinical_logit_weight * clinical_logits
             + self.dermoscopic_logit_weight * dermoscopic_logits
-        )
+        ) * self.class_scales
+
+    def _one_encoder_logits(
+        self,
+        clinical: torch.Tensor,
+        dermoscopic: torch.Tensor,
+        metadata: torch.Tensor,
+    ) -> torch.Tensor:
+        if self.image_fusion == "single_encoder_canvas":
+            combined = torch.cat([clinical, dermoscopic], dim=-1)
+            features = self._encode_shared(combined, metadata)
+            repr_ = self.shared_head(features)
+            fused_image = repr_
+        elif self.image_fusion == "shared_encoder_pool":
+            clinical_features = self._encode_shared(clinical, metadata)
+            dermoscopic_features = self._encode_shared(dermoscopic, metadata)
+            clinical_repr = self.shared_head(clinical_features)
+            dermoscopic_repr = self.shared_head(dermoscopic_features)
+            fused_image = torch.cat(
+                [
+                    0.5 * (clinical_repr + dermoscopic_repr),
+                    torch.abs(clinical_repr - dermoscopic_repr),
+                    clinical_repr * dermoscopic_repr,
+                ],
+                dim=1,
+            )
+        else:
+            raise ValueError(f"Unsupported one-encoder image_fusion: {self.image_fusion}")
+
+        metadata_repr = self._metadata_repr(fused_image, metadata)
+        return self.classifier(self._append_metadata(fused_image, metadata_repr))
+
+    def _encode_shared(self, images: torch.Tensor, metadata: torch.Tensor) -> torch.Tensor:
+        if self.metadata_fusion in ("gated_concat", "gated_only"):
+            features = self.encode_with_metadata_gate(
+                self.shared_encoder,
+                self.clinical_backbone_backend,
+                images,
+                metadata,
+                self.shared_metadata_gate,
+            )
+        else:
+            features = self.shared_encoder(images)
+        return torch.flatten(features, 1)
+
+    def _metadata_repr(self, image_repr: torch.Tensor, metadata: torch.Tensor) -> torch.Tensor | None:
+        if self.metadata_fusion == "gated_only":
+            return None
+        if self.disable_metadata:
+            return image_repr.new_zeros((image_repr.size(0), self.metadata_dim))
+        return self.metadata_head(metadata)
 
     def _append_metadata(self, features: torch.Tensor, metadata_repr: torch.Tensor | None) -> torch.Tensor:
         if metadata_repr is None:
@@ -401,6 +519,8 @@ class DualConvNeXtMetadataClassifier(DualEffB2MetadataClassifier):
 
 def normalize_backbone_name(name: str) -> str:
     name = name.lower().replace(" ", "").replace("_", "").replace("-", "")
+    if name in ("tfefficientnetv2b2", "efficientnetv2b2", "effnetv2b2", "effv2b2"):
+        return "tf_efficientnetv2_b2"
     if name in ("efficientnetb2", "effnetb2", "effb2"):
         return "efficientnet_b2"
     if name in ("efficientnetb1", "effnetb1", "effb1"):
@@ -425,6 +545,8 @@ def default_image_size(backbone: str) -> int:
     backbone = normalize_backbone_name(backbone)
     if backbone == "efficientnet_b2":
         return 260
+    if backbone == "tf_efficientnetv2_b2":
+        return 384
     if backbone == "efficientnet_b1":
         return 240
     if backbone == "convnext_base":
@@ -478,6 +600,8 @@ def build_feature_encoder(backbone: str, backbone_backend: str, imagenet_pretrai
         return model, int(model.num_features)
 
     if backbone_backend == "torchvision":
+        if backbone == "tf_efficientnetv2_b2":
+            raise ValueError("tf_efficientnetv2_b2 is only available with --backbone-backend timm.")
         if backbone == "efficientnet_b2":
             from torchvision.models import efficientnet_b2, EfficientNet_B2_Weights
             weights = EfficientNet_B2_Weights.IMAGENET1K_V1 if imagenet_pretrained else None
@@ -513,6 +637,10 @@ def build_feature_encoder(backbone: str, backbone_backend: str, imagenet_pretrai
 
 
 def set_encoder_trainable(model: DualEffB2MetadataClassifier, trainable: bool) -> None:
+    if getattr(model, "one_encoder", False):
+        for param in model.shared_encoder.parameters():
+            param.requires_grad = trainable
+        return
     for param in model.clinical_encoder.parameters():
         param.requires_grad = trainable
     for param in model.dermoscopic_encoder.parameters():

milk10k_effb2_metadata/milk10k_effb2_metadata/training.py

@@ -7,17 +7,58 @@ import argparse
 from milk10k_effb2_metadata.training_utils import json_safe
 
 
+def validate_balance_args(args: argparse.Namespace) -> None:
+    if args.balance_mode == "hybrid" and args.weighted_sampler:
+        raise ValueError("--balance-mode hybrid cannot be combined with --weighted-sampler.")
+    if args.balance_head_ratio <= 0:
+        raise ValueError("--balance-head-ratio must be greater than 0.")
+    if args.balance_tail_floor < 0:
+        raise ValueError("--balance-tail-floor must be >= 0.")
+    if args.balance_min_source_count < 1:
+        raise ValueError("--balance-min-source-count must be at least 1.")
+    tau = float(getattr(args, "tau", 0.0))
+    class_weight = bool(getattr(args, "class_weight", False))
+    loss = str(getattr(args, "loss", "ce"))
+    lws_epochs = int(getattr(args, "lws_epochs", 0))
+    lws_lr = float(getattr(args, "lws_lr", 1e-2))
+    lws_sampler_power = float(getattr(args, "lws_sampler_power", 0.5))
+    lws_min_scale = float(getattr(args, "lws_min_scale", 0.75))
+    lws_max_scale = float(getattr(args, "lws_max_scale", 1.5))
+    ema_decay = float(getattr(args, "ema_decay", 0.999))
+    if not 0.0 <= tau <= 0.5:
+        raise ValueError("--tau must be between 0.0 and 0.5.")
+    if tau > 0.0 and class_weight:
+        raise ValueError("--tau > 0 cannot be combined with --class-weight.")
+    if tau > 0.0 and loss in {"focal", "ldam"}:
+        raise ValueError("--tau > 0 requires a CE-based loss (ce, ce_dice, or ce_f1).")
+    if lws_epochs < 0:
+        raise ValueError("--lws-epochs must be >= 0.")
+    if lws_lr <= 0.0:
+        raise ValueError("--lws-lr must be > 0.")
+    if not 0.0 <= lws_sampler_power <= 1.0:
+        raise ValueError("--lws-sampler-power must be between 0.0 and 1.0.")
+    if lws_min_scale <= 0.0 or lws_max_scale < lws_min_scale:
+        raise ValueError("LWS scale bounds must satisfy 0 < min <= max.")
+    if not 0.0 < ema_decay < 1.0:
+        raise ValueError("--ema-decay must be between 0 and 1.")
+
+
 def run(args: argparse.Namespace) -> None:
     import torch
 
     from datasets import resolve_data_dir, set_seed
-    from milk10k_effb2_metadata.data import load_paired_dataframe
+    from milk10k_effb2_metadata.data import (
+        audit_dermoscopic_masks,
+        load_paired_dataframe,
+        print_mask_audit_summary,
+    )
     from milk10k_effb2_metadata.model_setup import resolve_training_backbone_backends
-    from milk10k_effb2_metadata.models import normalize_backbone_name, resolve_image_size
+    from milk10k_effb2_metadata.models import is_one_encoder_image_fusion, normalize_backbone_name, resolve_image_size
     from milk10k_effb2_metadata.runner import train_kfold, train_single_run
 
     if args.k_folds < 1:
         raise ValueError("--k-folds must be at least 1.")
+    validate_balance_args(args)
 
     set_seed(args.seed)
     data_dir = resolve_data_dir(args.data_dir)
@@ -26,11 +67,28 @@ def run(args: argparse.Namespace) -> None:
     args.backbone = normalize_backbone_name(args.backbone)
     if args.metadata_gate_hidden_dim is None:
         args.metadata_gate_hidden_dim = args.metadata_dim
+    if is_one_encoder_image_fusion(getattr(args, "image_fusion", "concat")):
+        if args.clinical_checkpoint is not None or args.dermoscopic_checkpoint is not None:
+            raise ValueError(
+                f"--image-fusion {args.image_fusion} uses one ImageNet-initialized encoder; "
+                "do not pass --clinical-checkpoint or --dermoscopic-checkpoint."
+            )
     if args.resume_checkpoint is None and args.clinical_checkpoint is None and args.dermoscopic_checkpoint is None:
         args.imagenet_pretrained = True
     args.image_size = resolve_image_size(args.backbone, args.image_size)
 
     df = load_paired_dataframe(data_dir)
+    if not 0.0 <= args.min_dermoscopic_mask_ratio <= 1.0:
+        raise ValueError("--min-dermoscopic-mask-ratio must be between 0 and 1.")
+    if args.dermoscopic_mask_dir is not None:
+        args.dermoscopic_mask_dir = args.dermoscopic_mask_dir.expanduser().resolve()
+        df, mask_audit = audit_dermoscopic_masks(
+            df,
+            args.dermoscopic_mask_dir,
+            args.min_dermoscopic_mask_ratio,
+        )
+        mask_audit.to_csv(args.output_dir / "dermoscopic_mask_audit.csv", index=False)
+        print_mask_audit_summary(mask_audit, args.min_dermoscopic_mask_ratio)
     class_names = sorted(df["label"].unique())
     label_to_idx = {label: idx for idx, label in enumerate(class_names)}
     device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

milk10k_effb2_metadata/model_setup.py

@@ -12,7 +12,11 @@ from milk10k_effb2_metadata.checkpoints import (
     load_encoder_checkpoint,
     resolve_backbone_backends,
 )
-from milk10k_effb2_metadata.models import DualEffB2MetadataClassifier, model_class_for_backbone
+from milk10k_effb2_metadata.models import (
+    DualEffB2MetadataClassifier,
+    is_one_encoder_image_fusion,
+    model_class_for_backbone,
+)
 
 
 def load_model_state_compat(model: DualEffB2MetadataClassifier, state: dict[str, torch.Tensor]) -> None:
@@ -45,6 +49,21 @@ def infer_branch_backend_from_state(state: dict[str, torch.Tensor], branch_prefi
 
 
 def resolve_training_backbone_backends(args: argparse.Namespace, device: torch.device) -> tuple[str, str]:
+    image_fusion = getattr(args, "image_fusion", "concat")
+    if is_one_encoder_image_fusion(image_fusion):
+        if args.backbone_backend != "auto":
+            return args.backbone_backend, args.backbone_backend
+        if args.resume_checkpoint is not None:
+            checkpoint = torch.load(args.resume_checkpoint.expanduser().resolve(), map_location=device, weights_only=False)
+            state = checkpoint["model_state"]
+            backend = infer_branch_backend_from_state(state, "shared_encoder.")
+            checkpoint_args = checkpoint.get("args", {})
+            if checkpoint_args.get("backbone") and args.backbone == "efficientnet_b2":
+                args.backbone = checkpoint_args["backbone"]
+            print(f"Auto-detected resume shared backend: shared={backend}")
+            return backend, backend
+        print("One-encoder image fusion: using timm backbone initialized from ImageNet weights.")
+        return "timm", "timm"
     if args.backbone_backend != "auto":
         return args.backbone_backend, args.backbone_backend
     if args.clinical_checkpoint is not None and args.dermoscopic_checkpoint is not None:
@@ -88,9 +107,16 @@ def build_optimizer(
     for name, param in model.named_parameters():
         if not param.requires_grad:
             continue
-        if name.startswith(("clinical_encoder.", "dermoscopic_encoder.")):
+        if name.startswith(("clinical_encoder.", "dermoscopic_encoder.", "shared_encoder.")):
             encoder_params.append(param)
-        elif name.startswith(("metadata_head.", "clinical_metadata_gate.", "dermoscopic_metadata_gate.")):
+        elif name.startswith(
+            (
+                "metadata_head.",
+                "clinical_metadata_gate.",
+                "dermoscopic_metadata_gate.",
+                "shared_metadata_gate.",
+            )
+        ):
             metadata_params.append(param)
         else:
             head_params.append(param)
@@ -106,7 +132,7 @@ def build_optimizer(
 def set_metadata_head_trainable(model: DualEffB2MetadataClassifier, trainable: bool) -> None:
     for param in model.metadata_head.parameters():
         param.requires_grad = trainable
-    for module_name in ("clinical_metadata_gate", "dermoscopic_metadata_gate"):
+    for module_name in ("clinical_metadata_gate", "dermoscopic_metadata_gate", "shared_metadata_gate"):
         module = getattr(model, module_name, None)
         if module is not None:
             for param in module.parameters():
@@ -175,7 +201,7 @@ def build_model(
         clinical_logit_weight=args.clinical_logit_weight,
         dermoscopic_logit_weight=args.dermoscopic_logit_weight,
     ).to(device)
-    if args.resume_checkpoint is None:
+    if args.resume_checkpoint is None and not is_one_encoder_image_fusion(getattr(args, "image_fusion", "concat")):
         if args.clinical_checkpoint is not None:
             load_encoder_checkpoint(args.clinical_checkpoint, model.clinical_encoder, "clinical", device)
         if args.dermoscopic_checkpoint is not None:

milk10k_effb2_metadata/models.py

@@ -7,6 +7,12 @@ import torch
 import torch.nn.functional as F
 from torch import nn
 
+ONE_ENCODER_IMAGE_FUSIONS = ("single_encoder_canvas", "shared_encoder_pool")
+
+
+def is_one_encoder_image_fusion(image_fusion: str) -> bool:
+    return image_fusion in ONE_ENCODER_IMAGE_FUSIONS
+
 
 class ProjectionHead(nn.Module):
     def __init__(self, in_dim: int, out_dim: int, dropout: float) -> None:
@@ -125,10 +131,13 @@ class DualEffB2MetadataClassifier(nn.Module):
             "adaptive_gate",
             "moe",
             "shared_private",
+            *ONE_ENCODER_IMAGE_FUSIONS,
         ):
             raise ValueError(f"Unsupported image_fusion: {image_fusion}")
         if logit_fusion_mode not in ("single", "fixed"):
             raise ValueError(f"Unsupported logit_fusion_mode: {logit_fusion_mode}")
+        if is_one_encoder_image_fusion(image_fusion) and logit_fusion_mode != "single":
+            raise ValueError(f"{image_fusion} supports only --logit-fusion-mode single.")
         if classifier_style not in ("legacy", "simple"):
             raise ValueError(f"Unsupported classifier_style: {classifier_style}")
         self.clinical_backbone_backend = clinical_backbone_backend
@@ -143,34 +152,56 @@ class DualEffB2MetadataClassifier(nn.Module):
         self.fusion_logit_weight = fusion_logit_weight
         self.clinical_logit_weight = clinical_logit_weight
         self.dermoscopic_logit_weight = dermoscopic_logit_weight
-        self.clinical_encoder, clinical_feature_dim = build_feature_encoder(
-            backbone,
-            clinical_backbone_backend,
-            imagenet_pretrained,
-        )
-        self.dermoscopic_encoder, dermoscopic_feature_dim = build_feature_encoder(
-            backbone,
-            dermoscopic_backbone_backend,
-            imagenet_pretrained,
-        )
+        self.one_encoder = is_one_encoder_image_fusion(image_fusion)
+        if self.one_encoder:
+            if clinical_backbone_backend != dermoscopic_backbone_backend:
+                raise ValueError(f"{image_fusion} requires one shared backend, got different branch backends.")
+            self.shared_encoder, shared_feature_dim = build_feature_encoder(
+                backbone,
+                clinical_backbone_backend,
+                imagenet_pretrained,
+            )
+            clinical_feature_dim = shared_feature_dim
+            dermoscopic_feature_dim = shared_feature_dim
+        else:
+            self.clinical_encoder, clinical_feature_dim = build_feature_encoder(
+                backbone,
+                clinical_backbone_backend,
+                imagenet_pretrained,
+            )
+            self.dermoscopic_encoder, dermoscopic_feature_dim = build_feature_encoder(
+                backbone,
+                dermoscopic_backbone_backend,
+                imagenet_pretrained,
+            )
 
         self.clinical_head = ProjectionHead(clinical_feature_dim, branch_dim, dropout)
         self.dermoscopic_head = ProjectionHead(dermoscopic_feature_dim, branch_dim, dropout)
+        if self.one_encoder:
+            self.shared_head = ProjectionHead(shared_feature_dim, branch_dim, dropout)
         self.metadata_head = MetadataHead(metadata_input_dim, metadata_dim, dropout)
         if metadata_fusion in ("gated_concat", "gated_only"):
             gate_hidden_dim = metadata_gate_hidden_dim if metadata_gate_hidden_dim is not None else metadata_dim
-            self.clinical_metadata_gate = MetadataChannelGate(
-                metadata_input_dim,
-                clinical_feature_dim,
-                gate_hidden_dim,
-                dropout,
-            )
-            self.dermoscopic_metadata_gate = MetadataChannelGate(
-                metadata_input_dim,
-                dermoscopic_feature_dim,
-                gate_hidden_dim,
-                dropout,
-            )
+            if self.one_encoder:
+                self.shared_metadata_gate = MetadataChannelGate(
+                    metadata_input_dim,
+                    shared_feature_dim,
+                    gate_hidden_dim,
+                    dropout,
+                )
+            else:
+                self.clinical_metadata_gate = MetadataChannelGate(
+                    metadata_input_dim,
+                    clinical_feature_dim,
+                    gate_hidden_dim,
+                    dropout,
+                )
+                self.dermoscopic_metadata_gate = MetadataChannelGate(
+                    metadata_input_dim,
+                    dermoscopic_feature_dim,
+                    gate_hidden_dim,
+                    dropout,
+                )
         metadata_output_dim = 0 if metadata_fusion == "gated_only" else metadata_dim
         fused_dim = self._fusion_dim(branch_dim, metadata_output_dim, image_fusion)
         heads = 4 if branch_dim % 4 == 0 else 1
@@ -260,8 +291,16 @@ class DualEffB2MetadataClassifier(nn.Module):
     def _fusion_dim(branch_dim: int, metadata_dim: int, image_fusion: str) -> int:
         if image_fusion in ("concat", "cross_attention"):
             image_dim = branch_dim * 2
-        elif image_fusion in ("compact_bilinear", "low_rank_bilinear", "adaptive_gate", "shared_private"):
+        elif image_fusion in (
+            "compact_bilinear",
+            "low_rank_bilinear",
+            "adaptive_gate",
+            "shared_private",
+            "shared_encoder_pool",
+        ):
             image_dim = branch_dim * 3
+        elif image_fusion == "single_encoder_canvas":
+            image_dim = branch_dim
         elif image_fusion == "co_attention":
             image_dim = branch_dim * 4
         elif image_fusion == "moe":
@@ -276,6 +315,10 @@ class DualEffB2MetadataClassifier(nn.Module):
         dermoscopic: torch.Tensor,
         metadata: torch.Tensor,
     ) -> torch.Tensor:
+        if self.one_encoder:
+            fusion_logits = self._one_encoder_logits(clinical, dermoscopic, metadata)
+            return fusion_logits * self.class_scales
+
         if self.metadata_fusion in ("gated_concat", "gated_only"):
             clinical_features = self.encode_with_metadata_gate(
                 self.clinical_encoder,
@@ -321,6 +364,56 @@ class DualEffB2MetadataClassifier(nn.Module):
             + self.dermoscopic_logit_weight * dermoscopic_logits
         ) * self.class_scales
 
+    def _one_encoder_logits(
+        self,
+        clinical: torch.Tensor,
+        dermoscopic: torch.Tensor,
+        metadata: torch.Tensor,
+    ) -> torch.Tensor:
+        if self.image_fusion == "single_encoder_canvas":
+            combined = torch.cat([clinical, dermoscopic], dim=-1)
+            features = self._encode_shared(combined, metadata)
+            repr_ = self.shared_head(features)
+            fused_image = repr_
+        elif self.image_fusion == "shared_encoder_pool":
+            clinical_features = self._encode_shared(clinical, metadata)
+            dermoscopic_features = self._encode_shared(dermoscopic, metadata)
+            clinical_repr = self.shared_head(clinical_features)
+            dermoscopic_repr = self.shared_head(dermoscopic_features)
+            fused_image = torch.cat(
+                [
+                    0.5 * (clinical_repr + dermoscopic_repr),
+                    torch.abs(clinical_repr - dermoscopic_repr),
+                    clinical_repr * dermoscopic_repr,
+                ],
+                dim=1,
+            )
+        else:
+            raise ValueError(f"Unsupported one-encoder image_fusion: {self.image_fusion}")
+
+        metadata_repr = self._metadata_repr(fused_image, metadata)
+        return self.classifier(self._append_metadata(fused_image, metadata_repr))
+
+    def _encode_shared(self, images: torch.Tensor, metadata: torch.Tensor) -> torch.Tensor:
+        if self.metadata_fusion in ("gated_concat", "gated_only"):
+            features = self.encode_with_metadata_gate(
+                self.shared_encoder,
+                self.clinical_backbone_backend,
+                images,
+                metadata,
+                self.shared_metadata_gate,
+            )
+        else:
+            features = self.shared_encoder(images)
+        return torch.flatten(features, 1)
+
+    def _metadata_repr(self, image_repr: torch.Tensor, metadata: torch.Tensor) -> torch.Tensor | None:
+        if self.metadata_fusion == "gated_only":
+            return None
+        if self.disable_metadata:
+            return image_repr.new_zeros((image_repr.size(0), self.metadata_dim))
+        return self.metadata_head(metadata)
+
     def _append_metadata(self, features: torch.Tensor, metadata_repr: torch.Tensor | None) -> torch.Tensor:
         if metadata_repr is None:
             return features
@@ -544,6 +637,10 @@ def build_feature_encoder(backbone: str, backbone_backend: str, imagenet_pretrai
 
 
 def set_encoder_trainable(model: DualEffB2MetadataClassifier, trainable: bool) -> None:
+    if getattr(model, "one_encoder", False):
+        for param in model.shared_encoder.parameters():
+            param.requires_grad = trainable
+        return
     for param in model.clinical_encoder.parameters():
         param.requires_grad = trainable
     for param in model.dermoscopic_encoder.parameters():

milk10k_effb2_metadata/tests/test_fusion_and_f1_loss.py

@@ -180,6 +180,8 @@ if MISSING_DEPENDENCY is None:
                 "adaptive_gate": 30,
                 "shared_private": 30,
                 "moe": 22,
+                "single_encoder_canvas": 14,
+                "shared_encoder_pool": 30,
             }
             for mode, expected_dim in expected.items():
                 with self.subTest(mode=mode):
@@ -187,6 +189,73 @@ if MISSING_DEPENDENCY is None:
                     gated_only_dim = expected_dim - metadata_dim
                     self.assertEqual(DualEffB2MetadataClassifier._fusion_dim(branch_dim, 0, mode), gated_only_dim)
 
+        def test_one_encoder_fusions_forward_with_and_without_metadata(self) -> None:
+            with patch("milk10k_effb2_metadata.models.build_feature_encoder", side_effect=fake_build_feature_encoder):
+                for mode in ("single_encoder_canvas", "shared_encoder_pool"):
+                    for disable_metadata in (False, True):
+                        with self.subTest(mode=mode, disable_metadata=disable_metadata):
+                            model = DualEffB2MetadataClassifier(
+                                num_classes=4,
+                                metadata_input_dim=5,
+                                branch_dim=8,
+                                metadata_dim=6,
+                                classifier_hidden_dim=12,
+                                dropout=0.0,
+                                imagenet_pretrained=False,
+                                clinical_backbone_backend="torchvision",
+                                dermoscopic_backbone_backend="torchvision",
+                                backbone="efficientnet_b2",
+                                disable_metadata=disable_metadata,
+                                image_fusion=mode,
+                            )
+                            self.assertTrue(hasattr(model, "shared_encoder"))
+                            self.assertFalse(hasattr(model, "clinical_encoder"))
+                            self.assertFalse(hasattr(model, "dermoscopic_encoder"))
+                            logits = model(
+                                torch.randn(2, 3, 8, 8),
+                                torch.randn(2, 3, 8, 8),
+                                torch.randn(2, 5),
+                            )
+                            self.assertEqual(tuple(logits.shape), (2, 4))
+
+        def test_checkpoint_reconstructs_one_encoder_model(self) -> None:
+            checkpoint_args = {
+                "branch_dim": 8,
+                "metadata_dim": 6,
+                "classifier_hidden_dim": 12,
+                "dropout": 0.0,
+                "metadata_fusion": "concat",
+                "image_fusion": "single_encoder_canvas",
+                "logit_fusion_mode": "single",
+                "backbone": "efficientnet_b2",
+            }
+            with patch("milk10k_effb2_metadata.models.build_feature_encoder", side_effect=fake_build_feature_encoder):
+                model = DualEffB2MetadataClassifier(
+                    num_classes=4,
+                    metadata_input_dim=5,
+                    branch_dim=8,
+                    metadata_dim=6,
+                    classifier_hidden_dim=12,
+                    dropout=0.0,
+                    imagenet_pretrained=False,
+                    clinical_backbone_backend="timm",
+                    dermoscopic_backbone_backend="timm",
+                    backbone="efficientnet_b2",
+                    image_fusion="single_encoder_canvas",
+                )
+                with patch("milk10k_effb2_metadata.inference.infer_backend_from_model_state", return_value="timm"):
+                    loaded = build_model_from_checkpoint(
+                        {
+                            "model_state": model.state_dict(),
+                            "class_names": ["A", "B", "C", "D"],
+                            "args": checkpoint_args,
+                        },
+                        metadata_dim=5,
+                        device=torch.device("cpu"),
+                    )
+            self.assertTrue(hasattr(loaded, "shared_encoder"))
+            self.assertFalse(hasattr(loaded, "clinical_encoder"))
+
 
     class MetadataAugmentationTest(unittest.TestCase):
         def test_image_transform_does_not_change_metadata(self) -> None:

milk10k_effb2_metadata/training.py

@@ -53,7 +53,7 @@ def run(args: argparse.Namespace) -> None:
         print_mask_audit_summary,
     )
     from milk10k_effb2_metadata.model_setup import resolve_training_backbone_backends
-    from milk10k_effb2_metadata.models import normalize_backbone_name, resolve_image_size
+    from milk10k_effb2_metadata.models import is_one_encoder_image_fusion, normalize_backbone_name, resolve_image_size
     from milk10k_effb2_metadata.runner import train_kfold, train_single_run
 
     if args.k_folds < 1:
@@ -67,6 +67,12 @@ def run(args: argparse.Namespace) -> None:
     args.backbone = normalize_backbone_name(args.backbone)
     if args.metadata_gate_hidden_dim is None:
         args.metadata_gate_hidden_dim = args.metadata_dim
+    if is_one_encoder_image_fusion(getattr(args, "image_fusion", "concat")):
+        if args.clinical_checkpoint is not None or args.dermoscopic_checkpoint is not None:
+            raise ValueError(
+                f"--image-fusion {args.image_fusion} uses one ImageNet-initialized encoder; "
+                "do not pass --clinical-checkpoint or --dermoscopic-checkpoint."
+            )
     if args.resume_checkpoint is None and args.clinical_checkpoint is None and args.dermoscopic_checkpoint is None:
         args.imagenet_pretrained = True
     args.image_size = resolve_image_size(args.backbone, args.image_size)