BGPANet: The Bi-Granular Attention Breakthrough That Finally Taught AI to Diagnose Skin Cancer Like a Dermatologist

Complete End-to-End PyTorch Implementation

The following is a complete, self-contained PyTorch implementation of BGPANet, including the BGPA block (all three branches: CPA, SAR, CDCA), the Dual-Tailed Loss with dynamic weight scheduling, and the full model with Swin-B backbone integration. This code is structured for readability and direct training use.

# ═══════════════════════════════════════════════════════════════════════════
# BGPANet: Bi-Granular Progressive Attention for Imbalanced Skin Lesion
# Diagnosis
# Liu, Guo, Yu, et al. · Expert Systems With Applications 321 (2026) 132169
# Complete PyTorch Implementation
# ═══════════════════════════════════════════════════════════════════════════

import torch
import torch.nn as nn
import torch.nn.functional as F
import torchvision.transforms as transforms
from torchvision.models import swin_b, Swin_B_Weights
from torch.utils.data import DataLoader, Dataset
import math
from typing import Optional, List, Tuple


# ─── Section 1: Channel Prior Attention (CPA Branch) ──────────────────────

class ChannelPriorAttention(nn.Module):
    """
    Branch (a) of the BGPA block.
    Computes coarse-grained channel weights via global average pooling
    followed by a bottleneck fully-connected module (Eq. 2 in paper).

    Args:
        channels (int): Number of input feature channels C.
        reduction (int): Bottleneck reduction ratio r (default 16).
    """
    def __init__(self, channels: int, reduction: int = 16):
        super().__init__()
        mid = max(channels // reduction, 8)
        # Two-layer bottleneck: C → C//r → C
        self.fc1 = nn.Linear(channels, mid, bias=True)
        self.fc2 = nn.Linear(mid, channels, bias=True)
        self.sigmoid = nn.Sigmoid()

    def forward(self, x: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
        """
        Args:
            x: Feature map of shape (B, C, H, W).
        Returns:
            g:   Channel attention vector (B, C, 1, 1) — the 'prior' g.
            x_c: Channel-reweighted features (B, C, H, W).
        """
        B, C, H, W = x.shape

        # Global average pooling: (B, C, H, W) → (B, C)
        z = x.mean(dim=[-2, -1])

        # Bottleneck with Swish activation (Eq. 4 in paper)
        h = F.silu(self.fc1(z))          # Swish ≡ SiLU in PyTorch
        g = self.sigmoid(self.fc2(h))   # (B, C)  — channel weights

        # Reshape for broadcasting: (B, C) → (B, C, 1, 1)
        g = g.view(B, C, 1, 1)

        # Reweight: X_c(i,j,c) = X(i,j,c) · g_c   (Eq. 5)
        x_c = x * g
        return g, x_c


# ─── Section 2: Spatial Attention Refinement (SAR Branch) ─────────────────

class SpatialAttentionRefinement(nn.Module):
    """
    Branch (b) of the BGPA block.
    Constructs a spatial attention map guided by the channel prior g,
    computing channel-weighted average and max statistics per location
    before a 7×7 convolution (Eq. 6–9 in paper).

    Args:
        kernel_size (int): Convolution kernel size for spatial map (default 7).
    """
    def __init__(self, kernel_size: int = 7):
        super().__init__()
        padding = kernel_size // 2
        # Takes concatenated [avg_stat, max_stat] → spatial attention map
        self.conv = nn.Conv2d(2, 1, kernel_size=kernel_size, padding=padding, bias=False)
        self.sigmoid = nn.Sigmoid()

    def forward(self, x_c: torch.Tensor, g: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
        """
        Args:
            x_c: Channel-reweighted features (B, C, H, W).
            g:   Channel attention weights (B, C, 1, 1).
        Returns:
            M_s: Spatial attention map (B, 1, H, W).
            x_s: Spatially refined features (B, C, H, W).
        """
        # Channel-weighted statistics at each spatial location (Eq. 6, 7)
        # x_c already contains g_c * X_c(i,j,c)
        f_avg = x_c.mean(dim=1, keepdim=True)        # (B, 1, H, W)
        f_max = x_c.max(dim=1, keepdim=True).values  # (B, 1, H, W)

        # Concatenate and apply 7×7 conv → sigmoid (Eq. 8)
        combined = torch.cat([f_avg, f_max], dim=1)   # (B, 2, H, W)
        M_s = self.sigmoid(self.conv(combined))        # (B, 1, H, W)

        # Fine-grained spatial features: X_s = X_c · M_s  (Eq. 9)
        x_s = x_c * M_s
        return M_s, x_s


# ─── Section 3: Cross-Dimensional Collaborative Attention (CDCA Branch) ──

class CrossDimensionalCollaborativeAttention(nn.Module):
    """
    Branch (c) of the BGPA block.
    Performs conditional local self-attention within non-overlapping windows,
    conditioned on the channel prior g (Eq. 10–12 in paper).

    Args:
        channels (int):    Number of feature channels C.
        window_size (int): Local attention window size M (default 4).
    """
    def __init__(self, channels: int, window_size: int = 4):
        super().__init__()
        self.window_size = window_size
        # 1×1 conv for embedding before similarity computation (Eq. 10)
        self.embed = nn.Conv2d(channels, channels, kernel_size=1, bias=False)

    def _window_partition(self, x: torch.Tensor) -> Tuple[torch.Tensor, int, int]:
        """Partition (B, C, H, W) into non-overlapping windows of size M×M."""
        B, C, H, W = x.shape
        M = self.window_size
        # Pad if necessary
        H_pad = (M - H % M) % M
        W_pad = (M - W % M) % M
        if H_pad > 0 or W_pad > 0:
            x = F.pad(x, (0, W_pad, 0, H_pad))
        H_p, W_p = H + H_pad, W + W_pad
        # Reshape to (B * num_windows, C, M, M)
        x = x.view(B, C, H_p // M, M, W_p // M, M)
        x = x.permute(0, 2, 4, 1, 3, 5).contiguous()
        x = x.view(-1, C, M, M)
        return x, H_p, W_p

    def _window_reverse(self, windows: torch.Tensor, B: int, H_p: int, W_p: int) -> torch.Tensor:
        """Reverse window partitioning back to (B, C, H_p, W_p)."""
        M = self.window_size
        C = windows.shape[1]
        windows = windows.view(B, H_p // M, W_p // M, C, M, M)
        windows = windows.permute(0, 3, 1, 4, 2, 5).contiguous()
        return windows.view(B, C, H_p, W_p)

    def forward(self, x_s: torch.Tensor, g: torch.Tensor) -> torch.Tensor:
        """
        Args:
            x_s: Fine-grained spatial features (B, C, H, W).
            g:   Channel prior weights (B, C, 1, 1).
        Returns:
            X_ctx: Cross-dimensional contextual features (B, C, H, W).
        """
        B, C, H, W = x_s.shape
        M = self.window_size

        # 1×1 conv embedding E = Conv_1×1(X_s)  (Eq. 10)
        E = self.embed(x_s)  # (B, C, H, W)

        # Partition into windows
        E_win, H_p, W_p = self._window_partition(E)    # (N_win, C, M, M)
        xs_win, _, _    = self._window_partition(x_s)  # (N_win, C, M, M)
        g_exp = g.expand(B, C, H, W)
        g_win, _, _     = self._window_partition(g_exp)  # (N_win, C, M, M)

        N_win = E_win.shape[0]
        # Flatten spatial: (N_win, C, M, M) → (N_win, M*M, C)
        E_flat  = E_win.view(N_win, C, -1).permute(0, 2, 1)   # (N_win, M², C)
        xs_flat = xs_win.view(N_win, C, -1).permute(0, 2, 1)   # (N_win, M², C)
        g_flat  = g_win.view(N_win, C, -1).permute(0, 2, 1)    # (N_win, M², C)

        # Local self-attention: A = softmax(E @ E^T / scale) (Eq. 11)
        scale = math.sqrt(C)
        A = torch.bmm(E_flat, E_flat.transpose(1, 2)) / scale  # (N_win, M², M²)
        A = F.softmax(A, dim=-1)

        # Channel-prior conditioned aggregation  (Eq. 12)
        # g_flat * xs_flat = channel-conditioned values
        cond_vals = g_flat * xs_flat  # (N_win, M², C)
        ctx_delta = torch.bmm(A, cond_vals)  # (N_win, M², C)

        # Residual: X_ctx = X_s + aggregated context
        x_ctx_flat = xs_flat + ctx_delta  # (N_win, M², C)

        # Unflatten and reverse window partition
        x_ctx_win = x_ctx_flat.permute(0, 2, 1).view(N_win, C, M, M)
        x_ctx = self._window_reverse(x_ctx_win, B, H_p, W_p)  # (B, C, H_p, W_p)
        return x_ctx[:, :, :H, :W]  # remove any padding


# ─── Section 4: Full BGPA Block ────────────────────────────────────────────

class BGPABlock(nn.Module):
    """
    Bi-Granular Progressive Attention Block.
    Integrates CPA → SAR → CDCA branches with a learnable convex
    combination (α, β, γ) to fuse multi-granularity representations
    (Eq. 13 in paper).

    Args:
        channels (int):    Feature channel count C.
        reduction (int):   CPA bottleneck reduction ratio (default 16).
        window_size (int): CDCA local attention window M (default 4).
    """
    def __init__(self, channels: int, reduction: int = 16, window_size: int = 4):
        super().__init__()
        self.cpa  = ChannelPriorAttention(channels, reduction)
        self.sar  = SpatialAttentionRefinement()
        self.cdca = CrossDimensionalCollaborativeAttention(channels, window_size)

        # Learnable convex combination weights (α, β, γ) via softmax
        # Initialized equally; updated during training
        self.mix_logits = nn.Parameter(torch.zeros(3))

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        """
        Args:
            x: Input features (B, C, H, W).
        Returns:
            Y: Fused bi-granular features (B, C, H, W).
        """
        # Branch (a): Channel Prior Attention
        g, x_c = self.cpa(x)           # g: (B,C,1,1), x_c: (B,C,H,W)

        # Branch (b): Spatial Attention Refinement
        M_s, x_s = self.sar(x_c, g)   # M_s: (B,1,H,W), x_s: (B,C,H,W)

        # Branch (c): Cross-Dimensional Collaborative Attention
        x_ctx = self.cdca(x_s, g)     # x_ctx: (B,C,H,W)

        # Learnable convex combination: α·X_c + β·X_s + γ·X_ctx  (Eq. 13)
        weights = F.softmax(self.mix_logits, dim=0)  # ensures α+β+γ=1, all >0
        alpha, beta, gamma = weights[0], weights[1], weights[2]

        Y = alpha * x_c + beta * x_s + gamma * x_ctx
        return Y


# ─── Section 5: Dual-Tailed Loss Function ────────────────────────────────

class DualTailedLoss(nn.Module):
    """
    Dynamic weighted combination of Cross-Entropy and Focal Loss.
    α(t) = 1 - t/T  (Cross-Entropy weight, starts high, decays)
    β(t) = t/T       (Focal Loss weight, starts zero, grows)
    (Eq. 18–20 in paper)

    Args:
        num_classes (int): Number of output classes.
        gamma (float):     Focal loss focusing parameter γ (default 2.0).
        total_steps (int): Total training steps T.
    """
    def __init__(self, num_classes: int, gamma: float = 2.0, total_steps: int = 10000):
        super().__init__()
        self.num_classes = num_classes
        self.gamma = gamma
        self.total_steps = total_steps
        self.current_step = 0

    def step(self):
        """Call after each optimizer.step() to advance the schedule."""
        self.current_step = min(self.current_step + 1, self.total_steps)

    def _cross_entropy(self, logits: torch.Tensor, targets: torch.Tensor) -> torch.Tensor:
        """Standard multi-class cross-entropy loss (Eq. 14)."""
        return F.cross_entropy(logits, targets)

    def _focal_loss(self, logits: torch.Tensor, targets: torch.Tensor) -> torch.Tensor:
        """
        Multi-class focal loss (Eq. 15).
        Reduces weight for well-classified samples via (1 - p_hat)^gamma.
        """
        log_probs = F.log_softmax(logits, dim=1)
        probs     = torch.exp(log_probs)

        # Gather the probability and log-probability for the true class
        batch_size = logits.size(0)
        p_hat = probs[torch.arange(batch_size), targets]      # (B,)
        log_p = log_probs[torch.arange(batch_size), targets]  # (B,)

        # Focal weight: (1 - p_hat)^gamma
        focal_weight = (1.0 - p_hat) ** self.gamma

        loss = -(focal_weight * log_p).mean()
        return loss

    def forward(self, logits: torch.Tensor, targets: torch.Tensor) -> torch.Tensor:
        """
        Args:
            logits:  Model output (B, num_classes).
            targets: Ground-truth class indices (B,).
        Returns:
            Scalar loss value.
        """
        t = self.current_step
        T = self.total_steps

        # Dynamic weights: α(t) = 1 - t/T, β(t) = t/T
        alpha_t = 1.0 - (t / T)
        beta_t  = t / T

        L_ce    = self._cross_entropy(logits, targets)
        L_focal = self._focal_loss(logits, targets)

        return alpha_t * L_ce + beta_t * L_focal


# ─── Section 6: BGPANet Model ─────────────────────────────────────────────

class BGPANet(nn.Module):
    """
    Bi-Granular Progressive Attention Network for skin lesion classification.

    Architecture:
      - Swin-B backbone (pretrained on ImageNet)
      - BGPA block inserted after each Swin stage's feature output
      - Dense classification head mapping to num_classes

    The Swin-B stages produce feature maps of channels:
        Stage 0: 128-ch (H/4  × W/4)
        Stage 1: 256-ch (H/8  × W/8)
        Stage 2: 512-ch (H/16 × W/16)
        Stage 3: 1024-ch (H/32 × W/32)

    BGPA blocks are applied at each stage. Final classification uses
    the last (Stage 3) features after global average pooling.

    Args:
        num_classes (int):  Number of skin lesion categories (7 for HAM10000,
                            2 for ISIC2020).
        reduction (int):    CPA bottleneck reduction ratio (default 16).
        window_size (int):  CDCA window size (default 4).
        pretrained (bool):  Use ImageNet pretrained Swin-B weights.
    """
    def __init__(self,
                 num_classes: int = 7,
                 reduction: int = 16,
                 window_size: int = 4,
                 pretrained: bool = True):
        super().__init__()

        # Load Swin-B backbone
        weights = Swin_B_Weights.DEFAULT if pretrained else None
        swin = swin_b(weights=weights)

        # Extract Swin stages. torchvision's swin_b .features contains:
        # [PatchEmbed, stage0, merge0, stage1, merge1, stage2, merge2, stage3, norm]
        self.patch_embed = swin.features[0]  # Patch partition + embedding

        # Stages and patch merging layers
        self.stage0 = swin.features[1]   # 128-ch, ×2 blocks
        self.merge0 = swin.features[2]   # PatchMerging: 128→256
        self.stage1 = swin.features[3]   # 256-ch, ×2 blocks
        self.merge1 = swin.features[4]   # PatchMerging: 256→512
        self.stage2 = swin.features[5]   # 512-ch, ×18 blocks
        self.merge2 = swin.features[6]   # PatchMerging: 512→1024
        self.stage3 = swin.features[7]   # 1024-ch, ×2 blocks
        self.norm   = swin.features[8]   # LayerNorm

        # BGPA blocks for each stage
        self.bgpa0 = BGPABlock(128,  reduction, window_size)
        self.bgpa1 = BGPABlock(256,  reduction, window_size)
        self.bgpa2 = BGPABlock(512,  reduction, window_size)
        self.bgpa3 = BGPABlock(1024, reduction, window_size)

        # Dense classification head
        self.classifier = nn.Linear(1024, num_classes)

    def _seq_to_spatial(self, x: torch.Tensor) -> torch.Tensor:
        """Convert (B, H*W, C) → (B, C, H, W) for BGPA processing."""
        B, L, C = x.shape
        H = W = int(math.isqrt(L))
        x = x.permute(0, 2, 1).view(B, C, H, W)
        return x

    def _spatial_to_seq(self, x: torch.Tensor) -> torch.Tensor:
        """Convert (B, C, H, W) → (B, H*W, C) for Swin merging layers."""
        B, C, H, W = x.shape
        x = x.view(B, C, H * W).permute(0, 2, 1)
        return x

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        """
        Forward pass for BGPANet.

        Args:
            x: Input dermoscopic images (B, 3, 224, 224).
        Returns:
            logits: Class scores (B, num_classes).
        """
        # ── Patch Embedding ──────────────────────────────────────────────
        x = self.patch_embed(x)  # (B, 56*56, 128) — sequence format

        # ── Stage 0 (128-ch) + BGPA ──────────────────────────────────────
        x = self.stage0(x)                  # (B, 56²,  128)
        sp = self._seq_to_spatial(x)        # (B, 128,  56, 56)
        sp = self.bgpa0(sp)                 # BGPA: coarse→fine pass
        x  = self._spatial_to_seq(sp)       # (B, 56²,  128)
        x  = self.merge0(x)                 # (B, 28²,  256)

        # ── Stage 1 (256-ch) + BGPA ──────────────────────────────────────
        x = self.stage1(x)
        sp = self._seq_to_spatial(x)        # (B, 256, 28, 28)
        sp = self.bgpa1(sp)
        x  = self._spatial_to_seq(sp)
        x  = self.merge1(x)                 # (B, 14², 512)

        # ── Stage 2 (512-ch, ×18 blocks) + BGPA ──────────────────────────
        x = self.stage2(x)
        sp = self._seq_to_spatial(x)        # (B, 512, 14, 14)
        sp = self.bgpa2(sp)
        x  = self._spatial_to_seq(sp)
        x  = self.merge2(x)                 # (B, 7², 1024)

        # ── Stage 3 (1024-ch) + BGPA ─────────────────────────────────────
        x = self.stage3(x)
        sp = self._seq_to_spatial(x)        # (B, 1024, 7, 7)
        sp = self.bgpa3(sp)
        x  = self._spatial_to_seq(sp)

        # ── LayerNorm + Global Average Pool ──────────────────────────────
        x = self.norm(x)                    # (B, 49, 1024)
        x = x.mean(dim=1)                  # (B, 1024)

        # ── Dense Classification Head ─────────────────────────────────────
        logits = self.classifier(x)         # (B, num_classes)
        return logits


# ─── Section 7: Training Pipeline ────────────────────────────────────────

def get_transforms(train: bool = True) -> transforms.Compose:
    """
    Data transforms matching Section 4.3 of the paper.
    Training: augmentation (flip, brightness, hue, saturation, contrast) + normalize.
    Validation/Test: resize + normalize only.
    """
    normalize = transforms.Normalize(
        mean=[0.485, 0.456, 0.406],
        std=[0.229, 0.224, 0.225]
    )
    if train:
        return transforms.Compose([
            transforms.Resize((224, 224)),
            transforms.RandomHorizontalFlip(p=0.5),
            transforms.RandomVerticalFlip(p=0.5),
            transforms.ColorJitter(
                brightness=0.2,    # [0.8, 1.2]
                contrast=0.2,      # [0.8, 1.2]
                saturation=0.2,    # [0.8, 1.2]
                hue=0.1            # [-0.1, 0.1]
            ),
            transforms.ToTensor(),
            normalize
        ])
    else:
        return transforms.Compose([
            transforms.Resize((224, 224)),
            transforms.ToTensor(),
            normalize
        ])


def train_bgpanet(
    num_classes: int,
    train_loader: DataLoader,
    val_loader: DataLoader,
    num_epochs: int = 180,
    device: str = "cuda"
) -> BGPANet:
    """
    Full training loop for BGPANet following paper hyperparameters (Table 2):
      - AdamW optimizer, lr=1e-4, weight_decay=0.05
      - Cosine annealing with 5-epoch warm-up
      - Dual-Tailed Loss with linear dynamic weighting
      - Early stopping on validation loss
      - Total epochs: 180

    Args:
        num_classes:   7 (HAM10000) or 2 (ISIC2020).
        train_loader:  Training DataLoader.
        val_loader:    Validation DataLoader.
        num_epochs:    Maximum training epochs (default 180).
        device:        'cuda' or 'cpu'.

    Returns:
        Trained BGPANet model (best checkpoint).
    """
    device = torch.device(device if torch.cuda.is_available() else "cpu")
    print(f"Training on: {device}")

    # Model
    model = BGPANet(num_classes=num_classes, pretrained=True).to(device)

    # Compute total training steps for Dual-Tailed Loss schedule
    total_steps = num_epochs * len(train_loader)

    # Loss and optimizer
    criterion = DualTailedLoss(
        num_classes=num_classes,
        gamma=2.0,
        total_steps=total_steps
    )
    optimizer = torch.optim.AdamW(
        model.parameters(),
        lr=1e-4,
        weight_decay=0.05
    )

    # Cosine annealing LR scheduler
    scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(
        optimizer,
        T_max=num_epochs,
        eta_min=1e-6
    )

    # Warm-up: linearly scale LR for first 5 epochs
    warmup_epochs = 5
    warmup_scheduler = torch.optim.lr_scheduler.LinearLR(
        optimizer, start_factor=0.01, end_factor=1.0, total_iters=warmup_epochs
    )

    best_val_loss = float("inf")
    best_val_acc  = 0.0
    patience      = 20
    no_improve    = 0
    best_state    = None

    for epoch in range(1, num_epochs + 1):
        # ── Training Phase ───────────────────────────────────────────
        model.train()
        total_loss = correct = total = 0

        for images, labels in train_loader:
            images = images.to(device)
            labels = labels.to(device)

            optimizer.zero_grad()
            logits = model(images)
            loss   = criterion(logits, labels)
            loss.backward()
            optimizer.step()
            criterion.step()  # advance Dual-Tailed Loss schedule

            total_loss += loss.item() * images.size(0)
            preds = logits.argmax(dim=1)
            correct += (preds == labels).sum().item()
            total += images.size(0)

        train_acc  = correct / total
        train_loss = total_loss / total

        # ── Validation Phase ─────────────────────────────────────────
        model.eval()
        val_loss = val_correct = val_total = 0

        with torch.no_grad():
            for images, labels in val_loader:
                images = images.to(device)
                labels = labels.to(device)
                logits = model(images)
                loss   = criterion(logits, labels)
                val_loss += loss.item() * images.size(0)
                preds = logits.argmax(dim=1)
                val_correct += (preds == labels).sum().item()
                val_total   += images.size(0)

        val_acc  = val_correct / val_total
        val_loss /= val_total

        # LR scheduling
        if epoch <= warmup_epochs:
            warmup_scheduler.step()
        else:
            scheduler.step()

        print(f"Epoch [{epoch:3d}/{num_epochs}] "
              f"Train Loss: {train_loss:.4f} Acc: {train_acc:.4f} | "
              f"Val Loss: {val_loss:.4f} Acc: {val_acc:.4f}")

        # Early stopping on best validation accuracy
        if val_acc > best_val_acc:
            best_val_acc = val_acc
            best_state   = {k: v.cpu().clone() for k, v in model.state_dict().items()}
            no_improve   = 0
        else:
            no_improve += 1
            if no_improve >= patience:
                print(f"Early stopping triggered at epoch {epoch}.")
                break

    # Restore best checkpoint
    model.load_state_dict(best_state)
    print(f"\nTraining complete. Best Val Accuracy: {best_val_acc:.4f}")
    return model


# ─── Section 8: Quick Sanity Check ────────────────────────────────────────

if __name__ == "__main__":
    print("=" * 65)
    print("BGPANet — Bi-Granular Progressive Attention Network")
    print("Liu et al. · Expert Systems With Applications 321 (2026)")
    print("=" * 65)

    device = "cuda" if torch.cuda.is_available() else "cpu"

    # ── 1. Model instantiation ────────────────────────────────────────
    print("\n[1] Building BGPANet for HAM10000 (7-class)...")
    model = BGPANet(num_classes=7, pretrained=False).to(device)

    total_params = sum(p.numel() for p in model.parameters())
    print(f"    Total parameters: {total_params / 1e6:.1f}M")

    # ── 2. Forward pass ───────────────────────────────────────────────
    print("\n[2] Running forward pass on synthetic batch...")
    dummy_input  = torch.randn(4, 3, 224, 224).to(device)  # batch of 4
    dummy_labels = torch.randint(0, 7, (4,)).to(device)

    with torch.no_grad():
        logits = model(dummy_input)
    print(f"    Input shape:  {dummy_input.shape}")
    print(f"    Output shape: {logits.shape}")
    print(f"    ✓ Forward pass successful")

    # ── 3. Dual-Tailed Loss ────────────────────────────────────────────
    print("\n[3] Testing Dual-Tailed Loss schedule...")
    criterion = DualTailedLoss(num_classes=7, gamma=2.0, total_steps=100)

    losses_at_steps = []
    for step in [0, 25, 50, 75, 100]:
        criterion.current_step = step
        alpha_t = 1.0 - step / 100
        beta_t  = step / 100
        losses_at_steps.append((step, alpha_t, beta_t))
        print(f"    Step {step:3d}/100 → α(CE)={alpha_t:.2f}, β(Focal)={beta_t:.2f}")

    # Reset and compute actual loss on dummy batch
    criterion.current_step = 50
    loss_val = criterion(logits, dummy_labels)
    print(f"    ✓ Loss at step 50: {loss_val.item():.4f}")

    # ── 4. BGPA Block ablation check ──────────────────────────────────
    print("\n[4] Individual branch outputs from BGPA block...")
    bgpa = BGPABlock(channels=128, reduction=16, window_size=4).to(device)
    feat = torch.randn(2, 128, 56, 56).to(device)  # Stage-0 feature map
    out  = bgpa(feat)
    print(f"    Input:  {feat.shape}")
    print(f"    Output: {out.shape}")
    alpha, beta, gamma = F.softmax(bgpa.mix_logits, dim=0).detach()
    print(f"    Fusion weights — α:{alpha:.3f}  β:{beta:.3f}  γ:{gamma:.3f}")
    print(f"    ✓ BGPA block verified")

    print("\n" + "=" * 65)
    print("All components verified. Ready for training on HAM10000/ISIC2020.")
    print("=" * 65)