Upload 7 files

Dockerfile

@@ -0,0 +1,29 @@
+FROM python:3.10-slim
+
+WORKDIR /app
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY fastapi_app/requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code (excluding models directory)
+COPY fastapi_app/app.py .
+COPY fastapi_app/scripts ./scripts
+COPY fastapi_app/templates ./templates
+
+# Create cache directory for model downloads
+RUN mkdir -p /app/.cache && \
+    useradd -m -u 1000 appuser && \
+    chown -R appuser:appuser /app
+
+USER appuser
+
+EXPOSE 8000
+
+HEALTHCHECK --interval=30s --timeout=10s --start-period=120s --retries=3 \
+    CMD python -c "import urllib.request; urllib.request.urlopen('http://localhost:8000/health')" || exit 1
+
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8000"]

fastapi_app/app.py

@@ -0,0 +1,123 @@
+import warnings
+import os
+import tempfile
+from pathlib import Path
+
+from fastapi import FastAPI, File, UploadFile, HTTPException, Request
+from fastapi.responses import HTMLResponse
+from fastapi.templating import Jinja2Templates
+from PIL import Image
+import torch
+
+from scripts.logging import get_logger
+from scripts.utils import ViTBrainTumorClassifier
+from scripts.data_model import ClassificationResponse, Prediction
+
+warnings.filterwarnings("ignore")
+logger = get_logger(__name__)
+
+app = FastAPI(
+    title="Brain Tumor Classification Inference API",
+    description="Vision Transformer based brain tumor classification",
+    version="1.0.0"
+)
+
+BASE_DIR = Path(__file__).parent
+templates = Jinja2Templates(directory=str(BASE_DIR / "templates"))
+MODEL = None
+
+
+@app.on_event("startup")
+async def startup_event():
+    global MODEL
+    try:
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+        logger.info(f"Using device: {device}")
+        MODEL = ViTBrainTumorClassifier(device=device)
+        logger.info("Application startup complete")
+    except Exception as e:
+        logger.error(f"Failed to initialize model: {e}")
+        raise
+
+
+@app.on_event("shutdown")
+async def shutdown_event():
+    logger.info("Application shutting down...")
+
+
+@app.get("/", response_class=HTMLResponse)
+async def index(request: Request):
+    return templates.TemplateResponse("index.html", {"request": request})
+
+
+@app.get("/health")
+async def health_check():
+    return {
+        "status": "healthy",
+        "model_loaded": MODEL is not None,
+        "version": "1.0.0"
+    }
+
+
+@app.post("/api/v1/classify")
+async def classify_image(file: UploadFile = File(...)) -> ClassificationResponse:
+    """
+    Classify a brain tumor from an uploaded image.
+    """
+    if MODEL is None:
+        raise HTTPException(status_code=500, detail="Model not initialized")
+    
+    allowed_extensions = {".jpg", ".jpeg", ".png", ".gif", ".bmp"}
+    file_extension = Path(file.filename).suffix.lower()
+    
+    if file_extension not in allowed_extensions:
+        raise HTTPException(
+            status_code=400,
+            detail=f"Invalid file type. Allowed: {', '.join(allowed_extensions)}"
+        )
+    
+    try:
+        contents = await file.read()
+        
+        with tempfile.NamedTemporaryFile(suffix=file_extension, delete=False) as tmp:
+            tmp.write(contents)
+            tmp_path = tmp.name
+        
+        try:
+            Image.open(tmp_path).verify()
+        except Exception:
+            if os.path.exists(tmp_path):
+                os.remove(tmp_path)
+            raise HTTPException(status_code=400, detail="Invalid image file")
+        
+        try:
+            logger.info(f"Processing: {file.filename}")
+            prediction_result = MODEL.predict(tmp_path)
+            
+            response = ClassificationResponse(
+                success=True,
+                prediction=Prediction(
+                    predicted_class=prediction_result["predicted_class"],
+                    confidence=prediction_result["confidence"],
+                    all_predictions=prediction_result["all_predictions"]
+                ),
+                message=f"Successfully classified as {prediction_result['predicted_class']}"
+            )
+            
+            logger.info(f"Complete: {prediction_result['predicted_class']}")
+            return response
+            
+        finally:
+            if os.path.exists(tmp_path):
+                os.remove(tmp_path)
+    
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error: {e}")
+        raise HTTPException(status_code=500, detail=f"Classification failed: {str(e)}")
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app="app:app", port=8000, reload=True, host="0.0.0.0")

fastapi_app/requirements.txt

@@ -0,0 +1,9 @@
+fastapi==0.115.6
+uvicorn[standard]==0.34.0
+jinja2==3.1.5
+python-multipart==0.0.18
+transformers==4.43.3
+torch==2.3.1
+torchvision==0.18.1
+Pillow==10.2.0
+pydantic==2.8.2

fastapi_app/scripts/data_model.py

@@ -0,0 +1,19 @@
+from pydantic import BaseModel, Field
+from typing import Dict
+
+
+class Prediction(BaseModel):
+    predicted_class: str = Field(..., description="Predicted tumor class")
+    confidence: float = Field(..., description="Confidence percentage (0-100)")
+    all_predictions: Dict[str, float] = Field(..., description="Confidence scores for all classes")
+
+
+class ClassificationResponse(BaseModel):
+    success: bool = Field(..., description="Whether classification was successful")
+    prediction: Prediction = Field(..., description="Classification results")
+    message: str = Field(default="", description="Additional message or error info")
+
+
+
+
+

fastapi_app/scripts/logging.py

@@ -0,0 +1,36 @@
+import logging
+import sys
+from logging.handlers import RotatingFileHandler
+from pathlib import Path
+
+
+def get_logger(name: str) -> logging.Logger:
+    logger = logging.getLogger(name)
+    
+    if logger.hasHandlers():
+        return logger
+    
+    logger.setLevel(logging.DEBUG)
+    logs_dir = Path("logs")
+    logs_dir.mkdir(exist_ok=True)
+    
+    formatter = logging.Formatter(
+        fmt="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S"
+    )
+    
+    console_handler = logging.StreamHandler(sys.stdout)
+    console_handler.setLevel(logging.INFO)
+    console_handler.setFormatter(formatter)
+    logger.addHandler(console_handler)
+    
+    file_handler = RotatingFileHandler(
+        logs_dir / "app.log",
+        maxBytes=10 * 1024 * 1024,
+        backupCount=5
+    )
+    file_handler.setLevel(logging.DEBUG)
+    file_handler.setFormatter(formatter)
+    logger.addHandler(file_handler)
+    
+    return logger

fastapi_app/scripts/utils.py

@@ -0,0 +1,63 @@
+from transformers import ViTImageProcessor, ViTForImageClassification
+from PIL import Image
+import os
+import torch
+from .logging import get_logger
+
+logger = get_logger(__name__)
+
+
+class ViTBrainTumorClassifier:
+    CLASS_LABELS = {0: "Glioma", 1: "Meningioma", 2: "No Tumor", 3: "Pituitary"}
+    
+    def __init__(self, device: str = "cpu", model_name: str = "codeby-hp/vit-brain-tumor-classifier"):
+        self.device = device
+        self.model_name = model_name
+        self.model = None
+        self.processor = None
+        self._load_model()
+    
+    def _load_model(self):
+        try:
+            logger.info(f"Downloading model from HuggingFace Hub: {self.model_name}")
+            
+            # Download from HuggingFace Hub
+            self.processor = ViTImageProcessor.from_pretrained(self.model_name)
+            self.model = ViTForImageClassification.from_pretrained(self.model_name)
+            self.model.to(self.device)
+            self.model.eval()
+            
+            logger.info(f"Model loaded successfully on {self.device}")
+        except Exception as e:
+            logger.error(f"Model loading failed: {e}")
+            raise
+    
+    def predict(self, image_path: str) -> dict:
+        try:
+            image = Image.open(image_path).convert("RGB")
+            inputs = self.processor(images=image, return_tensors="pt")
+            inputs = {k: v.to(self.device) for k, v in inputs.items()}
+            
+            with torch.no_grad():
+                outputs = self.model(**inputs)
+                logits = outputs.logits
+            
+            probabilities = torch.nn.functional.softmax(logits, dim=-1)
+            predicted_class = torch.argmax(probabilities, dim=-1).item()
+            confidence = probabilities[0, predicted_class].item()
+            
+            result = {
+                "predicted_class": self.CLASS_LABELS.get(predicted_class, "Unknown"),
+                "confidence": round(confidence * 100, 2),
+                "all_predictions": {
+                    self.CLASS_LABELS[i]: round(probabilities[0, i].item() * 100, 2)
+                    for i in range(len(self.CLASS_LABELS))
+                }
+            }
+            
+            logger.info(f"Prediction: {result['predicted_class']} ({result['confidence']}%)")
+            return result
+            
+        except Exception as e:
+            logger.error(f"Prediction error: {e}")
+            raise

fastapi_app/templates/index.html

@@ -0,0 +1,255 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Brain Tumor Classification</title>
+    <script src="https://cdn.jsdelivr.net/npm/@tailwindcss/browser@4"></script>
+    <style>
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, sans-serif;
+        }
+        
+        .glass-effect {
+            background: rgba(255, 255, 255, 0.95);
+            backdrop-filter: blur(10px);
+            border: 1px solid rgba(255, 255, 255, 0.2);
+        }
+        
+        .gradient-accent {
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        }
+        
+        .spinner {
+            display: inline-block;
+            width: 20px;
+            height: 20px;
+            border: 3px solid rgba(255, 255, 255, 0.3);
+            border-radius: 50%;
+            border-top-color: white;
+            animation: spin 0.8s linear infinite;
+        }
+        
+        .spinner.hidden {
+            display: none;
+        }
+        
+        @keyframes spin {
+            to { transform: rotate(360deg); }
+        }
+    </style>
+</head>
+<body class="bg-gray-50">
+    <div class="min-h-screen flex items-center justify-center px-4 py-8">
+        <div class="w-full max-w-2xl">
+            <!-- Header -->
+            <div class="mb-8 text-center">
+                <h1 class="text-4xl font-bold text-gray-900 mb-2">Brain Tumor Classification</h1>
+                <p class="text-gray-600">Upload an MRI scan for AI-powered analysis</p>
+            </div>
+
+            <!-- Main Card -->
+            <div id="mainCard" class="glass-effect rounded-2xl shadow-xl p-8 mb-6">
+                <!-- Upload Section -->
+                <div id="uploadSection" class="mb-8">
+                    <label for="imageInput" class="block mb-4">
+                        <div class="border-2 border-dashed border-gray-300 rounded-xl p-8 text-center cursor-pointer hover:border-purple-500 transition-colors">
+                            <svg class="w-12 h-12 mx-auto text-gray-400 mb-3" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                                <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M4 16l4.586-4.586a2 2 0 012.828 0L16 16m-2-2l1.586-1.586a2 2 0 012.828 0L20 14m-6-6h.01M6 20h12a2 2 0 002-2V6a2 2 0 00-2-2H6a2 2 0 00-2 2v12a2 2 0 002 2z"></path>
+                            </svg>
+                            <p class="text-gray-700 font-semibold mb-1">Click to upload or drag and drop</p>
+                            <p class="text-sm text-gray-500">PNG, JPG, GIF up to 10MB</p>
+                        </div>
+                    </label>
+                    <input type="file" id="imageInput" accept="image/*" class="hidden" />
+                </div>
+
+                <!-- Preview Section -->
+                <div id="previewSection" class="hidden mb-8">
+                    <div class="relative rounded-xl overflow-hidden bg-gray-100 mb-4">
+                        <img id="previewImage" src="" alt="Preview" class="w-full h-auto max-h-96 object-contain" />
+                    </div>
+                    <button id="removeButton" class="w-full bg-gray-200 hover:bg-gray-300 text-gray-800 font-semibold py-2 rounded-lg transition-colors">
+                        Choose Different Image
+                    </button>
+                </div>
+
+                <!-- Submit Button -->
+                <button id="classifyButton" class="w-full gradient-accent text-white font-semibold py-3 rounded-lg hover:opacity-90 transition-opacity mb-4 flex items-center justify-center gap-2">
+                    <span id="buttonText">Classify Image</span>
+                    <span id="spinner" class="hidden spinner"></span>
+                </button>
+
+                <!-- Error Message -->
+                <div id="errorMessage" class="hidden bg-red-50 border border-red-200 text-red-700 px-4 py-3 rounded-lg text-sm"></div>
+            </div>
+
+            <!-- Results Section -->
+            <div id="resultsSection" class="hidden glass-effect rounded-2xl shadow-xl p-8">
+                <h2 class="text-2xl font-bold text-gray-900 mb-6">Classification Results</h2>
+                
+                <!-- Main Prediction -->
+                <div class="mb-8 p-6 gradient-accent text-white rounded-xl">
+                    <p class="text-sm font-semibold opacity-90 mb-2">DIAGNOSIS</p>
+                    <p id="mainPrediction" class="text-3xl font-bold mb-2">-</p>
+                    <p id="mainConfidence" class="text-lg opacity-90">Confidence: -%</p>
+                </div>
+
+                <!-- Detailed Breakdown -->
+                <div class="mb-8">
+                    <h3 class="text-lg font-semibold text-gray-900 mb-4">Confidence Scores</h3>
+                    <div id="predictionsList" class="space-y-3"></div>
+                </div>
+
+                <!-- Action Buttons -->
+                <button id="analyzeButton" class="w-full gradient-accent text-white font-semibold py-3 rounded-lg hover:opacity-90 transition-opacity">
+                    Analyze Another Image
+                </button>
+            </div>
+
+            <!-- Footer -->
+            <div class="mt-8 text-center text-gray-600 text-sm">
+                <p>Vision Transformer (ViT) powered classification</p>
+            </div>
+        </div>
+    </div>
+
+    <script>
+        const imageInput = document.getElementById('imageInput');
+        const uploadSection = document.getElementById('uploadSection');
+        const previewSection = document.getElementById('previewSection');
+        const previewImage = document.getElementById('previewImage');
+        const classifyButton = document.getElementById('classifyButton');
+        const removeButton = document.getElementById('removeButton');
+        const mainCard = document.getElementById('mainCard');
+        const resultsSection = document.getElementById('resultsSection');
+        const errorMessage = document.getElementById('errorMessage');
+        const analyzeButton = document.getElementById('analyzeButton');
+        const mainPrediction = document.getElementById('mainPrediction');
+        const mainConfidence = document.getElementById('mainConfidence');
+        const predictionsList = document.getElementById('predictionsList');
+        const buttonText = document.getElementById('buttonText');
+        const spinner = document.getElementById('spinner');
+
+        imageInput.addEventListener('change', (e) => {
+            const file = e.target.files[0];
+            if (file) {
+                const reader = new FileReader();
+                reader.onload = (event) => {
+                    previewImage.src = event.target.result;
+                    uploadSection.classList.add('hidden');
+                    previewSection.classList.remove('hidden');
+                    resultsSection.classList.add('hidden');
+                    errorMessage.classList.add('hidden');
+                };
+                reader.readAsDataURL(file);
+            }
+        });
+
+        removeButton.addEventListener('click', () => {
+            imageInput.value = '';
+            previewSection.classList.add('hidden');
+            uploadSection.classList.remove('hidden');
+            resultsSection.classList.add('hidden');
+            errorMessage.classList.add('hidden');
+        });
+
+        classifyButton.addEventListener('click', async () => {
+            const file = imageInput.files[0];
+            if (!file) {
+                showError('Please select an image');
+                return;
+            }
+
+            const formData = new FormData();
+            formData.append('file', file);
+
+            classifyButton.disabled = true;
+            buttonText.textContent = 'Classifying...';
+            spinner.classList.remove('hidden');
+            errorMessage.classList.add('hidden');
+
+            try {
+                const response = await fetch('/api/v1/classify', {
+                    method: 'POST',
+                    body: formData
+                });
+
+                if (!response.ok) {
+                    const error = await response.json();
+                    showError(error.detail || 'Classification failed');
+                    return;
+                }
+
+                const data = await response.json();
+                displayResults(data.prediction);
+            } catch (error) {
+                showError('Network error: ' + error.message);
+            } finally {
+                classifyButton.disabled = false;
+                buttonText.textContent = 'Classify Image';
+                spinner.classList.add('hidden');
+            }
+        });
+
+        analyzeButton.addEventListener('click', () => {
+            imageInput.value = '';
+            previewSection.classList.add('hidden');
+            uploadSection.classList.remove('hidden');
+            resultsSection.classList.add('hidden');
+            mainCard.classList.remove('hidden');
+            errorMessage.classList.add('hidden');
+        });
+
+        function displayResults(prediction) {
+            mainPrediction.textContent = prediction.predicted_class;
+            mainConfidence.textContent = `Confidence: ${prediction.confidence}%`;
+
+            predictionsList.innerHTML = '';
+            Object.entries(prediction.all_predictions).forEach(([className, confidence]) => {
+                const progressPercent = Math.round(confidence);
+                const barColor = className === prediction.predicted_class ? 'bg-purple-500' : 'bg-gray-300';
+                
+                const html = `
+                    <div>
+                        <div class="flex justify-between items-center mb-1">
+                            <span class="text-gray-700 font-medium">${className}</span>
+                            <span class="text-gray-600 text-sm">${progressPercent}%</span>
+                        </div>
+                        <div class="w-full bg-gray-200 rounded-full h-2">
+                            <div class="${barColor} h-2 rounded-full transition-all" style="width: ${progressPercent}%"></div>
+                        </div>
+                    </div>
+                `;
+                predictionsList.innerHTML += html;
+            });
+
+            mainCard.classList.add('hidden');
+            resultsSection.classList.remove('hidden');
+        }
+
+        function showError(message) {
+            errorMessage.textContent = message;
+            errorMessage.classList.remove('hidden');
+        }
+
+        const dropZone = document.querySelector('[for="imageInput"]');
+        ['dragenter', 'dragover', 'dragleave', 'drop'].forEach(eventName => {
+            dropZone.addEventListener(eventName, preventDefaults, false);
+        });
+
+        function preventDefaults(e) {
+            e.preventDefault();
+            e.stopPropagation();
+        }
+
+        dropZone.addEventListener('drop', (e) => {
+            const dt = e.dataTransfer;
+            const files = dt.files;
+            imageInput.files = files;
+            const event = new Event('change', { bubbles: true });
+            imageInput.dispatchEvent(event);
+        });
+    </script>
+</body>
+</html>