Add backend code (no weights), root README with links and contact

Author: Harshith Reddy

README.md

@@ -1 +1,15 @@
-# Polyp-Frontend
+# Polyp Detection
+
+AI-powered polyp segmentation from colonoscopy images using **DilatedSegNet** (RUPNet): encoder-decoder with ResNet50, dilated convolution pooling, and two model variants (Kvasir-SEG and BKAI-IGH).
+
+**Live app:** [Frontend](https://harshithreddy01.github.io/Polyp-Frontend/)  
+**API:** [Hugging Face Space](https://huggingface.co/spaces/HarshithReddy01/Polyp_Detection)
+
+**Metrics (reported in training):** Dice coefficient **0.90**, mIoU **0.83**, ~33.68 FPS on GPU.
+
+---
+
+- **Frontend:** React (this repo root) — upload image, choose model, view mask and overlay.
+- **Backend:** FastAPI + PyTorch in `/backend` (no weights in repo; see [backend README](backend/README.md) for local run or use the HF link above).
+
+**Contact:** [Harshith Reddy Nalla](https://harshithreddy01.github.io/My-Web/)

backend/Dockerfile

@@ -0,0 +1,15 @@
+FROM python:3.10-slim
+
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+COPY --chown=user requirements.txt requirements.txt
+RUN pip install --no-cache-dir --user -r requirements.txt
+
+COPY --chown=user . /app
+
+EXPOSE 7860
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

backend/README.md

@@ -0,0 +1,8 @@
+# Backend (FastAPI + DilatedSegNet)
+
+This folder contains the API and model code only. **Weight files (`.pth`) are not included.**
+
+- **Use the live API:** [Hugging Face Space](https://huggingface.co/spaces/HarshithReddy01/Polyp_Detection) (no setup).
+- **Run locally:** Place `checkpoint-Kvasir-Seg.pth` and/or `checkpoint-BKAI-IGH.pth` in this folder. Download links: [Kvasir-SEG](https://drive.google.com/file/d/1diYckKDMqDWSDD6O5Jm6InCxWEkU0GJC/view?usp=sharing), [BKAI-IGH](https://drive.google.com/file/d/1ojGaQThD56mRhGQaVoJVpAw0oVwSzX8N/view?usp=sharing).
+
+`pip install -r requirements.txt` then `uvicorn main:app --host 0.0.0.0 --port 7860`.

backend/api/__init__.py

@@ -0,0 +1,44 @@
+import torch
+from fastapi import APIRouter, File, UploadFile, HTTPException, Query
+
+from core.config import IMAGE_SIZE, CHECKPOINT_MAP
+from services import model_service
+from utils.image_utils import (
+    decode_image_from_bytes,
+    preprocess,
+    tensor_to_mask_logits,
+    mask_logits_to_uint8,
+    mask_to_png_base64,
+)
+
+router = APIRouter()
+
+VALID_MODELS = list(CHECKPOINT_MAP.keys())
+
+
+@router.post("/predict")
+async def predict(
+    file: UploadFile = File(...),
+    model: str = Query("Kvasir-Seg"),
+):
+    if model not in VALID_MODELS:
+        raise HTTPException(status_code=400, detail=f"Invalid model. Choose from: {VALID_MODELS}")
+    if not file.content_type or not file.content_type.startswith("image/"):
+        raise HTTPException(status_code=400, detail="Expected an image file")
+    try:
+        data = await file.read()
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=f"Failed to read file: {str(e)}")
+    if not data:
+        raise HTTPException(status_code=400, detail="Empty file")
+    try:
+        image = decode_image_from_bytes(data)
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    tensor = preprocess(image)
+    logits = model_service.predict(tensor, model)
+    probs = torch.sigmoid(logits)
+    pred = tensor_to_mask_logits(probs)
+    mask = mask_logits_to_uint8(pred, threshold=0.5)
+    mask_b64 = mask_to_png_base64(mask)
+    return {"mask": mask_b64, "size": list(IMAGE_SIZE), "model": model}

backend/api/routes.py

@@ -0,0 +1,15 @@
+import os
+from pathlib import Path
+
+import torch as _torch
+
+BASE_DIR = Path(__file__).resolve().parent.parent
+MODEL_DIR = BASE_DIR
+
+CHECKPOINT_MAP = {
+    "Kvasir-Seg": MODEL_DIR / "checkpoint-Kvasir-Seg.pth",
+    "BKAI-IGH":   MODEL_DIR / "checkpoint-BKAI-IGH.pth",
+}
+
+IMAGE_SIZE = (256, 256)
+DEVICE = "cuda" if _torch.cuda.is_available() else "cpu"

backend/core/__init__.py

@@ -0,0 +1,21 @@
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+
+from api.routes import router
+
+app = FastAPI()
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+app.include_router(router)
+
+
+@app.get("/")
+def root():
+    return {"status": "ok", "model": "RUPNet"}

backend/core/config.py

@@ -0,0 +1,185 @@
+import torch
+import torch.nn as nn
+from resnet import resnet50
+import numpy as np
+import cv2
+
+
+def save_feats_mean(x, size=(256, 256)):
+    b, c, h, w = x.shape
+    with torch.no_grad():
+        x = x.detach().cpu().numpy()
+        x = np.transpose(x[0], (1, 2, 0))
+        x = np.mean(x, axis=-1)
+        x = x/np.max(x)
+        x = x * 255.0
+        x = x.astype(np.uint8)
+        if h != size[1]:
+            x = cv2.resize(x, size)
+        x = cv2.applyColorMap(x, cv2.COLORMAP_JET)
+        x = np.array(x, dtype=np.uint8)
+        return x
+
+
+def get_mean_attention_map(x):
+    x = torch.mean(x, axis=1)
+    x = torch.unsqueeze(x, 1)
+    x = x / torch.max(x)
+    return x
+
+
+class ResidualBlock(nn.Module):
+    def __init__(self, in_c, out_c):
+        super().__init__()
+        self.relu = nn.ReLU()
+        self.conv = nn.Sequential(
+            nn.Conv2d(in_c, out_c, kernel_size=3, padding=1),
+            nn.BatchNorm2d(out_c),
+            nn.ReLU(),
+            nn.Conv2d(out_c, out_c, kernel_size=3, padding=1),
+            nn.BatchNorm2d(out_c)
+        )
+        self.shortcut = nn.Sequential(
+            nn.Conv2d(in_c, out_c, kernel_size=1, padding=0),
+            nn.BatchNorm2d(out_c)
+        )
+
+    def forward(self, inputs):
+        x1 = self.conv(inputs)
+        x2 = self.shortcut(inputs)
+        x = self.relu(x1 + x2)
+        return x
+
+
+class DilatedConv(nn.Module):
+    def __init__(self, in_c, out_c):
+        super().__init__()
+        self.c1 = nn.Sequential(
+            nn.Conv2d(in_c, out_c, kernel_size=3, padding=1, dilation=1),
+            nn.BatchNorm2d(out_c),
+            nn.ReLU()
+        )
+        self.c2 = nn.Sequential(
+            nn.Conv2d(in_c, out_c, kernel_size=3, padding=3, dilation=3),
+            nn.BatchNorm2d(out_c),
+            nn.ReLU()
+        )
+        self.c3 = nn.Sequential(
+            nn.Conv2d(in_c, out_c, kernel_size=3, padding=6, dilation=6),
+            nn.BatchNorm2d(out_c),
+            nn.ReLU()
+        )
+        self.c4 = nn.Sequential(
+            nn.Conv2d(in_c, out_c, kernel_size=3, padding=9, dilation=9),
+            nn.BatchNorm2d(out_c),
+            nn.ReLU()
+        )
+        self.c5 = nn.Sequential(
+            nn.Conv2d(out_c*4, out_c, kernel_size=1, padding=0),
+            nn.BatchNorm2d(out_c),
+            nn.ReLU()
+        )
+
+    def forward(self, inputs):
+        x1 = self.c1(inputs)
+        x2 = self.c2(inputs)
+        x3 = self.c3(inputs)
+        x4 = self.c4(inputs)
+        x = torch.cat([x1, x2, x3, x4], axis=1)
+        x = self.c5(x)
+        return x
+
+
+class ChannelAttention(nn.Module):
+    def __init__(self, in_planes, ratio=16):
+        super(ChannelAttention, self).__init__()
+        self.avg_pool = nn.AdaptiveAvgPool2d(1)
+        self.max_pool = nn.AdaptiveMaxPool2d(1)
+        self.fc1   = nn.Conv2d(in_planes, in_planes // 16, 1, bias=False)
+        self.relu1 = nn.ReLU()
+        self.fc2   = nn.Conv2d(in_planes // 16, in_planes, 1, bias=False)
+        self.sigmoid = nn.Sigmoid()
+
+    def forward(self, x):
+        x0 = x
+        avg_out = self.fc2(self.relu1(self.fc1(self.avg_pool(x))))
+        max_out = self.fc2(self.relu1(self.fc1(self.max_pool(x))))
+        out = avg_out + max_out
+        return x0 * self.sigmoid(out)
+
+
+class SpatialAttention(nn.Module):
+    def __init__(self, kernel_size=7):
+        super(SpatialAttention, self).__init__()
+        assert kernel_size in (3, 7), 'kernel size must be 3 or 7'
+        padding = 3 if kernel_size == 7 else 1
+        self.conv1 = nn.Conv2d(2, 1, kernel_size, padding=padding, bias=False)
+        self.sigmoid = nn.Sigmoid()
+
+    def forward(self, x):
+        x0 = x
+        avg_out = torch.mean(x, dim=1, keepdim=True)
+        max_out, _ = torch.max(x, dim=1, keepdim=True)
+        x = torch.cat([avg_out, max_out], dim=1)
+        x = self.conv1(x)
+        return x0 * self.sigmoid(x)
+
+
+class DecoderBlock(nn.Module):
+    def __init__(self, in_c, out_c):
+        super().__init__()
+        self.up = nn.Upsample(scale_factor=2, mode="bilinear", align_corners=True)
+        self.r1 = ResidualBlock(in_c[0]+in_c[1], out_c)
+        self.r2 = ResidualBlock(out_c, out_c)
+        self.ca = ChannelAttention(out_c)
+        self.sa = SpatialAttention()
+
+    def forward(self, x, s):
+        x = self.up(x)
+        x = torch.cat([x, s], axis=1)
+        x = self.r1(x)
+        x = self.r2(x)
+        x = self.ca(x)
+        x = self.sa(x)
+        return x
+
+
+class RUPNet(nn.Module):
+    def __init__(self):
+        super().__init__()
+        backbone = resnet50(pretrained=False)
+        self.layer0 = nn.Sequential(backbone.conv1, backbone.bn1, backbone.relu)
+        self.layer1 = nn.Sequential(backbone.maxpool, backbone.layer1)
+        self.layer2 = backbone.layer2
+        self.layer3 = backbone.layer3
+        self.r1 = nn.Sequential(DilatedConv(64, 64), nn.MaxPool2d((8, 8)))
+        self.r2 = nn.Sequential(DilatedConv(256, 64), nn.MaxPool2d((4, 4)))
+        self.r3 = nn.Sequential(DilatedConv(512, 64), nn.MaxPool2d((2, 2)))
+        self.r4 = DilatedConv(1024, 64)
+        self.d1 = DecoderBlock([256, 512], 256)
+        self.d2 = DecoderBlock([256, 256], 128)
+        self.d3 = DecoderBlock([128, 64], 64)
+        self.d4 = DecoderBlock([64, 3], 32)
+        self.y = nn.Conv2d(32, 1, kernel_size=1, padding=0)
+
+    def forward(self, x, heatmap=None):
+        s0 = x
+        s1 = self.layer0(s0)
+        s2 = self.layer1(s1)
+        s3 = self.layer2(s2)
+        s4 = self.layer3(s3)
+        r1 = self.r1(s1)
+        r2 = self.r2(s2)
+        r3 = self.r3(s3)
+        r4 = self.r4(s4)
+        rx = torch.cat([r1, r2, r3, r4], axis=1)
+        d1 = self.d1(rx, s3)
+        d2 = self.d2(d1, s2)
+        d3 = self.d3(d2, s1)
+        d4 = self.d4(d3, s0)
+        y = self.y(d4)
+        if heatmap is not None:
+            hmap = save_feats_mean(d4)
+            return hmap, y
+        else:
+            return y

backend/main.py

@@ -0,0 +1,7 @@
+fastapi==0.109.2
+uvicorn[standard]==0.27.1
+python-multipart==0.0.9
+torch>=1.9.0
+torchvision>=0.10.0
+opencv-python-headless>=4.5.0
+numpy>=1.21.0