Upload 5 files

GB_stu_mob.pth

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

app.py

@@ -0,0 +1,72 @@
+import torch
+import torch.nn as nn
+from torchvision import transforms
+from model import ModifiedMobileNetV2
+import numpy as np
+from PIL import Image
+from fastapi import FastAPI, File, UploadFile, HTTPException
+from io import BytesIO
+import logging
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+app = FastAPI()
+
+# Class names provided by user
+class_names = ['Gallstones', 'Cholecystitis', 'Gangrenous_Cholecystitis', 'Perforation', 'Polyps&Cholesterol_Crystal', 'WallThickening', 'Adenomyomatosis', 'Carcinoma', 'Intra-abdominal&Retroperitoneum', 'Normal']
+
+# Device setup
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+logger.info(f"Using device: {device}")
+
+# Load model
+try:
+    model = ModifiedMobileNetV2(num_classes=len(class_names)).to(device)
+    model.load_state_dict(torch.load('GB_stu_mob.pth', map_location=device))
+    model.eval()
+    logger.info("Model loaded successfully")
+except Exception as e:
+    logger.error(f"Error loading model: {str(e)}")
+    raise
+
+# Preprocessing
+preprocess = transforms.Compose([
+    transforms.Resize((224, 224)),
+    transforms.ToTensor(),
+    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+])
+
+# Inference function
+def predict(image):
+    with torch.no_grad():
+        if not torch.is_tensor(image):
+            image = preprocess(image).unsqueeze(0)
+        image = image.to(device)
+        output = model(image)
+        probabilities = torch.softmax(output, dim=1)
+        predicted_class = torch.argmax(probabilities, dim=1)
+        confidence_score = probabilities[0, predicted_class.item()].item()
+    return class_names[predicted_class.item()], confidence_score
+
+@app.post("/predict")
+async def predict_image(file: UploadFile = File(...)):
+    try:
+        # Read image file
+        contents = await file.read()
+        image = Image.open(BytesIO(contents)).convert('RGB')
+        # Run prediction
+        class_name, confidence_score = predict(image)
+        return {
+            "filename": file.filename,
+            "predicted_class": class_name,
+            "confidence_score": confidence_score
+        }
+    except Exception as e:
+        logger.error(f"Error processing image: {str(e)}")
+        raise HTTPException(status_code=400, detail=f"Error processing image: {str(e)}")
+
+@app.get("/")
+async def root():
+    return {"message": "Welcome to the ModifiedMobileNetV2 API. Use POST /predict to upload an image."}

dockerfile

@@ -0,0 +1,32 @@
+FROM python:3.9
+
+WORKDIR /code
+
+# Install system dependencies for pillow
+RUN apt-get update && apt-get install -y \
+    libpng-dev \
+    libjpeg-dev \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy and install requirements first for caching
+COPY ./requirements.txt /code/requirements.txt
+RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
+
+# Create non-root user
+RUN useradd user
+USER user
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH
+
+# Set working directory for app
+WORKDIR $HOME/app
+
+# Copy application files with correct ownership
+COPY --chown=user ./app.py $HOME/app/app.py
+COPY --chown=user ./model.py $HOME/app/model.py
+COPY --chown=user ./GB_stu_mob.pth $HOME/app/GB_stu_mob.pth
+
+# Expose port
+EXPOSE 7860
+
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

model.py

@@ -0,0 +1,93 @@
+import torch
+import torch.nn as nn
+from torchvision.models import mobilenet_v2
+
+class TripletAttention(nn.Module):
+        def __init__(self, in_channels, kernel_size=7):
+            super(TripletAttention, self).__init__()
+            self.conv1 = nn.Conv2d(2, 1, kernel_size=kernel_size, padding=kernel_size // 2)
+            self.sigmoid = nn.Sigmoid()
+        def forward(self, x):
+            x_perm1 = x
+            x_perm2 = x.permute(0, 2, 1, 3)
+            x_perm3 = x.permute(0, 3, 2, 1)
+            out1 = self._attention(x_perm1)
+            out2 = self._attention(x_perm2).permute(0, 2, 1, 3)
+            out3 = self._attention(x_perm3).permute(0, 3, 2, 1)
+            out = (out1 + out2 + out3) / 3
+            return out
+        def _attention(self, x):
+            avg_out = torch.mean(x, dim=1, keepdim=True)
+            max_out, _ = torch.max(x, dim=1, keepdim=True)
+            pool = torch.cat([avg_out, max_out], dim=1)
+            attn = self.conv1(pool)
+            attn = self.sigmoid(attn)
+            return x * attn
+    
+class SEBlock(nn.Module):
+        def __init__(self, in_channels, reduction=16):
+            super(SEBlock, self).__init__()
+            self.fc1 = nn.Conv2d(in_channels, in_channels // reduction, kernel_size=1)
+            self.relu = nn.ReLU(inplace=True)
+            self.fc2 = nn.Conv2d(in_channels // reduction, in_channels, kernel_size=1)
+            self.sigmoid = nn.Sigmoid()
+        def forward(self, x):
+            w = nn.functional.adaptive_avg_pool2d(x, 1)
+            w = self.relu(self.fc1(w))
+            w = self.sigmoid(self.fc2(w))
+            return x * w
+    
+class ECABlock(nn.Module):
+        def __init__(self, channels, k_size=3):
+            super(ECABlock, self).__init__()
+            self.avg_pool = nn.AdaptiveAvgPool2d(1)
+            self.conv = nn.Conv1d(1, 1, kernel_size=k_size, padding=(k_size - 1) // 2, bias=False)
+            self.sigmoid = nn.Sigmoid()
+        def forward(self, x):
+            y = self.avg_pool(x)
+            y = self.conv(y.squeeze(-1).transpose(-1, -2)).transpose(-1, -2).unsqueeze(-1)
+            y = self.sigmoid(y)
+            return x * y.expand_as(x)
+    
+class RESBlock(nn.Module):
+        def __init__(self, in_channels):
+            super(RESBlock, self).__init__()
+            self.se = SEBlock(in_channels)
+            self.eca = ECABlock(in_channels)
+        def forward(self, x):
+            out_se = self.se(x)
+            out_eca = self.eca(x)
+            return out_se + out_eca
+    
+class ModifiedMobileNetV2(nn.Module):
+        def __init__(self, num_classes=10, insert_indices=(3, 5, 8, 10, 13, 15)):
+            super().__init__()
+            base = mobilenet_v2(weights='DEFAULT')
+            self.features = nn.Sequential()
+            attention_count = 0
+            resblock_count = 0
+            ta_insert_points = set([3, 8, 13])
+            res_insert_points = set([5, 10, 15])
+            for idx, layer in enumerate(base.features):
+                self.features.add_module(str(idx), layer)
+                out_channels = None
+                if hasattr(layer, 'out_channels'):
+                    out_channels = layer.out_channels
+                elif hasattr(layer, 'conv'):
+                    out_channels = layer.conv[-1].out_channels
+                else:
+                    out_channels = layer[0].out_channels
+                if idx in ta_insert_points:
+                    self.features.add_module(f'ta{attention_count+1}', TripletAttention(out_channels))
+                    attention_count += 1
+                if idx in res_insert_points:
+                    self.features.add_module(f'res{resblock_count+1}', RESBlock(out_channels))
+                    resblock_count += 1
+            self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
+            self.classifier = nn.Linear(base.last_channel, num_classes)
+        def forward(self, x):
+            x = self.features(x)
+            x = self.avgpool(x)
+            x = torch.flatten(x, 1)
+            x = self.classifier(x)
+            return x

requirements.txt

@@ -0,0 +1,5 @@
+fastapi==0.103.0 
+uvicorn==0.23.2 
+torchvision==0.15.2 
+pillow==9.5.0
+python-multipart==0.0.9