Update binary_segmentation.py

binary_segmentation.py

@@ -17,6 +17,7 @@ import torch
 from PIL import Image
 from torchvision import transforms
 import cv2
+from u2net import U2NETP
 
 # Configure logging
 logging.basicConfig(
@@ -31,15 +32,12 @@ logger.info(f"Using device: {DEVICE}")
 
 
 class U2NETP(torch.nn.Module):
-    """U2-Net Portrait (U2NETP) - Lightweight segmentation model
-    
-    Fixed to match pretrained weights architecture with 6 stages/side outputs.
-    """
+    """U2-Net Portrait (U2NETP) - Lightweight segmentation model"""
     
     def __init__(self, in_ch=3, out_ch=1):
         super(U2NETP, self).__init__()
         
-        # Encoder (6 stages to match pretrained weights)
+        # Encoder
         self.stage1 = self._make_stage(in_ch, 16, 64)
         self.pool12 = torch.nn.MaxPool2d(2, stride=2, ceil_mode=True)
         
@@ -50,31 +48,25 @@ class U2NETP(torch.nn.Module):
         self.pool34 = torch.nn.MaxPool2d(2, stride=2, ceil_mode=True)
         
         self.stage4 = self._make_stage(64, 16, 64)
-        self.pool45 = torch.nn.MaxPool2d(2, stride=2, ceil_mode=True)
-        
-        self.stage5 = self._make_stage(64, 16, 64)
-        self.pool56 = torch.nn.MaxPool2d(2, stride=2, ceil_mode=True)
         
         # Bridge
-        self.stage6 = self._make_stage(64, 16, 64)
+        self.stage5 = self._make_stage(64, 16, 64)
         
-        # Decoder (5 decoder stages)
-        self.stage5d = self._make_stage(128, 16, 64)
+        # Decoder
         self.stage4d = self._make_stage(128, 16, 64)
         self.stage3d = self._make_stage(128, 16, 64)
         self.stage2d = self._make_stage(128, 16, 64)
         self.stage1d = self._make_stage(128, 16, 64)
         
-        # Side outputs (6 outputs to match pretrained weights)
+        # Side outputs
         self.side1 = torch.nn.Conv2d(64, out_ch, 3, padding=1)
         self.side2 = torch.nn.Conv2d(64, out_ch, 3, padding=1)
         self.side3 = torch.nn.Conv2d(64, out_ch, 3, padding=1)
         self.side4 = torch.nn.Conv2d(64, out_ch, 3, padding=1)
         self.side5 = torch.nn.Conv2d(64, out_ch, 3, padding=1)
-        self.side6 = torch.nn.Conv2d(64, out_ch, 3, padding=1)
         
-        # Output fusion (6 channels now)
-        self.outconv = torch.nn.Conv2d(6 * out_ch, out_ch, 1)
+        # Output fusion
+        self.outconv = torch.nn.Conv2d(5 * out_ch, out_ch, 1)
     
     def _make_stage(self, in_ch, mid_ch, out_ch):
         return torch.nn.Sequential(
@@ -89,7 +81,7 @@ class U2NETP(torch.nn.Module):
     def forward(self, x):
         hx = x
         
-        # Encoder with skip connections
+        # Encoder
         hx1 = self.stage1(hx)
         hx = self.pool12(hx1)
         
@@ -100,28 +92,18 @@ class U2NETP(torch.nn.Module):
         hx = self.pool34(hx3)
         
         hx4 = self.stage4(hx)
-        hx = self.pool45(hx4)
-        
-        hx5 = self.stage5(hx)
-        hx = self.pool56(hx5)
-        
-        # Bridge
-        hx6 = self.stage6(hx)
-        
-        # Decoder with skip connections
-        hx6up = torch.nn.functional.interpolate(hx6, size=hx5.shape[2:], mode='bilinear', align_corners=True)
-        hx5d = self.stage5d(torch.cat((hx6up, hx5), 1))
+        hx5 = self.stage5(hx4)
         
-        hx5dup = torch.nn.functional.interpolate(hx5d, size=hx4.shape[2:], mode='bilinear', align_corners=True)
-        hx4d = self.stage4d(torch.cat((hx5dup, hx4), 1))
+        # Decoder
+        hx4d = self.stage4d(torch.cat((hx5, hx4), 1))
+        hx4dup = torch.nn.functional.interpolate(hx4d, scale_factor=2, mode='bilinear', align_corners=True)
         
-        hx4dup = torch.nn.functional.interpolate(hx4d, size=hx3.shape[2:], mode='bilinear', align_corners=True)
         hx3d = self.stage3d(torch.cat((hx4dup, hx3), 1))
+        hx3dup = torch.nn.functional.interpolate(hx3d, scale_factor=2, mode='bilinear', align_corners=True)
         
-        hx3dup = torch.nn.functional.interpolate(hx3d, size=hx2.shape[2:], mode='bilinear', align_corners=True)
         hx2d = self.stage2d(torch.cat((hx3dup, hx2), 1))
+        hx2dup = torch.nn.functional.interpolate(hx2d, scale_factor=2, mode='bilinear', align_corners=True)
         
-        hx2dup = torch.nn.functional.interpolate(hx2d, size=hx1.shape[2:], mode='bilinear', align_corners=True)
         hx1d = self.stage1d(torch.cat((hx2dup, hx1), 1))
         
         # Side outputs
@@ -129,13 +111,12 @@ class U2NETP(torch.nn.Module):
         d2 = torch.nn.functional.interpolate(self.side2(hx2d), size=d1.shape[2:], mode='bilinear', align_corners=True)
         d3 = torch.nn.functional.interpolate(self.side3(hx3d), size=d1.shape[2:], mode='bilinear', align_corners=True)
         d4 = torch.nn.functional.interpolate(self.side4(hx4d), size=d1.shape[2:], mode='bilinear', align_corners=True)
-        d5 = torch.nn.functional.interpolate(self.side5(hx5d), size=d1.shape[2:], mode='bilinear', align_corners=True)
-        d6 = torch.nn.functional.interpolate(self.side6(hx6), size=d1.shape[2:], mode='bilinear', align_corners=True)
+        d5 = torch.nn.functional.interpolate(self.side5(hx5), size=d1.shape[2:], mode='bilinear', align_corners=True)
         
-        # Fusion (6 side outputs now)
-        d0 = self.outconv(torch.cat((d1, d2, d3, d4, d5, d6), 1))
+        # Fusion
+        d0 = self.outconv(torch.cat((d1, d2, d3, d4, d5), 1))
         
-        return torch.sigmoid(d0), torch.sigmoid(d1), torch.sigmoid(d2), torch.sigmoid(d3), torch.sigmoid(d4), torch.sigmoid(d5), torch.sigmoid(d6)
+        return torch.sigmoid(d0), torch.sigmoid(d1), torch.sigmoid(d2), torch.sigmoid(d3), torch.sigmoid(d4), torch.sigmoid(d5)
 
 
 class BinarySegmenter: