Upload 8 files

Dockerfile

@@ -0,0 +1,31 @@
+FROM python:3.10-slim
+
+# Set working directory
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential \
+    libssl-dev \
+    libffi-dev \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first for better caching
+COPY fastapi_app/requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application files
+COPY fastapi_app .
+
+# Create non-root user for security
+RUN useradd -m -u 1000 appuser && chown -R appuser:appuser /app
+USER appuser
+
+EXPOSE 8000
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=40s --retries=3 \
+    CMD python -c "import urllib.request; urllib.request.urlopen('http://localhost:8000/health')" || exit 1
+
+# Run the application
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8000"]

dockerignore

@@ -0,0 +1,36 @@
+# Include any files or directories that you don't want to be copied to your
+# container here (e.g., local build artifacts, temporary files, etc.).
+#
+# For more help, visit the .dockerignore file reference guide at
+# https://docs.docker.com/go/build-context-dockerignore/
+
+**/.DS_Store
+**/__pycache__
+**/.venv
+**/.classpath
+**/.dockerignore
+**/.env
+**/.git
+**/.gitignore
+**/.project
+**/.settings
+**/.toolstarget
+**/.vs
+**/.vscode
+**/*.*proj.user
+**/*.dbmdl
+**/*.jfm
+**/bin
+**/charts
+**/docker-compose*
+**/compose.y*ml
+**/Dockerfile*
+**/node_modules
+**/npm-debug.log
+**/obj
+**/secrets.dev.yaml
+**/values.dev.yaml
+LICENSE
+README.md
+**/.aws
+ml-models/

fastapi_app/app.py

@@ -0,0 +1,178 @@
+import logging
+import os
+import time
+import warnings
+from pathlib import Path
+
+import torch
+from fastapi import FastAPI, UploadFile, File, HTTPException
+from fastapi.responses import HTMLResponse
+from fastapi.templating import Jinja2Templates
+from fastapi.requests import Request
+from transformers import AutoImageProcessor, pipeline
+from PIL import Image
+import io
+
+from scripts.data_model import (
+    PoseClassificationResponse,
+    PosePrediction,
+)
+from scripts.s3 import download_model_from_s3
+from scripts.huggingface_load import download_model_from_huggingface
+
+# Toggle between S3 and Hugging Face model loading
+# Set USE_HUGGINGFACE_MODELS = False to use S3 loader (production)
+# Set USE_HUGGINGFACE_MODELS = True to use Hugging Face loader (Spaces deployment)
+USE_HUGGINGFACE_MODELS = True
+
+warnings.filterwarnings("ignore")
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Initialize FastAPI app
+app = FastAPI(
+    title="Pose Classification API",
+    description="ViT-based human pose classification service",
+    version="0.0.0",
+)
+
+# Setup templates
+template_dir = Path(__file__).parent / "templates"
+if template_dir.exists():
+    templates = Jinja2Templates(directory=str(template_dir))
+
+# Device selection
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+logger.info(f"Using device: {device}")
+
+# Model initialization
+MODEL_NAME = "vit-human-pose-classification"
+LOCAL_MODEL_PATH = f"ml-models/{MODEL_NAME}"
+FORCE_DOWNLOAD = False
+
+# Global model variables
+pose_model = None
+image_processor = None
+
+
+def initialize_model():
+    """Initialize the pose classification model."""
+    global pose_model, image_processor
+    
+    try:
+        logger.info("Initializing pose classification model...")
+        
+        # Download model if not present
+        if not os.path.isdir(LOCAL_MODEL_PATH) or FORCE_DOWNLOAD:
+            if USE_HUGGINGFACE_MODELS:
+                logger.info(f"Downloading model from Hugging Face to {LOCAL_MODEL_PATH}")
+                success = download_model_from_huggingface(LOCAL_MODEL_PATH)
+            else:
+                logger.info(f"Downloading model from S3 to {LOCAL_MODEL_PATH}")
+                success = download_model_from_s3(LOCAL_MODEL_PATH, f"{MODEL_NAME}/")
+            
+            if not success:
+                logger.error("Failed to download model")
+                return False
+        
+        # Load image processor
+        image_processor = AutoImageProcessor.from_pretrained(
+            LOCAL_MODEL_PATH,
+            use_fast=True,
+            local_files_only=True,
+        )
+        
+        # Load model pipeline
+        pose_model = pipeline(
+            "image-classification",
+            model=LOCAL_MODEL_PATH,
+            device=device,
+            image_processor=image_processor,
+        )
+        
+        logger.info("Model initialized successfully")
+        return True
+        
+    except Exception as e:
+        logger.error(f"Error initializing model: {e}")
+        return False
+
+
+@app.on_event("startup")
+async def startup_event():
+    """Initialize model on startup."""
+    if not initialize_model():
+        logger.warning("Model initialization failed, app will not be fully functional")
+
+
+@app.get("/", response_class=HTMLResponse)
+async def read_root(request: Request):
+    """Serve the main UI page."""
+    if template_dir.exists():
+        return templates.TemplateResponse("index.html", {"request": request})
+    return """
+    <!DOCTYPE html>
+    <html>
+    <head><title>Pose Classification</title></head>
+    <body><p>Template not found</p></body>
+    </html>
+    """
+
+
+@app.get("/health")
+async def health_check():
+    """Health check endpoint."""
+    if pose_model is not None:
+        return {"status": "healthy", "model_loaded": True}
+    return {"status": "unhealthy", "model_loaded": False}
+
+
+@app.post("/api/v1/classify")
+async def classify_pose(file: UploadFile = File(...)) -> PoseClassificationResponse:
+    """Classify pose from uploaded image.
+    
+    Args:
+        file: Image file to classify
+        
+    Returns:
+        PoseClassificationResponse with prediction results
+    """
+    if pose_model is None:
+        raise HTTPException(
+            status_code=503,
+            detail="Model not loaded. Please try again later.",
+        )
+    
+    try:
+        # Read and validate image
+        content = await file.read()
+        image = Image.open(io.BytesIO(content))
+        
+        # Run inference
+        start_time = time.time()
+        output = pose_model(image)
+        inference_time = int((time.time() - start_time) * 1000)
+        
+        # Extract top prediction
+        top_prediction = output[0]
+        
+        return PoseClassificationResponse(
+            prediction=PosePrediction(
+                label=top_prediction["label"],
+                score=round(top_prediction["score"], 4),
+            ),
+            prediction_time_ms=inference_time,
+        )
+        
+    except Exception as e:
+        logger.error(f"Error during inference: {e}")
+        raise HTTPException(
+            status_code=400,
+            detail=f"Error processing image: {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,14 @@
+fastapi==0.115.6
+uvicorn[standard]==0.34.0
+jinja2==3.1.5
+python-multipart==0.0.18
+boto3==1.34.149
+python-dotenv==1.0.0
+transformers==4.43.3
+huggingface-hub==0.23.0
+torch==2.3.1
+torchvision==0.18.1
+accelerate==0.33.0
+Pillow==10.2.0
+pydantic==2.8.2
+pydantic[email]==2.8.2

fastapi_app/scripts/data_model.py

@@ -0,0 +1,30 @@
+"""Data models for pose classification API."""
+
+from pydantic import BaseModel, Field
+
+
+class PoseClassificationRequest(BaseModel):
+    """Request body for pose classification endpoint."""
+    url: str = Field(
+        description="Image URL for classification"
+    )
+
+
+class PosePrediction(BaseModel):
+    """Single pose prediction result."""
+    label: str
+    score: float
+
+
+class PoseClassificationResponse(BaseModel):
+    """Response body for pose classification endpoint."""
+    model_name: str = "vit-human-pose-classification"
+    prediction: PosePrediction
+    prediction_time_ms: int = Field(
+        description="Time taken for inference in milliseconds"
+    )
+
+
+
+
+

fastapi_app/scripts/huggingface_load.py

@@ -0,0 +1,50 @@
+"""Hugging Face utilities for downloading ML models."""
+
+import os
+import logging
+from transformers import AutoImageProcessor, AutoModelForImageClassification
+from huggingface_hub.utils import RepositoryNotFoundError
+
+logger = logging.getLogger(__name__)
+
+HF_MODEL_ID = "codeby-hp/finetune-VIT-HumanPoseClassification"
+
+
+def download_model_from_huggingface(local_path: str) -> bool:
+    """Download model from Hugging Face Hub.
+    
+    Args:
+        local_path: Local directory path to save model
+        
+    Returns:
+        True if successful, False otherwise
+    """
+    try:
+        logger.info(f"Downloading model from Hugging Face: {HF_MODEL_ID}")
+        os.makedirs(local_path, exist_ok=True)
+        
+        # Download image processor
+        logger.info("Downloading image processor...")
+        image_processor = AutoImageProcessor.from_pretrained(
+            HF_MODEL_ID,
+            cache_dir=local_path,
+        )
+        image_processor.save_pretrained(local_path)
+        
+        # Download model
+        logger.info("Downloading model weights...")
+        model = AutoModelForImageClassification.from_pretrained(
+            HF_MODEL_ID,
+            cache_dir=local_path,
+        )
+        model.save_pretrained(local_path)
+        
+        logger.info(f"Successfully downloaded model to {local_path}")
+        return True
+        
+    except RepositoryNotFoundError as e:
+        logger.error(f"Model not found on Hugging Face Hub: {e}")
+        return False
+    except Exception as e:
+        logger.error(f"Error downloading model from Hugging Face: {e}")
+        return False

fastapi_app/templates/index.html

@@ -0,0 +1,215 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Pose Classification</title>
+    <script src="https://cdn.tailwindcss.com"></script>
+</head>
+<body class="bg-gradient-to-br from-slate-900 via-slate-800 to-slate-900 min-h-screen">
+    <div class="min-h-screen flex items-center justify-center px-4 py-12">
+        <div class="w-full max-w-md">
+            <!-- Header -->
+            <div class="text-center mb-8">
+                <h1 class="text-4xl font-bold text-white mb-2">Pose Classification</h1>
+                <p class="text-slate-400 text-sm">Upload an image to classify human poses</p>
+            </div>
+
+            <!-- Main Card -->
+            <div class="bg-slate-800 rounded-lg shadow-xl overflow-hidden border border-slate-700">
+                <!-- Upload Section -->
+                <div class="p-8">
+                    <form id="uploadForm" class="space-y-6">
+                        <!-- File Input -->
+                        <div class="relative">
+                            <input
+                                type="file"
+                                id="imageInput"
+                                accept="image/*"
+                                class="hidden"
+                                required
+                            >
+                            <label
+                                for="imageInput"
+                                class="flex items-center justify-center w-full px-4 py-6 border-2 border-dashed border-slate-600 rounded-lg cursor-pointer transition hover:border-blue-400 hover:bg-slate-700/50"
+                            >
+                                <div class="text-center">
+                                    <svg class="w-10 h-10 mx-auto mb-2 text-slate-400" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                                        <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M12 4v16m8-8H4"></path>
+                                    </svg>
+                                    <p class="text-slate-300 font-medium">Click to upload image</p>
+                                    <p class="text-slate-500 text-xs mt-1">PNG, JPG, JPEG up to 10MB</p>
+                                </div>
+                            </label>
+                        </div>
+
+                        <!-- Image Preview -->
+                        <div id="previewContainer" class="hidden">
+                            <img id="imagePreview" class="w-full h-64 object-cover rounded-lg" alt="Preview">
+                        </div>
+
+                        <!-- Submit Button -->
+                        <button
+                            type="submit"
+                            id="submitBtn"
+                            class="w-full bg-blue-600 hover:bg-blue-700 text-white font-semibold py-3 rounded-lg transition disabled:opacity-50 disabled:cursor-not-allowed"
+                            disabled
+                        >
+                            Classify Pose
+                        </button>
+                    </form>
+                </div>
+
+                <!-- Results Section -->
+                <div id="resultsContainer" class="hidden border-t border-slate-700 bg-slate-700/30 p-8">
+                    <h2 class="text-white font-semibold mb-4 text-lg">Classification Results</h2>
+                    
+                    <div class="space-y-4">
+                        <!-- Prediction -->
+                        <div class="bg-slate-800/50 rounded-lg p-4">
+                            <p class="text-slate-400 text-sm mb-1">Detected Pose</p>
+                            <p id="predictionLabel" class="text-white text-2xl font-bold">-</p>
+                        </div>
+
+                        <!-- Confidence -->
+                        <div class="bg-slate-800/50 rounded-lg p-4">
+                            <p class="text-slate-400 text-sm mb-2">Confidence</p>
+                            <div class="flex items-center space-x-3">
+                                <div class="flex-1 bg-slate-700 rounded-full h-2">
+                                    <div id="confidenceBar" class="bg-green-500 h-2 rounded-full transition-all" style="width: 0%"></div>
+                                </div>
+                                <p id="confidenceScore" class="text-white font-semibold min-w-fit">0%</p>
+                            </div>
+                        </div>
+
+                        <!-- Inference Time -->
+                        <div class="bg-slate-800/50 rounded-lg p-4">
+                            <p class="text-slate-400 text-sm mb-1">Inference Time</p>
+                            <p id="inferenceTime" class="text-white text-lg font-semibold">-</p>
+                        </div>
+                    </div>
+
+                    <!-- Reset Button -->
+                    <button
+                        onclick="resetForm()"
+                        class="w-full mt-6 bg-slate-700 hover:bg-slate-600 text-white font-semibold py-2 rounded-lg transition"
+                    >
+                        Classify Another Image
+                    </button>
+                </div>
+            </div>
+
+            <!-- Status Messages -->
+            <div id="loadingContainer" class="hidden mt-4 text-center">
+                <div class="inline-block">
+                    <div class="animate-spin h-8 w-8 border-4 border-blue-400 border-t-transparent rounded-full"></div>
+                </div>
+                <p class="text-slate-400 mt-2">Processing image...</p>
+            </div>
+
+            <div id="errorContainer" class="hidden mt-4 p-4 bg-red-900/30 border border-red-700 rounded-lg">
+                <p id="errorMessage" class="text-red-300 text-sm"></p>
+            </div>
+        </div>
+    </div>
+
+    <script>
+        const uploadForm = document.getElementById('uploadForm');
+        const imageInput = document.getElementById('imageInput');
+        const previewContainer = document.getElementById('previewContainer');
+        const imagePreview = document.getElementById('imagePreview');
+        const submitBtn = document.getElementById('submitBtn');
+        const loadingContainer = document.getElementById('loadingContainer');
+        const resultsContainer = document.getElementById('resultsContainer');
+        const errorContainer = document.getElementById('errorContainer');
+        const errorMessage = document.getElementById('errorMessage');
+
+        // Handle image selection
+        imageInput.addEventListener('change', function(e) {
+            const file = e.target.files[0];
+            if (file) {
+                // Validate file size (10MB)
+                if (file.size > 10 * 1024 * 1024) {
+                    showError('Image size must be less than 10MB');
+                    imageInput.value = '';
+                    submitBtn.disabled = true;
+                    return;
+                }
+
+                // Show preview
+                const reader = new FileReader();
+                reader.onload = function(event) {
+                    imagePreview.src = event.target.result;
+                    previewContainer.classList.remove('hidden');
+                    submitBtn.disabled = false;
+                    errorContainer.classList.add('hidden');
+                    resultsContainer.classList.add('hidden');
+                };
+                reader.readAsDataURL(file);
+            }
+        });
+
+        // Handle form submission
+        uploadForm.addEventListener('submit', async function(e) {
+            e.preventDefault();
+            
+            const file = imageInput.files[0];
+            if (!file) return;
+
+            // Show loading state
+            submitBtn.disabled = true;
+            loadingContainer.classList.remove('hidden');
+            resultsContainer.classList.add('hidden');
+            errorContainer.classList.add('hidden');
+
+            try {
+                const formData = new FormData();
+                formData.append('file', file);
+
+                const response = await fetch('/api/v1/classify', {
+                    method: 'POST',
+                    body: formData
+                });
+
+                if (!response.ok) {
+                    const error = await response.json();
+                    throw new Error(error.detail || 'Classification failed');
+                }
+
+                const data = await response.json();
+                displayResults(data);
+
+            } catch (error) {
+                showError(error.message || 'An error occurred during classification');
+            } finally {
+                submitBtn.disabled = false;
+                loadingContainer.classList.add('hidden');
+            }
+        });
+
+        function displayResults(data) {
+            const confidence = (data.prediction.score * 100).toFixed(1);
+            
+            document.getElementById('predictionLabel').textContent = data.prediction.label;
+            document.getElementById('confidenceScore').textContent = confidence + '%';
+            document.getElementById('confidenceBar').style.width = confidence + '%';
+            document.getElementById('inferenceTime').textContent = data.prediction_time_ms + ' ms';
+            
+            resultsContainer.classList.remove('hidden');
+        }
+
+        function showError(message) {
+            errorMessage.textContent = message;
+            errorContainer.classList.remove('hidden');
+        }
+
+        function resetForm() {
+            imageInput.value = '';
+            previewContainer.classList.add('hidden');
+            resultsContainer.classList.add('hidden');
+            errorContainer.classList.add('hidden');
+            submitBtn.disabled = true;
+        }
+    </script>
+</body>
+</html>