Merge branch 'master' into 'main'

initial commit

See merge request ul-dsri/sandbox/sachin-sharma-in/ml-inference-service!1

.python-version

@@ -0,0 +1 @@
+3.12.11

app/__init__.py

@@ -0,0 +1,7 @@
+"""
+ML Inference Service
+
+A FastAPI-based web service for machine learning model inference.
+"""
+
+__version__ = "0.1.0"

app/api/__init__.py

@@ -0,0 +1 @@
+"""API layer for the ML inference service."""

app/api/controllers.py

@@ -0,0 +1,75 @@
+"""
+Controllers for handling API business logic.
+"""
+import base64
+import io
+
+from fastapi import HTTPException
+from PIL import Image
+
+from app.core.logging import logger
+from app.services.inference import ResNetInferenceService
+from app.api.models import ImageRequest, PredictionResponse
+
+
+class PredictionController:
+    """Controller for ML prediction endpoints."""
+
+    @staticmethod
+    async def predict_resnet(
+            request: ImageRequest,
+            resnet_service: ResNetInferenceService
+    ) -> PredictionResponse:
+        """
+        Classify an image using ResNet-18 from base64 encoded data.
+        """
+        try:
+            # Validate service availability
+            if not resnet_service:
+                raise HTTPException(
+                    status_code=503,
+                    detail="Service not initialized"
+                )
+
+            # Validate media type
+            if not request.image.mediaType.startswith('image/'):
+                raise HTTPException(
+                    status_code=400,
+                    detail=f"Invalid media type: {request.image.mediaType}"
+                )
+
+            # Decode base64 image data
+            try:
+                image_data = base64.b64decode(request.image.data)
+            except Exception as decode_error:
+                raise HTTPException(
+                    status_code=400,
+                    detail=f"Invalid base64 data: {str(decode_error)}"
+                )
+
+            # Load and validate image
+            try:
+                image = Image.open(io.BytesIO(image_data))
+            except Exception as img_error:
+                raise HTTPException(
+                    status_code=400,
+                    detail=f"Invalid image file: {str(img_error)}"
+                )
+
+            # Perform prediction
+            result = resnet_service.predict(image)
+
+            # Return structured response
+            return PredictionResponse(
+                prediction=result["prediction"],
+                confidence=result["confidence"],
+                model=result["model"],
+                predicted_label=result["predicted_label"],
+                mediaType=request.image.mediaType
+            )
+
+        except HTTPException:
+            raise
+        except Exception as e:
+            logger.error(f"Prediction failed: {e}")
+            raise HTTPException(status_code=500, detail=str(e))

app/api/models.py

@@ -0,0 +1,24 @@
+"""
+Pydantic models for request/response validation.
+"""
+from pydantic import BaseModel
+
+
+class ImageData(BaseModel):
+    """Image data model for base64 encoded images."""
+    mediaType: str
+    data: str
+
+
+class ImageRequest(BaseModel):
+    """Request model for image classification."""
+    image: ImageData
+
+
+class PredictionResponse(BaseModel):
+    """Response model for image classification results."""
+    prediction: str
+    confidence: float
+    model: str
+    predicted_label: int
+    mediaType: str

app/api/routes/__init__.py

@@ -0,0 +1 @@
+"""API route definitions."""

app/api/routes/prediction.py

@@ -0,0 +1,20 @@
+"""
+ML Prediction routes.
+"""
+from fastapi import APIRouter, Depends
+
+from app.api.controllers import PredictionController
+from app.api.models import ImageRequest, PredictionResponse
+from app.core.dependencies import get_resnet_service
+from app.services.inference import ResNetInferenceService
+
+router = APIRouter()
+
+
+@router.post("/predict/resnet", response_model=PredictionResponse)
+async def predict_image(
+    request: ImageRequest,
+    resnet_service: ResNetInferenceService = Depends(get_resnet_service)
+):
+    """Classify an image using ResNet-18 from base64 encoded data."""
+    return await PredictionController.predict_resnet(request, resnet_service)

app/api/routes/resnet_service_manager.py

@@ -0,0 +1,19 @@
+# """
+# Dependency injection for FastAPI.
+# """
+# from typing import Optional
+# from app.services.inference import ResNetInferenceService
+#
+# # Global service instance
+# _resnet_service: Optional[ResNetInferenceService] = None
+#
+#
+# def get_resnet_service() -> Optional[ResNetInferenceService]:
+#     """Get the ResNet service instance."""
+#     return _resnet_service
+#
+#
+# def set_resnet_service(service: ResNetInferenceService) -> None:
+#     """Set the global ResNet service instance."""
+#     global _resnet_service
+#     _resnet_service = service

app/core/__init__.py

@@ -0,0 +1 @@
+"""Core utilities and configurations."""

app/core/app.py

@@ -0,0 +1,25 @@
+"""
+FastAPI application factory.
+"""
+from fastapi import FastAPI
+
+from app.core.config import settings
+from app.core.lifespan import lifespan
+from app.api.routes import prediction
+
+
+def create_app() -> FastAPI:
+    """Application factory."""
+
+    app = FastAPI(
+        title=settings.app_name,
+        description="ML inference service for image classification",
+        version=settings.app_version,
+        debug=settings.debug,
+        lifespan=lifespan
+    )
+
+    # Include only prediction router
+    app.include_router(prediction.router)
+
+    return app

app/core/config.py

@@ -0,0 +1,30 @@
+"""
+Basic configuration management.
+
+Starting simple - just app settings. We'll expand as needed.
+"""
+
+from typing import Optional
+from pydantic import Field
+from pydantic_settings import BaseSettings  # Changed import
+
+
+class Settings(BaseSettings):
+    """Application settings with environment variable support."""
+
+    # Basic app settings
+    app_name: str = Field(default="ML Inference Service", description="Application name")
+    app_version: str = Field(default="0.1.0", description="Application version")
+    debug: bool = Field(default=False, description="Debug mode")
+
+    # Server settings
+    host: str = Field(default="0.0.0.0", description="Server host")
+    port: int = Field(default=8000, description="Server port")
+
+    class Config:
+        """Load from .env file if it exists."""
+        env_file = ".env"
+
+
+# Global settings instance
+settings = Settings()

app/core/dependencies.py

@@ -0,0 +1,19 @@
+"""
+Dependency injection for FastAPI.
+"""
+from typing import Optional
+from app.services.inference import ResNetInferenceService
+
+# Global service instance
+_resnet_service: Optional[ResNetInferenceService] = None
+
+
+def get_resnet_service() -> Optional[ResNetInferenceService]:
+    """Get the ResNet service instance."""
+    return _resnet_service
+
+
+def set_resnet_service(service: ResNetInferenceService) -> None:
+    """Set the global ResNet service instance."""
+    global _resnet_service
+    _resnet_service = service

app/core/lifespan.py

@@ -0,0 +1,43 @@
+"""
+Application lifespan management.
+"""
+import warnings
+from contextlib import asynccontextmanager
+from typing import AsyncGenerator
+
+from fastapi import FastAPI
+
+from app.core.logging import logger
+from app.core.dependencies import set_resnet_service
+from app.services.inference import ResNetInferenceService
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
+    """Application lifespan manager."""
+
+    # Startup
+    logger.info("Starting ML Inference Service...")
+
+    try:
+        with warnings.catch_warnings():
+            warnings.filterwarnings("ignore", category=FutureWarning)
+
+            # Initialize and load ResNet service
+            resnet_service = ResNetInferenceService(
+                model_name="microsoft/resnet-18",
+                use_local_model=True
+            )
+            resnet_service.load_model()
+            set_resnet_service(resnet_service)
+
+        logger.info("Startup completed successfully")
+
+    except Exception as e:
+        logger.error(f"Startup failed: {e}")
+        raise
+
+    yield  # App runs here
+
+    # Shutdown
+    logger.info("Shutting down...")

app/core/logging.py

@@ -0,0 +1,49 @@
+"""
+Logging configuration for the application.
+"""
+
+import logging
+import sys
+from typing import Optional
+
+from app.core.config import settings
+
+
+class LoggerSetup:
+    """Logger setup utility class."""
+
+    @staticmethod
+    def setup_logging(
+            logger_name: Optional[str] = None,
+            level: Optional[str] = None,
+            format_string: Optional[str] = None
+    ) -> logging.Logger:
+        """Set up and configure a logger."""
+        logger = logging.getLogger(logger_name or settings.app_name)
+
+        # Avoid duplicate handlers
+        if logger.handlers:
+            return logger
+
+        # Set level
+        log_level = getattr(logging, (level or "INFO").upper())
+        logger.setLevel(log_level)
+
+        # Create console handler
+        handler = logging.StreamHandler(sys.stdout)
+        handler.setLevel(log_level)
+
+        # Create formatter
+        formatter = logging.Formatter(
+            format_string or "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+        )
+        handler.setFormatter(formatter)
+
+        # Add handler to logger
+        logger.addHandler(handler)
+
+        return logger
+
+
+# Create application logger
+logger = LoggerSetup.setup_logging()

app/services/__init__.py

@@ -0,0 +1 @@
+"""Business logic services."""

app/services/inference.py

@@ -0,0 +1,152 @@
+"""
+Inference service for machine learning models.
+
+This service handles the business logic for ML inference,
+following the Single Responsibility Principle.
+"""
+import os
+from typing import Dict, Any
+import torch
+from PIL import Image
+from transformers import AutoImageProcessor, ResNetForImageClassification
+
+from app.core.logging import logger
+
+
+class ResNetInferenceService:
+    """
+    ResNet inference service.
+
+    Handles loading and inference for ResNet models.
+    Follows the Singleton pattern - loads model once.
+    """
+
+    def __init__(self, model_name: str = "microsoft/resnet-18", use_local_model: bool = True):
+        """
+        Initialize the ResNet service.
+
+        Args:
+            model_name: HuggingFace model identifier
+        """
+        self.model_name = model_name
+        self.use_local_model = use_local_model
+        self.model = None
+        self.processor = None
+        self._is_loaded = False
+
+        if use_local_model:
+            self.model_path = os.path.join("models", model_name.split("/")[-1])
+            logger.info(f"Initializing ResNet service with local model: {self.model_path}")
+        else:
+            self.model_path = model_name
+            logger.info(f"Initializing ResNet service with remote model: {model_name}")
+
+    def load_model(self) -> None:
+        """
+        Load the ResNet model and processor.
+
+        This method loads the model once and reuses it for all requests.
+        """
+        if self._is_loaded:
+            logger.debug("Model already loaded, skipping...")
+            return
+
+        try:
+            if self.use_local_model:
+                if not os.path.exists(self.model_path):
+                    raise FileNotFoundError(f"Local model directory not found: {self.model_path}")
+
+                config_path = os.path.join(self.model_path, "config.json")
+                if not os.path.exists(config_path):
+                    raise FileNotFoundError(f"Model config not found: {config_path}")
+
+                logger.info(f"Loading ResNet model from local directory: {self.model_path}")
+            else:
+                logger.info(f"Loading ResNet model from HuggingFace Hub: {self.model_name}")
+
+            # Suppress warnings during model loading
+            import warnings
+            with warnings.catch_warnings():
+                warnings.filterwarnings("ignore", category=FutureWarning)
+                warnings.filterwarnings("ignore", message="Could not find image processor class")
+
+                # Load processor and model from local directory or remote
+                self.processor = AutoImageProcessor.from_pretrained(
+                    self.model_path,
+                    local_files_only=self.use_local_model
+                )
+                self.model = ResNetForImageClassification.from_pretrained(
+                    self.model_path,
+                    local_files_only=self.use_local_model
+                )
+
+
+            self._is_loaded = True
+            logger.info("ResNet model loaded successfully")
+            logger.info(f"Model architecture: {self.model.config.architectures}")
+            logger.info(f"Model has {len(self.model.config.id2label)} classes")
+
+        except Exception as e:
+            logger.error(f"Failed to load ResNet model: {e}")
+            if self.use_local_model:
+                logger.error("Hint: Make sure the model was downloaded correctly with dwl.bash")
+            raise
+
+
+    def predict(self, image: Image.Image) -> Dict[str, Any]:
+        """
+        Perform inference on an image.
+
+        Args:
+            image: PIL Image to classify
+
+        Returns:
+            Dictionary containing prediction results
+
+        Raises:
+            RuntimeError: If model is not loaded
+            ValueError: If image processing fails
+        """
+        if not self._is_loaded:
+            logger.info("Model not loaded, loading now...")
+            self.load_model()
+
+        try:
+            logger.debug("Starting ResNet inference")
+
+            if image.mode != 'RGB':
+                image = image.convert('RGB')
+                logger.debug(f"Converted image from {image.mode} to RGB")
+
+            inputs = self.processor(image, return_tensors="pt")
+
+            # Perform inference
+            with torch.no_grad():
+                logits = self.model(**inputs).logits
+
+            # Get prediction
+            predicted_label = logits.argmax(-1).item()
+            predicted_class = self.model.config.id2label[predicted_label]
+
+            # Calculate confidence score
+            probabilities = torch.nn.functional.softmax(logits, dim=-1)
+            confidence = probabilities[0][predicted_label].item()
+
+            result = {
+                "prediction": predicted_class,
+                "confidence": round(confidence, 4),
+                "model": self.model_name,
+                "predicted_label": predicted_label
+            }
+
+            logger.debug(f"Inference completed: {predicted_class} (confidence: {confidence:.4f})")
+            return result
+
+        except Exception as e:
+            logger.error(f"Inference failed: {e}")
+            raise ValueError(f"Failed to process image: {str(e)}")
+
+    @property
+    def is_loaded(self) -> bool:
+        """Check if model is loaded."""
+        return self._is_loaded

main.py

@@ -0,0 +1,6 @@
+"""
+Main FastAPI application entry point.
+"""
+from app.core.app import create_app
+
+app = create_app()

requirements.in

@@ -0,0 +1,16 @@
+# Web framework
+fastapi==0.104.1
+uvicorn[standard]==0.24.0
+
+# Configuration management
+pydantic==2.5.0
+pydantic-settings==2.0.3
+python-dotenv==0.21.0
+
+# File upload handling
+python-multipart==0.0.6
+
+# ML/AI dependencies (newly added)
+transformers>=4.35.0
+torch>=2.4.0  # Newer PyTorch with NumPy 2.x support
+pillow>=10.0.0

requirements.txt

@@ -0,0 +1,161 @@
+# This file was autogenerated by uv via the following command:
+#    uv pip compile requirements.in -o requirements.txt
+annotated-types==0.7.0
+    # via pydantic
+anyio==3.7.1
+    # via
+    #   fastapi
+    #   starlette
+    #   watchfiles
+certifi==2025.8.3
+    # via requests
+charset-normalizer==3.4.3
+    # via requests
+click==8.2.1
+    # via uvicorn
+fastapi==0.104.1
+    # via -r requirements.in
+filelock==3.19.1
+    # via
+    #   huggingface-hub
+    #   torch
+    #   transformers
+fsspec==2025.7.0
+    # via
+    #   huggingface-hub
+    #   torch
+h11==0.16.0
+    # via uvicorn
+hf-xet==1.1.8
+    # via huggingface-hub
+httptools==0.6.4
+    # via uvicorn
+huggingface-hub==0.34.4
+    # via
+    #   tokenizers
+    #   transformers
+idna==3.10
+    # via
+    #   anyio
+    #   requests
+jinja2==3.1.6
+    # via torch
+markupsafe==3.0.2
+    # via jinja2
+mpmath==1.3.0
+    # via sympy
+networkx==3.5
+    # via torch
+numpy==2.3.2
+    # via transformers
+nvidia-cublas-cu12==12.8.4.1
+    # via
+    #   nvidia-cudnn-cu12
+    #   nvidia-cusolver-cu12
+    #   torch
+nvidia-cuda-cupti-cu12==12.8.90
+    # via torch
+nvidia-cuda-nvrtc-cu12==12.8.93
+    # via torch
+nvidia-cuda-runtime-cu12==12.8.90
+    # via torch
+nvidia-cudnn-cu12==9.10.2.21
+    # via torch
+nvidia-cufft-cu12==11.3.3.83
+    # via torch
+nvidia-cufile-cu12==1.13.1.3
+    # via torch
+nvidia-curand-cu12==10.3.9.90
+    # via torch
+nvidia-cusolver-cu12==11.7.3.90
+    # via torch
+nvidia-cusparse-cu12==12.5.8.93
+    # via
+    #   nvidia-cusolver-cu12
+    #   torch
+nvidia-cusparselt-cu12==0.7.1
+    # via torch
+nvidia-nccl-cu12==2.27.3
+    # via torch
+nvidia-nvjitlink-cu12==12.8.93
+    # via
+    #   nvidia-cufft-cu12
+    #   nvidia-cusolver-cu12
+    #   nvidia-cusparse-cu12
+    #   torch
+nvidia-nvtx-cu12==12.8.90
+    # via torch
+packaging==25.0
+    # via
+    #   huggingface-hub
+    #   transformers
+pillow==10.1.0
+    # via -r requirements.in
+pydantic==2.5.0
+    # via
+    #   -r requirements.in
+    #   fastapi
+    #   pydantic-settings
+pydantic-core==2.14.1
+    # via pydantic
+pydantic-settings==2.0.3
+    # via -r requirements.in
+python-dotenv==0.21.0
+    # via
+    #   -r requirements.in
+    #   pydantic-settings
+    #   uvicorn
+python-multipart==0.0.6
+    # via -r requirements.in
+pyyaml==6.0.2
+    # via
+    #   huggingface-hub
+    #   transformers
+    #   uvicorn
+regex==2025.7.34
+    # via transformers
+requests==2.32.5
+    # via
+    #   huggingface-hub
+    #   transformers
+safetensors==0.6.2
+    # via transformers
+setuptools==80.9.0
+    # via
+    #   torch
+    #   triton
+sniffio==1.3.1
+    # via anyio
+starlette==0.27.0
+    # via fastapi
+sympy==1.14.0
+    # via torch
+tokenizers==0.15.2
+    # via transformers
+torch==2.8.0
+    # via -r requirements.in
+tqdm==4.67.1
+    # via
+    #   huggingface-hub
+    #   transformers
+transformers==4.35.2
+    # via -r requirements.in
+triton==3.4.0
+    # via torch
+typing-extensions==4.15.0
+    # via
+    #   fastapi
+    #   huggingface-hub
+    #   pydantic
+    #   pydantic-core
+    #   torch
+urllib3==2.5.0
+    # via requests
+uvicorn==0.24.0
+    # via -r requirements.in
+uvloop==0.21.0
+    # via uvicorn
+watchfiles==1.1.0
+    # via uvicorn
+websockets==15.0.1
+    # via uvicorn

scripts/model_download.bash

@@ -0,0 +1,8 @@
+python - <<'PY'
+from huggingface_hub import snapshot_download
+snapshot_download(
+    repo_id="microsoft/resnet-18",
+    local_dir="models/resnet-18",
+    local_dir_use_symlinks=False # copies files; safer for containers
+)
+PY

test_main.http

@@ -0,0 +1,11 @@
+# Test ResNet Prediction Endpoint
+
+POST http://127.0.0.1:8000/predict/resnet
+Content-Type: application/json
+
+{
+  "image": {
+    "mediaType": "image/jpeg",
+    "data": "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"
+    }
+}