Upload folder using huggingface_hub

README.md

@@ -0,0 +1,85 @@
+---
+license: other
+license_name: polyform-small-business-1.0.0
+license_link: https://polyformproject.org/licenses/small-business/1.0.0/
+library_name: pytorch
+pipeline_tag: image-classification
+tags:
+  - bio-inspired
+  - neuroscience
+  - lightweight
+  - medical-imaging
+  - edge-ai
+  - retinal-ganglion-cells
+  - fibonacci-strides
+datasets:
+  - kvasir-v2
+  - cifar-10
+  - cifar-100
+  - imagenet-100
+---
+
+# MPKNet V6 - Bio-Inspired Visual Classification
+
+A lightweight neural network inspired by the primate Lateral Geniculate Nucleus (LGN), implementing parallel **Parvocellular (P)**, **Koniocellular (K)**, and **Magnocellular (M)** pathways with Fibonacci-stride spatial sampling.
+
+## Architecture
+
+MPKNet V6 uses three parallel pathways with biologically-motivated stride ratios (2:3:5):
+
+- **P pathway** (stride 2): Fine detail and edges, analogous to Parvocellular neurons (~80% of LGN)
+- **K pathway** (stride 3): Context signals that generate gating modulation, analogous to Koniocellular neurons (~10% of LGN)
+- **M pathway** (stride 5): Global structure and coarse features, analogous to Magnocellular neurons (~10% of LGN)
+
+The **K-gating mechanism** dynamically modulates P and M pathways via learned sigmoid gates, inspired by cross-stream modulation in biological vision.
+
+## Results
+
+| Dataset | Classes | Accuracy | Parameters |
+|---------|---------|----------|------------|
+| Kvasir-v2 (GI endoscopy) | 8 | 89.2% | 0.21M |
+| CIFAR-10 | 10 | 89.4% | 0.54M |
+| CIFAR-100 | 100 | 58.8% | 0.22M |
+| ImageNet-100 | 100 | 60.8% | 0.54M |
+
+No pretraining. No augmentation. 161x fewer parameters than MobileNetV3-Small.
+
+## Usage
+
+```python
+import torch
+from mpknet_v6 import BinocularMPKNetV6
+from mpknet_components import count_params
+
+# Load model
+model = BinocularMPKNetV6(num_classes=8, ch=48, use_stereo=True)
+state_dict = torch.load("v6_kvasir_best.pth", map_location="cpu", weights_only=True)
+model.load_state_dict(state_dict)
+model.eval()
+
+# Inference
+x = torch.randn(1, 3, 224, 224)
+with torch.no_grad():
+    logits = model(x)
+    pred = logits.argmax(dim=1)
+```
+
+## Files
+
+- `v6_kvasir_best.pth` - Trained weights (Kvasir-v2, 8 classes, 2.1MB)
+- `mpknet_v6.py` - Model architecture
+- `mpknet_components.py` - Shared components (RGCLayer, BinocularPreMPK, StereoDisparity, StridedMonocularBlock)
+
+## Citation
+
+```
+D.J. Lougen, "MPKNet: Bio-Inspired Visual Classification with Parallel LGN Pathways", 2025.
+```
+
+## License
+
+PolyForm Small Business License 1.0.0 - Free for organizations with less than $100K revenue, non-profits, and education.
+
+## Links
+
+- [GitHub](https://github.com/DJLougen/MPKnet)

mpknet_components.py

@@ -0,0 +1,397 @@
+"""
+Shared components for all MPKNet model variants.
+
+Contains building blocks used across V1, V2, V3, V4 and detection models:
+- RGCLayer: Biologically accurate retinal ganglion cell preprocessing
+- BinocularPreMPK: Legacy retinal preprocessing (deprecated, use RGCLayer)
+- StereoDisparity: Stereo disparity simulation
+- OcularDominanceConv: Convolution with ocular dominance channels
+- BinocularMPKPathway: Pathway with binocular processing
+- MonocularPathwayBlock: Pathway keeping eyes separate
+- StridedMonocularBlock: Strided pathway for V4
+"""
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from typing import Tuple
+
+
+class RGCLayer(nn.Module):
+    """
+    Biologically accurate Retinal Ganglion Cell layer.
+
+    Based on Kim et al. 2021 "Retinal Ganglion Cells—Diversity of Cell Types
+    and Clinical Relevance" (Front. Neurol. 12:661938).
+
+    Models three main RGC types that feed the P/K/M pathways:
+
+    1. MIDGET RGCs (~70% of RGCs):
+       - Small receptive field (5-10 μm dendritic field)
+       - Center-surround via Difference of Gaussians (DoG)
+       - Red-Green color opponency (L-M or M-L)
+       - Feeds PARVOCELLULAR (P) pathway
+       - High spatial acuity, low temporal resolution
+
+    2. PARASOL RGCs (~10% of RGCs):
+       - Large receptive field (30-300 μm dendritic field)
+       - Center-surround DoG on luminance
+       - Achromatic (no color, L+M pooled)
+       - Feeds MAGNOCELLULAR (M) pathway
+       - Motion detection, high temporal resolution
+
+    3. SMALL BISTRATIFIED RGCs (~5-8% of RGCs):
+       - Medium receptive field
+       - S-cone ON center, (L+M) OFF surround
+       - Blue-Yellow opponency
+       - Feeds KONIOCELLULAR (K) pathway
+       - Color context, particularly blue
+
+    Key biological details implemented:
+    - DoG (Difference of Gaussians) for center-surround RF
+    - RF size ratios: Midget < Bistratified < Parasol
+    - Surround ~3-6x larger than center (we use 3x)
+    - ON-center and OFF-center populations (we use ON-center)
+    """
+
+    def __init__(
+        self,
+        midget_sigma: float = 0.8,    # Small RF for fine detail
+        parasol_sigma: float = 2.5,    # Large RF for motion/gist
+        bistrat_sigma: float = 1.2,    # Medium RF for color context
+        surround_ratio: float = 3.0,   # Surround is 3x center
+    ):
+        super().__init__()
+
+        self.midget_sigma = midget_sigma
+        self.parasol_sigma = parasol_sigma
+        self.bistrat_sigma = bistrat_sigma
+        self.surround_ratio = surround_ratio
+
+        # Create DoG kernels for each cell type
+        self.register_buffer('midget_center', self._make_gaussian(midget_sigma))
+        self.register_buffer('midget_surround', self._make_gaussian(midget_sigma * surround_ratio))
+
+        self.register_buffer('parasol_center', self._make_gaussian(parasol_sigma))
+        self.register_buffer('parasol_surround', self._make_gaussian(parasol_sigma * surround_ratio))
+
+        self.register_buffer('bistrat_center', self._make_gaussian(bistrat_sigma))
+        self.register_buffer('bistrat_surround', self._make_gaussian(bistrat_sigma * surround_ratio))
+
+        # Store kernel sizes for padding calculation
+        self.midget_ks = self.midget_surround.shape[-1]
+        self.parasol_ks = self.parasol_surround.shape[-1]
+        self.bistrat_ks = self.bistrat_surround.shape[-1]
+
+    def _make_gaussian(self, sigma: float) -> torch.Tensor:
+        """Create a normalized 2D Gaussian kernel."""
+        ks = int(6 * sigma + 1) | 1  # Ensure odd, cover 3 sigma each side
+        ax = torch.arange(ks, dtype=torch.float32) - ks // 2
+        xx, yy = torch.meshgrid(ax, ax, indexing='ij')
+        kernel = torch.exp(-(xx**2 + yy**2) / (2 * sigma**2))
+        kernel = kernel / kernel.sum()  # Normalize
+        return kernel.unsqueeze(0).unsqueeze(0)  # (1, 1, H, W)
+
+    def _apply_dog(
+        self,
+        x: torch.Tensor,
+        center_kernel: torch.Tensor,
+        surround_kernel: torch.Tensor,
+        kernel_size: int
+    ) -> torch.Tensor:
+        """Apply Difference of Gaussians (center - surround)."""
+        B, C, H, W = x.shape
+        padding = kernel_size // 2
+
+        # Expand kernels for all channels
+        center_k = center_kernel.expand(C, 1, -1, -1)
+        surround_k = surround_kernel.expand(C, 1, -1, -1)
+
+        # Pad surround kernel to match size if needed
+        c_size = center_k.shape[-1]
+        s_size = surround_k.shape[-1]
+        if c_size < s_size:
+            pad_amt = (s_size - c_size) // 2
+            center_k = F.pad(center_k, (pad_amt, pad_amt, pad_amt, pad_amt))
+
+        # Apply center and surround
+        center_response = F.conv2d(x, center_k, padding=padding, groups=C)
+        surround_response = F.conv2d(x, surround_k, padding=padding, groups=C)
+
+        # DoG: ON-center response (center - surround)
+        return center_response - surround_response
+
+    def forward(
+        self,
+        x_left: torch.Tensor,
+        x_right: torch.Tensor
+    ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor,
+               torch.Tensor, torch.Tensor, torch.Tensor]:
+        """
+        Process left and right eye inputs through RGC populations.
+
+        Returns:
+            P_left, P_right: Midget RGC output (R-G opponency) -> P pathway
+            M_left, M_right: Parasol RGC output (luminance DoG) -> M pathway
+            K_left, K_right: Bistratified RGC output (S vs L+M) -> K pathway
+        """
+        # ========== MIDGET RGCs -> P pathway ==========
+        # Red-Green opponency: L-cone vs M-cone
+        # Approximate: R channel vs G channel
+        # DoG on the opponent signal
+
+        # Extract R and G channels (approximating L and M cones)
+        R_left, G_left = x_left[:, 0:1], x_left[:, 1:2]
+        R_right, G_right = x_right[:, 0:1], x_right[:, 1:2]
+
+        # L-M opponency (R-G) with small receptive field DoG
+        rg_left = R_left - G_left
+        rg_right = R_right - G_right
+
+        P_left = self._apply_dog(rg_left, self.midget_center, self.midget_surround, self.midget_ks)
+        P_right = self._apply_dog(rg_right, self.midget_center, self.midget_surround, self.midget_ks)
+
+        # Expand back to 3 channels for compatibility
+        P_left = P_left.expand(-1, 3, -1, -1)
+        P_right = P_right.expand(-1, 3, -1, -1)
+
+        # ========== PARASOL RGCs -> M pathway ==========
+        # Achromatic: pool L+M (approximate as luminance)
+        # Large RF DoG for motion sensitivity
+
+        lum_left = 0.299 * x_left[:, 0:1] + 0.587 * x_left[:, 1:2] + 0.114 * x_left[:, 2:3]
+        lum_right = 0.299 * x_right[:, 0:1] + 0.587 * x_right[:, 1:2] + 0.114 * x_right[:, 2:3]
+
+        M_left = self._apply_dog(lum_left, self.parasol_center, self.parasol_surround, self.parasol_ks)
+        M_right = self._apply_dog(lum_right, self.parasol_center, self.parasol_surround, self.parasol_ks)
+
+        # Expand to 3 channels
+        M_left = M_left.expand(-1, 3, -1, -1)
+        M_right = M_right.expand(-1, 3, -1, -1)
+
+        # ========== SMALL BISTRATIFIED RGCs -> K pathway ==========
+        # S-cone ON center, (L+M) OFF surround
+        # Blue-Yellow opponency: S vs (L+M)
+
+        # S-cone approximated by B channel
+        # (L+M) approximated by (R+G)/2
+        S_left = x_left[:, 2:3]  # Blue
+        S_right = x_right[:, 2:3]
+        LM_left = (x_left[:, 0:1] + x_left[:, 1:2]) / 2
+        LM_right = (x_right[:, 0:1] + x_right[:, 1:2]) / 2
+
+        # S - (L+M) opponency with medium RF
+        by_left = S_left - LM_left
+        by_right = S_right - LM_right
+
+        K_left = self._apply_dog(by_left, self.bistrat_center, self.bistrat_surround, self.bistrat_ks)
+        K_right = self._apply_dog(by_right, self.bistrat_center, self.bistrat_surround, self.bistrat_ks)
+
+        # Expand to 3 channels
+        K_left = K_left.expand(-1, 3, -1, -1)
+        K_right = K_right.expand(-1, 3, -1, -1)
+
+        return P_left, M_left, K_left, P_right, M_right, K_right
+
+
+class BinocularPreMPK(nn.Module):
+    """
+    Simulates retinal + LGN preprocessing for both eyes.
+    Each eye gets its own center-surround filtering.
+
+    Biological motivation:
+    - Retinal ganglion cells have center-surround receptive fields
+    - M cells respond to luminance changes (motion/gist)
+    - P cells respond to color/detail (high-pass filtered)
+    """
+    def __init__(self, sigma: float = 1.0):
+        super().__init__()
+        self.sigma = sigma
+        ks = int(4 * sigma + 1) | 1  # ensure odd
+        ax = torch.arange(ks, dtype=torch.float32) - ks // 2
+        xx, yy = torch.meshgrid(ax, ax, indexing='ij')
+        kernel = torch.exp(-(xx**2 + yy**2) / (2 * sigma**2))
+        kernel = kernel / kernel.sum()
+        self.register_buffer('gauss', kernel.unsqueeze(0).unsqueeze(0))
+        self.ks = ks
+
+    def _blur(self, x: torch.Tensor) -> torch.Tensor:
+        B, C, H, W = x.shape
+        kernel = self.gauss.expand(C, 1, self.ks, self.ks)
+        return F.conv2d(x, kernel, padding=self.ks // 2, groups=C)
+
+    def forward(self, x_left: torch.Tensor, x_right: torch.Tensor) -> Tuple[torch.Tensor, ...]:
+        """
+        Returns (P_left, M_left, P_right, M_right)
+        P = high-pass (center - surround) for detail
+        M = low-pass luminance for motion/gist
+        """
+        # Left eye
+        blur_L = self._blur(x_left)
+        P_left = x_left - blur_L  # high-pass (Parvo-like)
+        lum_L = x_left.mean(dim=1, keepdim=True)
+        M_left = self._blur(lum_L).expand(-1, 3, -1, -1)  # low-pass luminance (Magno-like)
+
+        # Right eye
+        blur_R = self._blur(x_right)
+        P_right = x_right - blur_R
+        lum_R = x_right.mean(dim=1, keepdim=True)
+        M_right = self._blur(lum_R).expand(-1, 3, -1, -1)
+
+        return P_left, M_left, P_right, M_right
+
+
+class StereoDisparity(nn.Module):
+    """
+    Creates stereo disparity by horizontally shifting left/right views.
+    Simulates the slight positional difference between two eyes.
+
+    disparity_range: maximum pixel shift (positive = crossed disparity)
+    """
+    def __init__(self, disparity_range: int = 2):
+        super().__init__()
+        self.disparity_range = disparity_range
+
+    def forward(self, x: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
+        """
+        Takes single image, returns (left_view, right_view) with disparity.
+        For training, uses random disparity. For inference, uses fixed small disparity.
+        """
+        B, C, H, W = x.shape
+
+        if self.training:
+            d = torch.randint(-self.disparity_range, self.disparity_range + 1, (1,)).item()
+        else:
+            d = 1
+
+        if d == 0:
+            return x, x
+
+        if d > 0:
+            x_left = F.pad(x[:, :, :, d:], (0, d, 0, 0), mode='replicate')
+            x_right = F.pad(x[:, :, :, :-d], (d, 0, 0, 0), mode='replicate')
+        else:
+            d = -d
+            x_left = F.pad(x[:, :, :, :-d], (d, 0, 0, 0), mode='replicate')
+            x_right = F.pad(x[:, :, :, d:], (0, d, 0, 0), mode='replicate')
+
+        return x_left, x_right
+
+
+class OcularDominanceConv(nn.Module):
+    """
+    Convolution with ocular dominance - channels are assigned to left/right eye
+    with graded mixing (some purely monocular, some binocular).
+
+    Inspired by V1 ocular dominance columns but applied at LGN stage
+    for computational efficiency.
+    """
+    def __init__(self, in_ch: int, out_ch: int, kernel_size: int,
+                 monocular_ratio: float = 0.5):
+        super().__init__()
+        self.out_ch = out_ch
+        self.monocular_ratio = monocular_ratio
+
+        n_mono = int(out_ch * monocular_ratio)
+        n_mono_per_eye = n_mono // 2
+        n_bino = out_ch - 2 * n_mono_per_eye
+
+        self.n_left = n_mono_per_eye
+        self.n_right = n_mono_per_eye
+        self.n_bino = n_bino
+
+        self.conv_left = nn.Conv2d(in_ch, n_mono_per_eye, kernel_size, padding=kernel_size//2)
+        self.conv_right = nn.Conv2d(in_ch, n_mono_per_eye, kernel_size, padding=kernel_size//2)
+        self.conv_bino_L = nn.Conv2d(in_ch, n_bino, kernel_size, padding=kernel_size//2)
+        self.conv_bino_R = nn.Conv2d(in_ch, n_bino, kernel_size, padding=kernel_size//2)
+        self.bn = nn.BatchNorm2d(out_ch)
+
+    def forward(self, x_left: torch.Tensor, x_right: torch.Tensor) -> torch.Tensor:
+        left_only = self.conv_left(x_left)
+        right_only = self.conv_right(x_right)
+        bino = self.conv_bino_L(x_left) + self.conv_bino_R(x_right)
+        out = torch.cat([left_only, right_only, bino], dim=1)
+        return F.relu(self.bn(out))
+
+
+class BinocularMPKPathway(nn.Module):
+    """
+    Single pathway (M, P, or K) with binocular processing.
+    Receives left and right eye inputs, produces fused output.
+    """
+    def __init__(self, in_ch: int, out_ch: int, kernel_sizes: list,
+                 monocular_ratio: float = 0.5):
+        super().__init__()
+
+        layers = []
+        ch = in_ch
+        for i, ks in enumerate(kernel_sizes):
+            is_first = (i == 0)
+            if is_first:
+                layers.append(OcularDominanceConv(ch, out_ch, ks, monocular_ratio))
+            else:
+                layers.append(nn.Sequential(
+                    nn.Conv2d(out_ch if i > 0 else ch, out_ch, ks, padding=ks//2),
+                    nn.BatchNorm2d(out_ch),
+                    nn.ReLU(inplace=True)
+                ))
+            ch = out_ch
+
+        self.first_layer = layers[0]
+        self.rest = nn.Sequential(*layers[1:]) if len(layers) > 1 else nn.Identity()
+
+    def forward(self, x_left: torch.Tensor, x_right: torch.Tensor) -> torch.Tensor:
+        x = self.first_layer(x_left, x_right)
+        return self.rest(x)
+
+
+class MonocularPathwayBlock(nn.Module):
+    """
+    Single pathway block that keeps left/right eyes separate.
+    Used for LGN processing where eye segregation persists.
+    """
+    def __init__(self, in_ch: int, out_ch: int, kernel_size: int):
+        super().__init__()
+        self.conv_left = nn.Sequential(
+            nn.Conv2d(in_ch, out_ch, kernel_size, padding=kernel_size//2),
+            nn.BatchNorm2d(out_ch),
+            nn.ReLU(inplace=True)
+        )
+        self.conv_right = nn.Sequential(
+            nn.Conv2d(in_ch, out_ch, kernel_size, padding=kernel_size//2),
+            nn.BatchNorm2d(out_ch),
+            nn.ReLU(inplace=True)
+        )
+
+    def forward(self, x_left: torch.Tensor, x_right: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
+        return self.conv_left(x_left), self.conv_right(x_right)
+
+
+class StridedMonocularBlock(nn.Module):
+    """
+    Monocular pathway block with configurable stride.
+    Keeps left/right eyes separate, uses stride to control spatial sampling.
+
+    Used in V4 for stride-based pathway differentiation.
+    """
+    def __init__(self, in_ch: int, out_ch: int, kernel_size: int = 3, stride: int = 1):
+        super().__init__()
+        padding = kernel_size // 2
+        self.conv_left = nn.Sequential(
+            nn.Conv2d(in_ch, out_ch, kernel_size, stride=stride, padding=padding),
+            nn.BatchNorm2d(out_ch),
+            nn.ReLU(inplace=True)
+        )
+        self.conv_right = nn.Sequential(
+            nn.Conv2d(in_ch, out_ch, kernel_size, stride=stride, padding=padding),
+            nn.BatchNorm2d(out_ch),
+            nn.ReLU(inplace=True)
+        )
+
+    def forward(self, x_left: torch.Tensor, x_right: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
+        return self.conv_left(x_left), self.conv_right(x_right)
+
+
+def count_params(model: nn.Module) -> int:
+    """Count total trainable parameters."""
+    return sum(p.numel() for p in model.parameters())

mpknet_v6.py

@@ -0,0 +1,207 @@
+"""
+BinocularMPKNet V6 - First complete M/P/K pathway implementation with Fibonacci strides.
+
+Key innovations:
+1. First Fibonacci strides (2:3:5) in CNNs - derived from biological spatial frequency tuning
+2. First complete M/P/K implementation - prior work (Magno-Parvo CNN, EVNets) models M/P only
+3. Biologically-grounded K→M/P gating - extends cross-attention (Bahdanau, FiLM) with LGN anatomy
+
+Fibonacci-inspired stride ratios (2:3:5) for P:K:M pathways:
+- P: stride=2, kernel=5 (fine detail, ~80% of LGN neurons)
+- K: stride=3, kernel=5 (context/modulation, ~10% of LGN)
+- M: stride=5, kernel=5 (global gist, ~10% of LGN)
+
+Results:
+- 89.38% on CIFAR-10 with 0.539M parameters
+- 60.8% on ImageNet-100 with 0.54M parameters
+- 89.2% on Kvasir-v2 with 0.21M parameters
+
+The stride ratios produce resolutions converging toward golden ratio (φ ≈ 1.618),
+optimizing multi-scale coverage without redundancy - same principle as phyllotaxis.
+
+Prior art acknowledgment:
+- Cross-stream attention: Bahdanau (2014), FiLM (2018), SlowFast laterals (2019)
+- M/P pathways: Magno-Parvo CNN (2022), EVNets (2024)
+- Contribution: Complete M/P/K with functional K gating, Fibonacci strides
+"""
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from mpknet_components import (
+    BinocularPreMPK,
+    StereoDisparity,
+    StridedMonocularBlock,
+    count_params,
+)
+
+
+class BinocularMPKNetV6(nn.Module):
+    """
+    Binocular MPKNet V6 with fibonacci stride scaling.
+
+    Key changes from V4:
+    - Larger kernel (5 vs 3)
+    - Fibonacci strides: P=2, K=3, M=5
+    - Same information extraction, fewer FLOPs
+
+    The stride/kernel ratio ~0.4-1.0 provides efficient coverage:
+    - P: 5/2 = 2.5 overlap per step (fine but not redundant)
+    - K: 5/3 = 1.67 overlap (moderate)
+    - M: 5/5 = 1.0 no overlap (coarse gist)
+    """
+    def __init__(self, num_classes: int = 10, ch: int = 48,
+                 use_stereo: bool = True, disparity_range: int = 2,
+                 kernel_size: int = 5):
+        super().__init__()
+
+        self.use_stereo = use_stereo
+        self.kernel_size = kernel_size
+
+        # Fibonacci strides: 2, 3, 5
+        self.p_stride = 2
+        self.k_stride = 3
+        self.m_stride = 5
+
+        if use_stereo:
+            self.stereo = StereoDisparity(disparity_range)
+
+        self.pre_mpk = BinocularPreMPK(sigma=1.0)
+
+        # ========== BLOCK 1 ==========
+        # P pathway: stride=2 (detail without noise), 2 layers
+        self.P_block1_layer1 = StridedMonocularBlock(3, ch, kernel_size, stride=self.p_stride)
+        self.P_block1_layer2 = StridedMonocularBlock(ch, ch, kernel_size, stride=1)
+
+        # K pathway: stride=3 (context), 1 layer
+        self.K_block1 = StridedMonocularBlock(3, ch // 2, kernel_size, stride=self.k_stride)
+
+        # M pathway: stride=5 (global gist), 1 layer
+        self.M_block1 = StridedMonocularBlock(3, ch, kernel_size, stride=self.m_stride)
+
+        # K gates for block 1
+        self.k_gate1_M_left = nn.Sequential(nn.Linear(ch // 2, ch), nn.Sigmoid())
+        self.k_gate1_M_right = nn.Sequential(nn.Linear(ch // 2, ch), nn.Sigmoid())
+        self.k_gate1_P_left = nn.Sequential(nn.Linear(ch // 2, ch), nn.Sigmoid())
+        self.k_gate1_P_right = nn.Sequential(nn.Linear(ch // 2, ch), nn.Sigmoid())
+
+        # ========== BLOCK 2 ==========
+        # All stride=1 now (already at different resolutions)
+        self.P_block2_layer1 = StridedMonocularBlock(ch, ch, kernel_size, stride=1)
+        self.P_block2_layer2 = StridedMonocularBlock(ch, ch, kernel_size, stride=1)
+
+        self.K_block2 = StridedMonocularBlock(ch // 2, ch // 2, kernel_size, stride=1)
+
+        self.M_block2 = StridedMonocularBlock(ch, ch, kernel_size, stride=1)
+
+        # K gates for block 2
+        self.k_gate2_M_left = nn.Sequential(nn.Linear(ch // 2, ch), nn.Sigmoid())
+        self.k_gate2_M_right = nn.Sequential(nn.Linear(ch // 2, ch), nn.Sigmoid())
+        self.k_gate2_P_left = nn.Sequential(nn.Linear(ch // 2, ch), nn.Sigmoid())
+        self.k_gate2_P_right = nn.Sequential(nn.Linear(ch // 2, ch), nn.Sigmoid())
+
+        # ========== V1 FUSION ==========
+        self.v1_fusion = nn.Sequential(
+            nn.Conv2d(ch * 4, ch * 2, 1),
+            nn.BatchNorm2d(ch * 2),
+            nn.ReLU(inplace=True),
+        )
+
+        # Classification head (dropout before FC per NiN paper)
+        self.gap = nn.AdaptiveAvgPool2d(1)
+        self.dropout = nn.Dropout(p=0.5)
+        self.fc = nn.Linear(ch * 2, num_classes)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        # Create stereo views
+        if self.use_stereo:
+            x_left, x_right = self.stereo(x)
+        else:
+            x_left, x_right = x, x
+
+        # Retinal preprocessing
+        P_left, M_left, P_right, M_right = self.pre_mpk(x_left, x_right)
+
+        # ========== BLOCK 1 ==========
+        # K first (from original input)
+        K_left, K_right = self.K_block1(P_left, P_right)
+
+        # P pathway: 2 layers
+        P_left, P_right = self.P_block1_layer1(P_left, P_right)
+        P_left, P_right = self.P_block1_layer2(P_left, P_right)
+
+        # M pathway: 1 layer
+        M_left, M_right = self.M_block1(M_left, M_right)
+
+        # K gate 1 - GAP makes it resolution-independent
+        k_ctx1_left = self.gap(K_left).flatten(1)
+        k_ctx1_right = self.gap(K_right).flatten(1)
+
+        gate1_M_left = self.k_gate1_M_left(k_ctx1_left).unsqueeze(-1).unsqueeze(-1)
+        gate1_M_right = self.k_gate1_M_right(k_ctx1_right).unsqueeze(-1).unsqueeze(-1)
+        gate1_P_left = self.k_gate1_P_left(k_ctx1_left).unsqueeze(-1).unsqueeze(-1)
+        gate1_P_right = self.k_gate1_P_right(k_ctx1_right).unsqueeze(-1).unsqueeze(-1)
+
+        M_left = M_left * gate1_M_left
+        M_right = M_right * gate1_M_right
+        P_left = P_left * gate1_P_left
+        P_right = P_right * gate1_P_right
+
+        # ========== BLOCK 2 ==========
+        P_left, P_right = self.P_block2_layer1(P_left, P_right)
+        P_left, P_right = self.P_block2_layer2(P_left, P_right)
+
+        K_left, K_right = self.K_block2(K_left, K_right)
+
+        M_left, M_right = self.M_block2(M_left, M_right)
+
+        # K gate 2
+        k_ctx2_left = self.gap(K_left).flatten(1)
+        k_ctx2_right = self.gap(K_right).flatten(1)
+
+        gate2_M_left = self.k_gate2_M_left(k_ctx2_left).unsqueeze(-1).unsqueeze(-1)
+        gate2_M_right = self.k_gate2_M_right(k_ctx2_right).unsqueeze(-1).unsqueeze(-1)
+        gate2_P_left = self.k_gate2_P_left(k_ctx2_left).unsqueeze(-1).unsqueeze(-1)
+        gate2_P_right = self.k_gate2_P_right(k_ctx2_right).unsqueeze(-1).unsqueeze(-1)
+
+        M_left = M_left * gate2_M_left
+        M_right = M_right * gate2_M_right
+        P_left = P_left * gate2_P_left
+        P_right = P_right * gate2_P_right
+
+        # ========== V1 FUSION ==========
+        # Match spatial sizes only at fusion (pool to smallest)
+        target_size = M_left.shape[-1]  # M is smallest
+        if P_left.shape[-1] != target_size:
+            P_left = F.adaptive_avg_pool2d(P_left, target_size)
+            P_right = F.adaptive_avg_pool2d(P_right, target_size)
+        if K_left.shape[-1] != target_size:
+            K_left = F.adaptive_avg_pool2d(K_left, target_size)
+            K_right = F.adaptive_avg_pool2d(K_right, target_size)
+
+        # Combine all four streams (M and P from both eyes)
+        z = torch.cat([M_left, M_right, P_left, P_right], dim=1)
+        z = self.v1_fusion(z)
+
+        # Classification
+        z = self.gap(z).flatten(1)
+        z = self.dropout(z)
+        return self.fc(z)
+
+
+if __name__ == "__main__":
+    model = BinocularMPKNetV6(num_classes=10, ch=48, use_stereo=True)
+    print(f"BinocularMPKNet V6 params: {count_params(model)/1e6:.3f}M")
+    print(f"Strides: P={model.p_stride}, K={model.k_stride}, M={model.m_stride}")
+    print(f"Kernel: {model.kernel_size}")
+
+    # Test on CIFAR-10 size
+    x = torch.randn(2, 3, 32, 32)
+    y = model(x)
+    print(f"Input: {x.shape}, Output: {y.shape}")
+
+    # Test on larger input
+    x = torch.randn(2, 3, 224, 224)
+    y = model(x)
+    print(f"Input: {x.shape}, Output: {y.shape}")

v6_kvasir_best.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4347d2777ede2279440e1c1f5e264dc8d7724974eb6598a42e9abc2c16d26cb0
+size 2210203