deploy: backend bundle from 9c864b98f64c05462a27b71841ae97fb4451e449

Code/Model/data/models/version_registry.json

@@ -27,7 +27,7 @@
         "model_type": "dl_multihead",
         "model_class": "CardAuthModel",
         "backbone": "resnet50+efficientnet_b7",
-        "status": "production",
+        "status": "retired",
         "accuracy": 0.7741935483870968,
         "f1_score": 0.631578947368421,
         "roc_auc": 0.6333333333333333,
@@ -59,9 +59,29 @@
         "svdd_threshold": 0.7524242424242424,
         "back_threshold": 0.6534343434343434,
         "trained_at": "2026-02-15T07:30:42.692244"
+      },
+      {
+        "version": "20260216_091800",
+        "filename": "cardauth_multihead_20260216_091800_best.pth",
+        "model_type": "multi_head",
+        "backbone": "resnet50+efficientnet_b7",
+        "status": "production",
+        "accuracy": 1.0,
+        "f1_score": 1.0,
+        "roc_auc": 1.0,
+        "n_features": "end-to-end",
+        "dataset_size": 19113,
+        "total_params": 95402258,
+        "trainable_params": 81637498,
+        "best_epoch": 26,
+        "svdd_threshold": 0.08919191919191918,
+        "back_threshold": 0.0198989898989899,
+        "pipeline_type": "dl",
+        "trained_at": "2026-02-17T15:15:06.491447",
+        "promoted_at": "2026-02-18T00:00:00.000000"
       }
     ]
   },
-  "production_model": "20260211_155409",
+  "production_model": "20260216_091800",
   "staging_model": "20260210_182731"
 }

Code/Model/src/dl/backbone.py

@@ -80,6 +80,19 @@ class ResNet50Backbone(nn.Module):
 
         return x
 
+    def get_layer_groups(self):
+        """
+        Get parameter groups split by layer depth for discriminative fine-tuning.
+
+        Returns:
+            List of 2 param lists: [layer3_params, layer4_params]
+            (Earlier layers are frozen and excluded.)
+        """
+        return [
+            [p for p in self.layer3.parameters() if p.requires_grad],
+            [p for p in self.layer4.parameters() if p.requires_grad],
+        ]
+
     def get_trainable_params(self):
         """Get count of trainable vs frozen parameters."""
         trainable = sum(p.numel() for p in self.parameters() if p.requires_grad)

Code/Model/src/dl/efficientnet.py

@@ -69,6 +69,22 @@ class EfficientNetB7Backbone(nn.Module):
         x = torch.flatten(x, 1)
         return x
 
+    def get_layer_groups(self):
+        """
+        Get parameter groups split by block depth for discriminative fine-tuning.
+
+        Returns:
+            List of 2 param lists: [block6_params, block7_params]
+            (Earlier blocks 0-5 are frozen and excluded.)
+        """
+        groups = [[], []]
+        for i, block in enumerate(self.features):
+            if i == 6:
+                groups[0].extend([p for p in block.parameters() if p.requires_grad])
+            elif i >= 7:
+                groups[1].extend([p for p in block.parameters() if p.requires_grad])
+        return groups
+
     def get_trainable_params(self):
         """Get count of trainable vs frozen parameters."""
         trainable = sum(p.numel() for p in self.parameters() if p.requires_grad)

Code/Model/src/dl/model.py

@@ -250,26 +250,40 @@ class CardAuthModel(nn.Module):
 
     def get_param_groups(self, backbone_lr: float = 1e-4, head_lr: float = 1e-3):
         """
-        Get parameter groups with differential learning rates.
+        Get parameter groups with discriminative (layer-wise) learning rates.
+
+        3 groups:
+        - Early trainable backbone layers (layer3/block6): backbone_lr * 0.1
+        - Late trainable backbone layers (layer4/block7+): backbone_lr
+        - Head parameters: head_lr
 
         Args:
-            backbone_lr: Learning rate for backbone parameters
+            backbone_lr: Learning rate for late backbone layers
             head_lr: Learning rate for head parameters
 
         Returns:
             List of parameter group dicts for optimizer
         """
-        backbone_params = list(self.resnet.parameters()) + list(self.efficientnet.parameters())
+        resnet_groups = self.resnet.get_layer_groups()   # [layer3, layer4]
+        efn_groups = self.efficientnet.get_layer_groups() # [block6, block7+]
+
+        early_backbone_params = resnet_groups[0] + efn_groups[0]
+        late_backbone_params = resnet_groups[1] + efn_groups[1]
+
         head_params = (
             list(self.pokemon_head.parameters())
             + list(self.back_auth_head.parameters())
             + list(self.svdd_heads.parameters())
         )
 
-        return [
-            {"params": [p for p in backbone_params if p.requires_grad], "lr": backbone_lr},
-            {"params": head_params, "lr": head_lr},
-        ]
+        groups = []
+        if early_backbone_params:
+            groups.append({"params": early_backbone_params, "lr": backbone_lr * 0.1})
+        if late_backbone_params:
+            groups.append({"params": late_backbone_params, "lr": backbone_lr})
+        groups.append({"params": head_params, "lr": head_lr})
+
+        return groups
 
 
 # Backward-compatible alias

Code/Model/src/dl/transforms.py

@@ -67,6 +67,30 @@ def get_eval_transforms(image_size: int = 224):
     ])
 
 
+def get_minority_augment_transforms():
+    """
+    Get stronger augmentation pipeline for minority class images.
+
+    Applied BEFORE the standard train transforms to create visual diversity
+    for under-represented classes (e.g., fake backs). Includes more aggressive
+    geometric and color perturbations.
+
+    Returns:
+        torchvision.transforms.Compose pipeline (operates on PIL images)
+    """
+    return transforms.Compose([
+        transforms.RandomPerspective(distortion_scale=0.2, p=0.5),
+        transforms.RandomAdjustSharpness(sharpness_factor=2, p=0.3),
+        transforms.ColorJitter(
+            brightness=0.4,
+            contrast=0.4,
+            saturation=0.4,
+            hue=0.15,
+        ),
+        transforms.RandomVerticalFlip(p=0.3),
+    ])
+
+
 def denormalize(tensor, mean=None, std=None):
     """
     Reverse ImageNet normalization for visualization.

Code/Model/src/utils/config.py

@@ -68,6 +68,14 @@ class Config:
         self.DL_HEAD_B_BETA = 0.40   # Back authenticator loss weight
         self.DL_HEAD_C_GAMMA = 0.45  # Front SVDD loss weight (primary mechanism)
 
+        # Training improvements for counterfeit detection
+        self.DL_BACK_COUNTERFEIT_WEIGHT = 2.5    # Class weight for counterfeit backs (ratio real/fake: 300/120)
+        self.DL_MINORITY_AUGMENT_FACTOR = 2      # Duplication factor for minority class (backs_fake)
+        self.DL_CALIBRATION_FBETA = 2.0           # F-beta for threshold calibration (2.0 = recall-weighted)
+        self.DL_USE_FOCAL_LOSS = True             # Enable focal loss for Head A/B
+        self.DL_FOCAL_GAMMA = 2.0                 # Focal loss gamma (focus on hard examples)
+        self.DL_SVDD_CONTRASTIVE_ETA = 1.0        # Weight for contrastive SVDD term (Deep SAD)
+
         # Ensure DL directories exist
         self.DL_MODELS_DIR.mkdir(parents=True, exist_ok=True)
         self.DL_EXPANDED_DATA_DIR.mkdir(parents=True, exist_ok=True)