Upload folder using huggingface_hub

.dockerignore

@@ -0,0 +1,38 @@
+__pycache__
+*.pyc
+*.pyo
+*.pyd
+.Python
+*.so
+*.egg
+*.egg-info
+dist
+build
+
+.venv
+venv
+ENV
+env
+
+.git
+.gitignore
+.idea
+.vscode
+.claude
+
+*.md
+README.md
+Dockerfile
+.dockerignore
+
+test_*.http
+test_results
+scripts/test_datasets
+
+.pytest_cache
+.coverage
+htmlcov
+
+*.log
+.DS_Store
+.python-version

.env.example

@@ -0,0 +1,11 @@
+# App Configuration
+APP_NAME="ML Inference Service"
+APP_VERSION="0.1.0"
+DEBUG=false
+
+# Server
+HOST="0.0.0.0"
+PORT=8000
+
+# Model
+MODEL_NAME="microsoft/resnet-18"

.gitignore

@@ -0,0 +1,2 @@
+models/
+venv/

.python-version

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

Dockerfile

@@ -0,0 +1,26 @@
+FROM python:3.12-slim as builder
+
+WORKDIR /build
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir --user -r requirements.txt
+
+FROM python:3.12-slim
+
+WORKDIR /app
+
+RUN useradd -m -u 1000 appuser
+
+COPY --from=builder --chown=appuser:appuser /root/.local /home/appuser/.local
+COPY --chown=appuser:appuser app ./app
+COPY --chown=appuser:appuser models ./models
+COPY --chown=appuser:appuser main.py .
+
+USER appuser
+
+ENV PATH=/home/appuser/.local/bin:$PATH \
+    PYTHONUNBUFFERED=1
+
+EXPOSE 8000
+
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

README.md

@@ -1,10 +1,380 @@
 ---
-title: Safe Challenge Example
-emoji: 😻
-colorFrom: gray
-colorTo: pink
+title: SAFE Challenge Example Submission
+emoji: 🔒
+colorFrom: blue
+colorTo: purple
 sdk: docker
 pinned: false
+license: apache-2.0
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+license: apache-2.0
+---
+
+# ML Inference Service
+
+FastAPI service for serving ML models over HTTP. Comes with ResNet-18 for image classification out of the box, but you can swap in any model you want.
+
+## Quick Start
+
+**Local development:**
+```bash
+# Install dependencies
+python -m venv .venv
+source .venv/bin/activate
+pip install -r requirements.txt
+
+# Download the example model
+bash scripts/model_download.bash
+
+# Run it
+uvicorn main:app --reload
+```
+
+Server runs on `http://127.0.0.1:8000`. Check `/docs` for the interactive API documentation.
+
+**Docker:**
+```bash
+# Build
+docker build -t ml-inference-service:test .
+
+# Run
+docker run -d --name ml-inference-test -p 8000:8000 ml-inference-service:test
+
+# Check logs
+docker logs -f ml-inference-test
+
+# Stop
+docker stop ml-inference-test && docker rm ml-inference-test
+```
+
+## Testing the API
+
+```bash
+# Using curl
+curl -X POST http://localhost:8000/predict \
+  -H "Content-Type: application/json" \
+  -d '{
+    "image": {
+      "mediaType": "image/jpeg",
+      "data": "<base64-encoded-image>"
+    }
+  }'
+```
+
+Example response:
+```json
+{
+  "prediction": "tiger cat",
+  "confidence": 0.394,
+  "predicted_label": 282,
+  "model": "microsoft/resnet-18",
+  "mediaType": "image/jpeg"
+}
+```
+
+## Project Structure
+
+```
+ml-inference-service/
+├── main.py                      # Entry point
+├── app/
+│   ├── core/
+│   │   ├── app.py               # App factory, config, DI, lifecycle
+│   │   └── logging.py           # Logging setup
+│   ├── api/
+│   │   ├── models.py            # Request/response schemas
+│   │   ├── controllers.py       # Business logic
+│   │   └── routes/
+│   │       └── prediction.py    # POST /predict
+│   └── services/
+│       ├── base.py              # Abstract InferenceService class
+│       └── inference.py         # ResNet implementation
+├── models/
+│   └── microsoft/
+│       └── resnet-18/           # Model weights and config
+├── scripts/
+│   ├── model_download.bash
+│   ├── generate_test_datasets.py
+│   └── test_datasets.py
+├── Dockerfile                   # Multi-stage build
+├── .env.example                 # Environment config template
+└── requirements.txt
+```
+
+The key design decision here is that `app/core/app.py` consolidates everything—config, dependency injection, lifecycle, and the app factory. This avoids the mess of managing global state across multiple files.
+
+## How to Plug In Your Own Model
+
+The whole service is built around one abstract base class: `InferenceService`. Implement it for your model, and everything else just works.
+
+### Step 1: Create Your Service Class
+
+```python
+# app/services/your_model_service.py
+from app.services.base import InferenceService
+from app.api.models import ImageRequest, PredictionResponse
+import asyncio
+
+class YourModelService(InferenceService[ImageRequest, PredictionResponse]):
+    def __init__(self, model_name: str):
+        self.model_name = model_name
+        self.model_path = f"models/{model_name}"
+        self.model = None
+        self._is_loaded = False
+
+    async def load_model(self) -> None:
+        """Load your model here. Called once at startup."""
+        self.model = load_your_model(self.model_path)
+        self._is_loaded = True
+
+    async def predict(self, request: ImageRequest) -> PredictionResponse:
+        """Run inference. Offload heavy work to thread pool."""
+        return await asyncio.to_thread(self._predict_sync, request)
+
+    def _predict_sync(self, request: ImageRequest) -> PredictionResponse:
+        """Actual inference happens here."""
+        image = decode_base64_image(request.image.data)
+        result = self.model(image)
+
+        return PredictionResponse(
+            prediction=result.label,
+            confidence=result.confidence,
+            predicted_label=result.class_id,
+            model=self.model_name,
+            mediaType=request.image.mediaType
+        )
+
+    @property
+    def is_loaded(self) -> bool:
+        return self._is_loaded
+```
+
+**Important:** Use `asyncio.to_thread()` to run CPU-heavy inference in a background thread. This keeps the server responsive while your model is working.
+
+### Step 2: Register Your Service
+
+Open `app/core/app.py` and find the lifespan function:
+
+```python
+# Change this line:
+service = ResNetInferenceService(model_name="microsoft/resnet-18")
+
+# To this:
+service = YourModelService(model_name="your-org/your-model")
+```
+
+That's it. The `/predict` endpoint now serves your model.
+
+### Model Files
+
+Put your model files under `models/` with the full org/model structure:
+
+```
+models/
+└── your-org/
+    └── your-model/
+        ├── config.json
+        ├── weights.bin
+        └── (other files)
+```
+
+No renaming, no dropping the org prefix—it just mirrors the Hugging Face structure.
+
+## Configuration
+
+Settings are managed via environment variables or a `.env` file. See `.env.example` for all available options.
+
+**Default values:**
+- `APP_NAME`: "ML Inference Service"
+- `APP_VERSION`: "0.1.0"
+- `DEBUG`: false
+- `HOST`: "0.0.0.0"
+- `PORT`: 8000
+- `MODEL_NAME`: "microsoft/resnet-18"
+
+**To customize:**
+```bash
+# Copy the example
+cp .env.example .env
+
+# Edit values
+vim .env
+```
+
+Or set environment variables directly:
+```bash
+export MODEL_NAME="google/vit-base-patch16-224"
+uvicorn main:app --reload
+```
+
+## Deployment
+
+**Development:**
+```bash
+uvicorn main:app --reload
+```
+
+**Production:**
+```bash
+gunicorn main:app -w 4 -k uvicorn.workers.UvicornWorker --bind 0.0.0.0:8000
+```
+
+The service runs on CPU by default. For GPU inference, install CUDA-enabled PyTorch and modify your service to move tensors to the GPU device.
+
+**Docker:**
+- Multi-stage build keeps the image small
+- Runs as non-root user (`appuser`)
+- Python dependencies installed in user site-packages
+- Model files baked into the image
+
+## What Happens When You Start the Server
+
+```
+INFO: Starting ML Inference Service...
+INFO: Initializing ResNet service: models/microsoft/resnet-18
+INFO: Loading model from models/microsoft/resnet-18
+INFO: Model loaded: 1000 classes
+INFO: Startup completed successfully
+INFO: Uvicorn running on http://0.0.0.0:8000
+```
+
+If you see "Model directory not found", check that your model files exist at the expected path with the full org/model structure.
+
+## API Reference
+
+**Endpoint:** `POST /predict`
+
+**Request:**
+```json
+{
+  "image": {
+    "mediaType": "image/jpeg",  // or "image/png"
+    "data": "<base64-encoded-image>"
+  }
+}
+```
+
+**Response:**
+```json
+{
+  "prediction": "string",      // Human-readable label
+  "confidence": 0.0,           // Softmax probability
+  "predicted_label": 0,        // Numeric class index
+  "model": "org/model-name",   // Model identifier
+  "mediaType": "image/jpeg"    // Echoed from request
+}
+```
+
+**Docs:**
+- Swagger UI: `http://localhost:8000/docs`
+- ReDoc: `http://localhost:8000/redoc`
+- OpenAPI JSON: `http://localhost:8000/openapi.json`
+
+## PyArrow Test Datasets
+
+We've included a test dataset system for validating your model. It generates 100 standardized test cases covering normal inputs, edge cases, performance benchmarks, and model comparisons.
+
+### Generate Datasets
+
+```bash
+python scripts/generate_test_datasets.py
+```
+
+This creates:
+- `scripts/test_datasets/*.parquet` - Test data (images, requests, expected responses)
+- `scripts/test_datasets/*_metadata.json` - Human-readable descriptions
+- `scripts/test_datasets/datasets_summary.json` - Overview of all datasets
+
+### Run Tests
+
+```bash
+# Start your service first
+uvicorn main:app --reload
+
+# Quick test (5 samples per dataset)
+python scripts/test_datasets.py --quick
+
+# Full validation
+python scripts/test_datasets.py
+
+# Test specific category
+python scripts/test_datasets.py --category edge_case
+```
+
+### Dataset Categories (25 datasets each)
+
+**1. Standard Tests** (`standard_test_*.parquet`)
+- Normal images: random patterns, shapes, gradients
+- Common sizes: 224x224, 256x256, 299x299, 384x384
+- Formats: JPEG, PNG
+- Purpose: Baseline validation
+
+**2. Edge Cases** (`edge_case_*.parquet`)
+- Tiny images (32x32, 1x1)
+- Huge images (2048x2048)
+- Extreme aspect ratios (1000x50)
+- Corrupted data, malformed requests
+- Purpose: Test error handling
+
+**3. Performance Benchmarks** (`performance_test_*.parquet`)
+- Batch sizes: 1, 5, 10, 25, 50, 100 images
+- Latency and throughput tracking
+- Purpose: Performance profiling
+
+**4. Model Comparisons** (`model_comparison_*.parquet`)
+- Same inputs across different architectures
+- Models: ResNet-18/50, ViT, ConvNext, Swin
+- Purpose: Cross-model benchmarking
+
+### Test Output
+
+```
+DATASET TESTING SUMMARY
+============================================================
+Datasets tested: 100
+Successful datasets: 95
+Failed datasets: 5
+Total samples: 1,247
+Overall success rate: 87.3%
+Test duration: 45.2s
+
+Performance:
+  Avg latency: 123.4ms
+  Median latency: 98.7ms
+  p95 latency: 342.1ms
+  Max latency: 2,341.0ms
+  Requests/sec: 27.6
+
+Category breakdown:
+  standard: 25 datasets, 94.2% avg success
+  edge_case: 25 datasets, 76.8% avg success
+  performance: 25 datasets, 91.1% avg success
+  model_comparison: 25 datasets, 89.3% avg success
+```
+
+## Common Issues
+
+**Port 8000 already in use:**
+```bash
+# Find what's using it
+lsof -i :8000
+
+# Or just use a different port
+uvicorn main:app --port 8080
+```
+
+**Model not loading:**
+- Check the path: models should be in `models/<org>/<model-name>/`
+- Make sure you ran `bash scripts/model_download.bash`
+- Check logs for the exact error
+
+**Slow inference:**
+- Inference runs on CPU by default
+- For GPU: install CUDA PyTorch and modify service to use GPU device
+- Consider using smaller models or quantization
+
+## License
+
+Apache 2.0

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,36 @@
+"""API controllers for request handling and validation."""
+
+import asyncio
+from fastapi import HTTPException
+
+from app.core.logging import logger
+from app.services.base import InferenceService
+from app.api.models import ImageRequest, PredictionResponse
+
+
+class PredictionController:
+    """Controller for prediction endpoints."""
+
+    @staticmethod
+    async def predict(
+        request: ImageRequest,
+        service: InferenceService
+    ) -> PredictionResponse:
+        """Run inference using the configured service."""
+        try:
+            if not service or not service.is_loaded:
+                raise HTTPException(503, "Service not available")
+
+            if not request.image.mediaType.startswith('image/'):
+                raise HTTPException(400, f"Invalid media type: {request.image.mediaType}")
+
+            return await asyncio.to_thread(service.predict, request)
+
+        except HTTPException:
+            raise
+        except ValueError as e:
+            logger.error(f"Invalid input: {e}")
+            raise HTTPException(400, str(e))
+        except Exception as e:
+            logger.error(f"Prediction failed: {e}")
+            raise HTTPException(500, "Internal server error")

app/api/models.py

@@ -0,0 +1,85 @@
+"""
+Pydantic models for request/response validation.
+"""
+import enum
+from typing import Optional
+
+import pydantic
+
+
+class ImageData(pydantic.BaseModel):
+    """Image data model for base64 encoded images."""
+    mediaType: str
+    data: str
+
+
+class ImageRequest(pydantic.BaseModel):
+    """Request model for image classification."""
+    image: ImageData
+
+
+class Labels(enum.IntEnum):
+    Natural = 0
+    FullySynthesized = 1
+    LocallyEdited = 2
+    LocallySynthesized = 3
+
+
+class LocalizationMask(pydantic.BaseModel):
+    """A bit mask indicating which pixels are manipulated / synthesized.
+
+    A bit value of ``1`` means that the model believes the corresponding pixel
+    has been edited or synthesized (i.e., its label would be non-zero).
+    A bit value of ``0`` means that the model believes the pixel is unaltered.
+
+    The mask ``.width`` and ``.height`` should be the same as the input image.
+    Extra bits at the end of ``.bitsRowMajor`` after the first
+    ``width * height`` bits are **ignored**; for simplicity/efficiency,
+    you should encode your bit mask into a byte array and not worry if the
+    final byte isn't "full", then convert the byte array to base64.
+    """
+
+    width: int = pydantic.Field(
+        description="The width of the mask."
+    )
+
+    height: int = pydantic.Field(
+        description="The height of the mask."
+    )
+    
+    bitsRowMajor: str = pydantic.Field(
+        description="A base64 string encoding the bit mask in row-major order.",
+        # Canonical base64 encoding
+        # https://stackoverflow.com/a/64467300/3709935
+        pattern=r"^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/][AQgw]==|[A-Za-z0-9+/]{2}[AEIMQUYcgkosw048]=)?$",
+    )
+
+
+class PredictionResponse(pydantic.BaseModel):
+    """Response model for synthetic image classification results.
+    
+    Detector models will be scored primarily on their ability to classify the
+    entire image into 1 of the 4 label categories::
+
+        0: (Natural) The image is natural / unaltered.
+        1: (FullySynthesized) The entire image was synthesized by e.g., a
+            generative image model.
+        2: (LocallyEdited) The image is a natural image where a portion has
+            been edited using traditional photo editing techniques such as
+            splicing.
+        3: (LocallySynthesized) The image is a natural image where a portion
+            has been replaced by synthesized content.
+    """
+
+    logprobs: list[float] = pydantic.Field(
+        description="The log-probabilities for each of the 4 possible labels.",
+        min_length=4,
+        max_length=4,
+    )
+
+    localizationMask: Optional[LocalizationMask] = pydantic.Field(
+        description="A bit mask localizing predicted edits. Models that are"
+        " not capable of localization may omit this field. It may also be"
+        " omitted if the predicted label is ``0`` or ``1``, in which case the"
+        " mask will be assumed to be all 0's or all 1's, as appropriate."
+    )

app/api/routes/__init__.py

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

app/api/routes/prediction.py

@@ -0,0 +1,23 @@
+"""Prediction API 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_inference_service
+from app.services.base import InferenceService
+
+router = APIRouter()
+
+
+@router.post("/predict", response_model=PredictionResponse)
+async def predict(
+    request: ImageRequest,
+    service: InferenceService = Depends(get_inference_service)
+):
+    """
+    Run inference on base64-encoded image.
+
+    Returns prediction, confidence, predicted label, model name, and media type.
+    """
+    return await PredictionController.predict(request, service)

app/core/__init__.py

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

app/core/app.py

@@ -0,0 +1,71 @@
+"""FastAPI application factory and core infrastructure."""
+
+import asyncio
+import warnings
+from contextlib import asynccontextmanager
+from typing import AsyncGenerator, Optional
+
+from fastapi import FastAPI
+from pydantic import Field
+from pydantic_settings import BaseSettings
+
+from app.core.logging import logger
+from app.core.dependencies import set_inference_service
+from app.services.inference import ResNetInferenceService
+from app.api.routes import prediction
+
+
+class Settings(BaseSettings):
+    """Application settings. Override via environment variables or .env file."""
+
+    app_name: str = Field(default="ML Inference Service")
+    app_version: str = Field(default="0.1.0")
+    debug: bool = Field(default=False)
+    host: str = Field(default="0.0.0.0")
+    port: int = Field(default=8000)
+
+    class Config:
+        env_file = ".env"
+
+
+settings = Settings()
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
+    """Application lifecycle: startup/shutdown."""
+    logger.info("Starting ML Inference Service...")
+
+    try:
+        with warnings.catch_warnings():
+            warnings.filterwarnings("ignore", category=FutureWarning)
+
+            # Replace ResNetInferenceService with your own implementation
+            service = ResNetInferenceService(model_name="microsoft/resnet-18")
+            await asyncio.to_thread(service.load_model)
+            set_inference_service(service)
+
+        logger.info("Startup completed successfully")
+
+    except Exception as e:
+        logger.error(f"Startup failed: {e}")
+        raise
+
+    yield
+
+    logger.info("Shutting down...")
+
+
+def create_app() -> FastAPI:
+    """Create and configure FastAPI application."""
+    app = FastAPI(
+        title=settings.app_name,
+        description="ML inference service for image classification",
+        version=settings.app_version,
+        debug=settings.debug,
+        lifespan=lifespan
+    )
+
+    app.include_router(prediction.router)
+
+    return app

app/core/dependencies.py

@@ -0,0 +1,17 @@
+"""Dependency injection for services."""
+
+from typing import Optional
+from app.services.base import InferenceService
+
+_inference_service: Optional[InferenceService] = None
+
+
+def get_inference_service() -> Optional[InferenceService]:
+    """Get inference service for dependency injection."""
+    return _inference_service
+
+
+def set_inference_service(service: InferenceService) -> None:
+    """Set inference service. Called internally during startup."""
+    global _inference_service
+    _inference_service = service

app/core/logging.py

@@ -0,0 +1,26 @@
+"""Logging configuration."""
+
+import logging
+import sys
+
+
+def setup_logging(logger_name: str = "ML Inference Service") -> logging.Logger:
+    """Setup and configure logger."""
+    logger = logging.getLogger(logger_name)
+
+    if logger.handlers:
+        return logger
+
+    logger.setLevel(logging.INFO)
+    handler = logging.StreamHandler(sys.stdout)
+    handler.setLevel(logging.INFO)
+    formatter = logging.Formatter(
+        "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+    )
+    handler.setFormatter(formatter)
+    logger.addHandler(handler)
+
+    return logger
+
+
+logger = setup_logging()

app/services/__init__.py

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

app/services/base.py

@@ -0,0 +1,30 @@
+"""Abstract base class for ML inference services."""
+
+from abc import ABC, abstractmethod
+from typing import Generic, TypeVar
+from pydantic import BaseModel
+
+TRequest = TypeVar('TRequest', bound=BaseModel)
+TResponse = TypeVar('TResponse', bound=BaseModel)
+
+
+class InferenceService(ABC, Generic[TRequest, TResponse]):
+    """
+    Base class for inference services. Subclass this to integrate your model.
+    """
+
+    @abstractmethod
+    def load_model(self) -> None:
+        """Load model weights and processors. Called once at startup."""
+        pass
+
+    @abstractmethod
+    def predict(self, request: TRequest) -> TResponse:
+        """Run inference and return typed response."""
+        pass
+
+    @property
+    @abstractmethod
+    def is_loaded(self) -> bool:
+        """Check if model is loaded and ready."""
+        pass

app/services/inference.py

@@ -0,0 +1,86 @@
+"""ResNet inference service implementation."""
+
+import base64
+import os
+import random
+from io import BytesIO
+
+import torch
+from PIL import Image
+from transformers import AutoImageProcessor, ResNetForImageClassification  # type: ignore[import-untyped]
+
+from app.core.logging import logger
+from app.services.base import InferenceService
+from app.api.models import ImageRequest, Labels, LocalizationMask, PredictionResponse
+
+
+class ResNetInferenceService(InferenceService[ImageRequest, PredictionResponse]):
+    """ResNet-18 inference service for image classification."""
+
+    def __init__(self, model_name: str = "microsoft/resnet-18"):
+        self.model_name = model_name
+        self.model = None
+        self.processor = None
+        self._is_loaded = False
+        self.model_path = os.path.join("models", model_name)
+        logger.info(f"Initializing ResNet service: {self.model_path}")
+
+    def load_model(self) -> None:
+        if self._is_loaded:
+            return
+
+        if not os.path.exists(self.model_path):
+            raise FileNotFoundError(f"Model 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"Config not found: {config_path}")
+
+        logger.info(f"Loading model from {self.model_path}")
+
+        import warnings
+        with warnings.catch_warnings():
+            warnings.filterwarnings("ignore", category=FutureWarning)
+            self.processor = AutoImageProcessor.from_pretrained(
+                self.model_path, local_files_only=True
+            )
+            self.model = ResNetForImageClassification.from_pretrained(
+                self.model_path, local_files_only=True
+            )
+            assert self.model is not None
+
+        self._is_loaded = True
+        logger.info(f"Model loaded: {len(self.model.config.id2label)} classes")  # pyright: ignore
+
+    def predict(self, request: ImageRequest) -> PredictionResponse:
+        if not self.is_loaded:
+            raise RuntimeError("model is not loaded")
+        assert self.processor is not None
+        assert self.model is not None
+
+        image_data = base64.b64decode(request.image.data)
+        image = Image.open(BytesIO(image_data))
+        width, height = image.size
+
+        if image.mode != 'RGB':
+            image = image.convert('RGB')
+
+        inputs = self.processor(image, return_tensors="pt")
+
+        with torch.no_grad():
+            logits = self.model(**inputs).logits   # pyright: ignore
+
+        logprobs = torch.nn.functional.log_softmax(logits[:len(Labels)], dim=-1).tolist()
+        mask_bytes = random.randbytes((width*height + 7) // 8)
+        mask_bits = base64.b64encode(mask_bytes).decode("utf-8")
+
+        return PredictionResponse(
+            logprobs=logprobs,
+            localizationMask=LocalizationMask(
+                width=width, height=height, bitsRowMajor=mask_bits
+            )
+        )
+
+    @property
+    def is_loaded(self) -> bool:
+        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,22 @@
+# 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
+
+# Dataset generation and testing
+pyarrow>=14.0.0
+numpy>=1.24.0
+pandas>=2.0.0
+requests>=2.25.0

requirements.txt

@@ -0,0 +1,180 @@
+#
+# This file is autogenerated by pip-compile with Python 3.12
+# by the following command:
+#
+#    pip-compile requirements.in
+#
+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
+    #   -r requirements.in
+    #   pandas
+    #   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
+pandas==2.3.2
+    # via -r requirements.in
+pillow==10.1.0
+    # via -r requirements.in
+pyarrow==21.0.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-dateutil==2.9.0.post0
+    # via pandas
+python-dotenv==0.21.0
+    # via
+    #   -r requirements.in
+    #   pydantic-settings
+    #   uvicorn
+python-multipart==0.0.6
+    # via -r requirements.in
+pytz==2025.2
+    # via pandas
+pyyaml==6.0.2
+    # via
+    #   huggingface-hub
+    #   transformers
+    #   uvicorn
+regex==2025.7.34
+    # via transformers
+requests==2.32.5
+    # via
+    #   -r requirements.in
+    #   huggingface-hub
+    #   transformers
+safetensors==0.6.2
+    # via transformers
+six==1.17.0
+    # via python-dateutil
+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
+tzdata==2025.2
+    # via pandas
+urllib3==2.5.0
+    # via requests
+uvicorn[standard]==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
+
+# The following packages are considered to be unsafe in a requirements file:
+# setuptools

scripts/generate_test_datasets.py

@@ -0,0 +1,411 @@
+#!/usr/bin/env python3
+"""
+PyArrow Dataset Generator for ML Inference Service
+
+Generates test datasets for academic challenges and model validation.
+Creates 100 PyArrow datasets with various image types and test scenarios.
+"""
+
+import base64
+import json
+import random
+from pathlib import Path
+from typing import Dict, List, Any, Tuple
+import io
+
+import numpy as np
+import pyarrow as pa
+import pyarrow.parquet as pq
+from PIL import Image, ImageDraw, ImageFont
+
+
+class TestDatasetGenerator:
+    def __init__(self, output_dir: str = "test_datasets"):
+        self.output_dir = Path(output_dir)
+        self.output_dir.mkdir(exist_ok=True)
+
+        # ImageNet class labels (sample for testing)
+        self.imagenet_labels = [
+            "tench", "goldfish", "great_white_shark", "tiger_shark", "hammerhead",
+            "electric_ray", "stingray", "cock", "hen", "ostrich", "brambling",
+            "goldfinch", "house_finch", "junco", "indigo_bunting", "robin",
+            "bulbul", "jay", "magpie", "chickadee", "water_ouzel", "kite",
+            "bald_eagle", "vulture", "great_grey_owl", "European_fire_salamander",
+            "common_newt", "eft", "spotted_salamander", "axolotl", "bullfrog",
+            "tree_frog", "tailed_frog", "loggerhead", "leatherback_turtle",
+            "mud_turtle", "terrapin", "box_turtle", "banded_gecko", "common_iguana",
+            "American_chameleon", "whiptail", "agama", "frilled_lizard", "alligator_lizard",
+            "Gila_monster", "green_lizard", "African_chameleon", "Komodo_dragon",
+            "African_crocodile", "American_alligator", "triceratops", "thunder_snake"
+        ]
+
+    def create_synthetic_image(self, width: int = 224, height: int = 224,
+                             image_type: str = "random") -> Image.Image:
+        """Create synthetic images for testing."""
+        if image_type == "random":
+            # Random noise image
+            array = np.random.randint(0, 256, (height, width, 3), dtype=np.uint8)
+            return Image.fromarray(array)
+
+        elif image_type == "geometric":
+            # Geometric patterns
+            img = Image.new('RGB', (width, height), color='white')
+            draw = ImageDraw.Draw(img)
+
+            # Draw random shapes
+            for _ in range(random.randint(3, 8)):
+                color = tuple(random.randint(0, 255) for _ in range(3))
+                shape_type = random.choice(['rectangle', 'ellipse'])
+                x1, y1 = random.randint(0, width//2), random.randint(0, height//2)
+                x2, y2 = x1 + random.randint(20, width//2), y1 + random.randint(20, height//2)
+
+                if shape_type == 'rectangle':
+                    draw.rectangle([x1, y1, x2, y2], fill=color)
+                else:
+                    draw.ellipse([x1, y1, x2, y2], fill=color)
+
+            return img
+
+        elif image_type == "gradient":
+            array = np.zeros((height, width, 3), dtype=np.uint8)
+            for i in range(height):
+                for j in range(width):
+                    array[i, j] = [i * 255 // height, j * 255 // width, (i + j) * 255 // (height + width)]
+            return Image.fromarray(array)
+
+        elif image_type == "text":
+            img = Image.new('RGB', (width, height), color='white')
+            draw = ImageDraw.Draw(img)
+
+            try:
+                font = ImageFont.load_default()
+            except:
+                font = None
+
+            text = f"Test Image {random.randint(1, 1000)}"
+            draw.text((width//4, height//2), text, fill='black', font=font)
+            return img
+
+        else:
+            color = tuple(random.randint(0, 255) for _ in range(3))
+            return Image.new('RGB', (width, height), color=color)
+
+    def image_to_base64(self, image: Image.Image, format: str = "JPEG") -> str:
+        """Convert PIL image to base64 string."""
+        buffer = io.BytesIO()
+        image.save(buffer, format=format)
+        image_bytes = buffer.getvalue()
+        return base64.b64encode(image_bytes).decode('utf-8')
+
+    def create_api_request(self, image_b64: str, media_type: str = "image/jpeg") -> Dict[str, Any]:
+        """Create API request structure matching your service."""
+        return {
+            "image": {
+                "mediaType": media_type,
+                "data": image_b64
+            }
+        }
+
+    def create_expected_response(self, model_name: str = "microsoft/resnet-18",
+                               media_type: str = "image/jpeg") -> Dict[str, Any]:
+        """Create expected response structure."""
+        prediction = random.choice(self.imagenet_labels)
+        return {
+            "prediction": prediction,
+            "confidence": round(random.uniform(0.3, 0.99), 4),
+            "predicted_label": random.randint(0, len(self.imagenet_labels) - 1),
+            "model": model_name,
+            "mediaType": media_type
+        }
+
+    def generate_standard_datasets(self, count: int = 25) -> List[Dict[str, Any]]:
+        """Generate standard test cases with normal images."""
+        datasets = []
+
+        for i in range(count):
+            image_types = ["random", "geometric", "gradient", "text", "solid"]
+            sizes = [(224, 224), (256, 256), (299, 299), (384, 384)]
+            formats = [("JPEG", "image/jpeg"), ("PNG", "image/png")]
+
+            records = []
+            for j in range(random.randint(5, 20)):  # 5-20 images per dataset
+                img_type = random.choice(image_types)
+                size = random.choice(sizes)
+                format_info = random.choice(formats)
+
+                image = self.create_synthetic_image(size[0], size[1], img_type)
+                image_b64 = self.image_to_base64(image, format_info[0])
+
+                api_request = self.create_api_request(image_b64, format_info[1])
+                expected_response = self.create_expected_response()
+
+                record = {
+                    "dataset_id": f"standard_{i:03d}",
+                    "image_id": f"img_{j:03d}",
+                    "image_type": img_type,
+                    "image_size": f"{size[0]}x{size[1]}",
+                    "format": format_info[0],
+                    "media_type": format_info[1],
+                    "api_request": json.dumps(api_request),
+                    "expected_response": json.dumps(expected_response),
+                    "test_category": "standard",
+                    "difficulty": "normal"
+                }
+                records.append(record)
+
+            datasets.append({
+                "name": f"standard_test_{i:03d}",
+                "category": "standard",
+                "description": f"Standard test dataset {i+1} with {len(records)} images",
+                "records": records
+            })
+
+        return datasets
+
+    def generate_edge_case_datasets(self, count: int = 25) -> List[Dict[str, Any]]:
+        """Generate datasets for edge case scenarios."""
+        datasets = []
+
+        for i in range(count):
+            records = []
+            edge_cases = [
+                {"type": "tiny", "size": (32, 32), "difficulty": "high"},
+                {"type": "huge", "size": (2048, 2048), "difficulty": "high"},
+                {"type": "extreme_aspect", "size": (1000, 50), "difficulty": "medium"},
+                {"type": "single_pixel", "size": (1, 1), "difficulty": "extreme"},
+                {"type": "corrupted_base64", "size": (224, 224), "difficulty": "extreme"}
+            ]
+
+            for j, edge_case in enumerate(edge_cases):
+                if edge_case["type"] == "corrupted_base64":
+                    image = self.create_synthetic_image(224, 224, "random")
+                    image_b64 = self.image_to_base64(image, "JPEG")
+                    corrupted_b64 = image_b64[:-20] + "CORRUPTED_DATA"
+                    api_request = self.create_api_request(corrupted_b64)
+                    expected_response = {
+                        "error": "Invalid image data",
+                        "status": "failed"
+                    }
+                else:
+                    image = self.create_synthetic_image(
+                        edge_case["size"][0], edge_case["size"][1], "random"
+                    )
+                    image_b64 = self.image_to_base64(image, "PNG")
+                    api_request = self.create_api_request(image_b64, "image/png")
+                    expected_response = self.create_expected_response()
+
+                record = {
+                    "dataset_id": f"edge_{i:03d}",
+                    "image_id": f"edge_{j:03d}",
+                    "image_type": edge_case["type"],
+                    "image_size": f"{edge_case['size'][0]}x{edge_case['size'][1]}",
+                    "format": "PNG",
+                    "media_type": "image/png",
+                    "api_request": json.dumps(api_request),
+                    "expected_response": json.dumps(expected_response),
+                    "test_category": "edge_case",
+                    "difficulty": edge_case["difficulty"]
+                }
+                records.append(record)
+
+            datasets.append({
+                "name": f"edge_case_{i:03d}",
+                "category": "edge_case",
+                "description": f"Edge case dataset {i+1} with challenging scenarios",
+                "records": records
+            })
+
+        return datasets
+
+    def generate_performance_datasets(self, count: int = 25) -> List[Dict[str, Any]]:
+        """Generate performance benchmark datasets."""
+        datasets = []
+
+        for i in range(count):
+            batch_sizes = [1, 5, 10, 25, 50, 100]
+            batch_size = random.choice(batch_sizes)
+
+            records = []
+            for j in range(batch_size):
+                image = self.create_synthetic_image(224, 224, "random")
+                image_b64 = self.image_to_base64(image, "JPEG")
+                api_request = self.create_api_request(image_b64)
+                expected_response = self.create_expected_response()
+
+                record = {
+                    "dataset_id": f"perf_{i:03d}",
+                    "image_id": f"batch_{j:03d}",
+                    "image_type": "performance_test",
+                    "image_size": "224x224",
+                    "format": "JPEG",
+                    "media_type": "image/jpeg",
+                    "api_request": json.dumps(api_request),
+                    "expected_response": json.dumps(expected_response),
+                    "test_category": "performance",
+                    "difficulty": "normal",
+                    "batch_size": batch_size,
+                    "expected_max_latency_ms": batch_size * 100
+                }
+                records.append(record)
+
+            datasets.append({
+                "name": f"performance_test_{i:03d}",
+                "category": "performance",
+                "description": f"Performance dataset {i+1} with batch size {batch_size}",
+                "records": records
+            })
+
+        return datasets
+
+    def generate_model_comparison_datasets(self, count: int = 25) -> List[Dict[str, Any]]:
+        """Generate datasets for comparing different models."""
+        datasets = []
+
+        model_types = [
+            "microsoft/resnet-18", "microsoft/resnet-50", "google/vit-base-patch16-224",
+            "facebook/convnext-tiny-224", "microsoft/swin-tiny-patch4-window7-224"
+        ]
+
+        for i in range(count):
+            # Same images tested across different model types
+            base_images = []
+            for _ in range(10):  # 10 base images per comparison dataset
+                image = self.create_synthetic_image(224, 224, "geometric")
+                base_images.append(self.image_to_base64(image, "JPEG"))
+
+            records = []
+            for j, model in enumerate(model_types):
+                for k, image_b64 in enumerate(base_images):
+                    api_request = self.create_api_request(image_b64)
+                    expected_response = self.create_expected_response(model)
+
+                    record = {
+                        "dataset_id": f"comparison_{i:03d}",
+                        "image_id": f"img_{k:03d}_model_{j}",
+                        "image_type": "comparison_base",
+                        "image_size": "224x224",
+                        "format": "JPEG",
+                        "media_type": "image/jpeg",
+                        "api_request": json.dumps(api_request),
+                        "expected_response": json.dumps(expected_response),
+                        "test_category": "model_comparison",
+                        "difficulty": "normal",
+                        "model_type": model,
+                        "comparison_group": k
+                    }
+                    records.append(record)
+
+            datasets.append({
+                "name": f"model_comparison_{i:03d}",
+                "category": "model_comparison",
+                "description": f"Model comparison dataset {i+1} testing {len(model_types)} models",
+                "records": records
+            })
+
+        return datasets
+
+    def save_dataset_to_parquet(self, dataset: Dict[str, Any]):
+        """Save a dataset to PyArrow Parquet format."""
+        records = dataset["records"]
+
+        # Convert to PyArrow table
+        table = pa.table({
+            "dataset_id": [r["dataset_id"] for r in records],
+            "image_id": [r["image_id"] for r in records],
+            "image_type": [r["image_type"] for r in records],
+            "image_size": [r["image_size"] for r in records],
+            "format": [r["format"] for r in records],
+            "media_type": [r["media_type"] for r in records],
+            "api_request": [r["api_request"] for r in records],
+            "expected_response": [r["expected_response"] for r in records],
+            "test_category": [r["test_category"] for r in records],
+            "difficulty": [r["difficulty"] for r in records],
+            # Optional fields with defaults
+            "batch_size": [r.get("batch_size", 1) for r in records],
+            "expected_max_latency_ms": [r.get("expected_max_latency_ms", 1000) for r in records],
+            "model_type": [r.get("model_type", "microsoft/resnet-18") for r in records],
+            "comparison_group": [r.get("comparison_group", 0) for r in records]
+        })
+
+        output_path = self.output_dir / f"{dataset['name']}.parquet"
+        pq.write_table(table, output_path)
+
+        # Save metadata as JSON
+        metadata = {
+            "name": dataset["name"],
+            "category": dataset["category"],
+            "description": dataset["description"],
+            "record_count": len(records),
+            "file_size_mb": round(output_path.stat().st_size / (1024 * 1024), 2),
+            "schema": [field.name for field in table.schema]
+        }
+
+        metadata_path = self.output_dir / f"{dataset['name']}_metadata.json"
+        with open(metadata_path, 'w') as f:
+            json.dump(metadata, f, indent=2)
+
+    def generate_all_datasets(self):
+        """Generate all 100 datasets."""
+        print(" Starting dataset generation...")
+
+        print("📊 Generating standard test datasets (25)...")
+        standard_datasets = self.generate_standard_datasets(25)
+        for dataset in standard_datasets:
+            self.save_dataset_to_parquet(dataset)
+
+        print("⚡ Generating edge case datasets (25)...")
+        edge_datasets = self.generate_edge_case_datasets(25)
+        for dataset in edge_datasets:
+            self.save_dataset_to_parquet(dataset)
+
+        print("🏁 Generating performance datasets (25)...")
+        performance_datasets = self.generate_performance_datasets(25)
+        for dataset in performance_datasets:
+            self.save_dataset_to_parquet(dataset)
+
+        print("🔄 Generating model comparison datasets (25)...")
+        comparison_datasets = self.generate_model_comparison_datasets(25)
+        for dataset in comparison_datasets:
+            self.save_dataset_to_parquet(dataset)
+
+        print(f"✅ Generated 100 datasets in {self.output_dir}/")
+
+        self.generate_summary()
+
+    def generate_summary(self):
+        """Generate a summary of all datasets."""
+        summary = {
+            "total_datasets": 100,
+            "categories": {
+                "standard": 25,
+                "edge_case": 25,
+                "performance": 25,
+                "model_comparison": 25
+            },
+            "dataset_info": [],
+            "usage_instructions": {
+                "loading": "Use pyarrow.parquet.read_table('dataset.parquet')",
+                "testing": "Run python scripts/test_datasets.py",
+                "api_endpoint": "POST /predict/resnet",
+                "request_format": "See api_request column in datasets"
+            }
+        }
+
+        # Add individual dataset info
+        for parquet_file in self.output_dir.glob("*.parquet"):
+            metadata_file = self.output_dir / f"{parquet_file.stem}_metadata.json"
+            if metadata_file.exists():
+                with open(metadata_file, 'r') as f:
+                    metadata = json.load(f)
+                    summary["dataset_info"].append(metadata)
+
+        summary_path = self.output_dir / "datasets_summary.json"
+        with open(summary_path, 'w') as f:
+            json.dump(summary, f, indent=2)
+
+        print(f"📋 Summary saved to {summary_path}")
+
+
+if __name__ == "__main__":
+    generator = TestDatasetGenerator()
+    generator.generate_all_datasets()

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/microsoft/resnet-18",
+    local_dir_use_symlinks=False # copies files; safer for containers
+)
+PY

scripts/test_datasets.py

@@ -0,0 +1,382 @@
+#!/usr/bin/env python3
+"""
+Dataset Tester for ML Inference Service
+
+Tests the generated PyArrow datasets against the running ML inference service.
+Validates API requests/responses and measures performance metrics.
+"""
+
+import json
+import time
+import asyncio
+import statistics
+from pathlib import Path
+from typing import Dict, List, Any, Optional
+import argparse
+
+import pyarrow.parquet as pq
+import requests
+import pandas as pd
+
+
+class DatasetTester:
+    def __init__(self, base_url: str = "http://127.0.0.1:8000", datasets_dir: str = "test_datasets"):
+        self.base_url = base_url.rstrip('/')
+        self.datasets_dir = Path(datasets_dir)
+        self.endpoint = f"{self.base_url}/predict/resnet"
+        self.results = []
+
+    def load_dataset(self, dataset_path: Path) -> pd.DataFrame:
+        """Load a PyArrow dataset."""
+        table = pq.read_table(dataset_path)
+        return table.to_pandas()
+
+    def test_api_connection(self) -> bool:
+        """Test if the API is running and accessible."""
+        try:
+            response = requests.get(f"{self.base_url}/docs", timeout=5)
+            return response.status_code == 200
+        except requests.RequestException:
+            return False
+
+    def send_prediction_request(self, api_request_json: str) -> Dict[str, Any]:
+        """Send a single prediction request to the API."""
+        try:
+            request_data = json.loads(api_request_json)
+            start_time = time.time()
+
+            response = requests.post(
+                self.endpoint,
+                json=request_data,
+                headers={"Content-Type": "application/json"},
+                timeout=30
+            )
+
+            end_time = time.time()
+            latency_ms = (end_time - start_time) * 1000
+
+            return {
+                "success": response.status_code == 200,
+                "status_code": response.status_code,
+                "response": response.json() if response.status_code == 200 else response.text,
+                "latency_ms": round(latency_ms, 2),
+                "error": None
+            }
+
+        except requests.RequestException as e:
+            return {
+                "success": False,
+                "status_code": None,
+                "response": None,
+                "latency_ms": None,
+                "error": str(e)
+            }
+        except json.JSONDecodeError as e:
+            return {
+                "success": False,
+                "status_code": None,
+                "response": None,
+                "latency_ms": None,
+                "error": f"JSON decode error: {str(e)}"
+            }
+
+    def validate_response(self, actual_response: Dict[str, Any],
+                         expected_response_json: str) -> Dict[str, Any]:
+        """Validate API response against expected response."""
+        try:
+            expected = json.loads(expected_response_json)
+
+            validation = {
+                "structure_valid": True,
+                "field_errors": []
+            }
+
+            # Check required fields exist
+            required_fields = ["prediction", "confidence", "predicted_label", "model", "mediaType"]
+            for field in required_fields:
+                if field not in actual_response:
+                    validation["structure_valid"] = False
+                    validation["field_errors"].append(f"Missing field: {field}")
+
+            # Validate field types
+            if "confidence" in actual_response:
+                if not isinstance(actual_response["confidence"], (int, float)):
+                    validation["field_errors"].append("confidence must be numeric")
+                elif not (0 <= actual_response["confidence"] <= 1):
+                    validation["field_errors"].append("confidence must be between 0 and 1")
+
+            if "predicted_label" in actual_response:
+                if not isinstance(actual_response["predicted_label"], int):
+                    validation["field_errors"].append("predicted_label must be integer")
+
+            return validation
+
+        except json.JSONDecodeError:
+            return {
+                "structure_valid": False,
+                "field_errors": ["Invalid expected response JSON"]
+            }
+
+    def test_dataset(self, dataset_path: Path, max_samples: Optional[int] = None) -> Dict[str, Any]:
+        """Test a single dataset."""
+        print(f"📊 Testing dataset: {dataset_path.name}")
+
+        try:
+            df = self.load_dataset(dataset_path)
+            if max_samples:
+                df = df.head(max_samples)
+
+            results = {
+                "dataset_name": dataset_path.stem,
+                "total_samples": len(df),
+                "tested_samples": 0,
+                "successful_requests": 0,
+                "failed_requests": 0,
+                "validation_errors": 0,
+                "latencies_ms": [],
+                "errors": [],
+                "category": df['test_category'].iloc[0] if not df.empty else "unknown"
+            }
+
+            for idx, row in df.iterrows():
+                print(f"  Testing sample {idx + 1}/{len(df)}", end="\r")
+
+                # Send API request
+                api_result = self.send_prediction_request(row['api_request'])
+                results["tested_samples"] += 1
+
+                if api_result["success"]:
+                    results["successful_requests"] += 1
+                    results["latencies_ms"].append(api_result["latency_ms"])
+
+                    # Validate response structure
+                    validation = self.validate_response(
+                        api_result["response"],
+                        row['expected_response']
+                    )
+
+                    if not validation["structure_valid"]:
+                        results["validation_errors"] += 1
+                        results["errors"].append({
+                            "sample_id": row['image_id'],
+                            "type": "validation_error",
+                            "details": validation["field_errors"]
+                        })
+
+                else:
+                    results["failed_requests"] += 1
+                    results["errors"].append({
+                        "sample_id": row['image_id'],
+                        "type": "request_failed",
+                        "status_code": api_result["status_code"],
+                        "error": api_result["error"]
+                    })
+
+            # Calculate statistics
+            if results["latencies_ms"]:
+                results["avg_latency_ms"] = round(statistics.mean(results["latencies_ms"]), 2)
+                results["min_latency_ms"] = round(min(results["latencies_ms"]), 2)
+                results["max_latency_ms"] = round(max(results["latencies_ms"]), 2)
+                results["median_latency_ms"] = round(statistics.median(results["latencies_ms"]), 2)
+            else:
+                results.update({
+                    "avg_latency_ms": None,
+                    "min_latency_ms": None,
+                    "max_latency_ms": None,
+                    "median_latency_ms": None
+                })
+
+            results["success_rate"] = round(
+                results["successful_requests"] / results["tested_samples"] * 100, 2
+            ) if results["tested_samples"] > 0 else 0
+
+            print(f"\n  ✅ Completed: {results['success_rate']}% success rate")
+            return results
+
+        except Exception as e:
+            print(f"\n  ❌ Failed to test dataset: {str(e)}")
+            return {
+                "dataset_name": dataset_path.stem,
+                "error": str(e),
+                "success_rate": 0
+            }
+
+    def test_all_datasets(self, max_samples_per_dataset: Optional[int] = None,
+                         category_filter: Optional[str] = None) -> Dict[str, Any]:
+        """Test all datasets or filtered by category."""
+        if not self.test_api_connection():
+            print("❌ API is not accessible. Please start the service first:")
+            print("   uvicorn main:app --reload")
+            return {"error": "API not accessible"}
+
+        print(f" Starting dataset testing against {self.endpoint}")
+
+        parquet_files = list(self.datasets_dir.glob("*.parquet"))
+        if not parquet_files:
+            print(f"❌ No datasets found in {self.datasets_dir}")
+            return {"error": "No datasets found"}
+
+        if category_filter:
+            parquet_files = [f for f in parquet_files if category_filter in f.name]
+
+        print(f" Found {len(parquet_files)} datasets to test")
+
+        all_results = []
+        start_time = time.time()
+
+        for dataset_file in parquet_files:
+            result = self.test_dataset(dataset_file, max_samples_per_dataset)
+            all_results.append(result)
+
+        end_time = time.time()
+        total_time = end_time - start_time
+
+        summary = self.generate_summary(all_results, total_time)
+
+        self.save_results(summary, all_results)
+
+        return summary
+
+    def generate_summary(self, results: List[Dict[str, Any]], total_time: float) -> Dict[str, Any]:
+        """Generate summary of all test results."""
+        successful_datasets = [r for r in results if r.get("success_rate", 0) > 0]
+        failed_datasets = [r for r in results if r.get("error") or r.get("success_rate", 0) == 0]
+
+        total_samples = sum(r.get("tested_samples", 0) for r in results)
+        total_successful = sum(r.get("successful_requests", 0) for r in results)
+        total_failed = sum(r.get("failed_requests", 0) for r in results)
+
+        all_latencies = []
+        for r in results:
+            all_latencies.extend(r.get("latencies_ms", []))
+
+        summary = {
+            "test_summary": {
+                "total_datasets": len(results),
+                "successful_datasets": len(successful_datasets),
+                "failed_datasets": len(failed_datasets),
+                "total_samples_tested": total_samples,
+                "total_successful_requests": total_successful,
+                "total_failed_requests": total_failed,
+                "overall_success_rate": round(
+                    total_successful / total_samples * 100, 2
+                ) if total_samples > 0 else 0,
+                "total_test_time_seconds": round(total_time, 2)
+            },
+            "performance_metrics": {
+                "avg_latency_ms": round(statistics.mean(all_latencies), 2) if all_latencies else None,
+                "median_latency_ms": round(statistics.median(all_latencies), 2) if all_latencies else None,
+                "min_latency_ms": round(min(all_latencies), 2) if all_latencies else None,
+                "max_latency_ms": round(max(all_latencies), 2) if all_latencies else None,
+                "requests_per_second": round(
+                    total_successful / total_time, 2
+                ) if total_time > 0 else 0
+            },
+            "category_breakdown": {},
+            "failed_datasets": [r["dataset_name"] for r in failed_datasets]
+        }
+
+        categories = {}
+        for result in results:
+            category = result.get("category", "unknown")
+            if category not in categories:
+                categories[category] = {
+                    "count": 0,
+                    "success_rates": [],
+                    "avg_success_rate": 0
+                }
+            categories[category]["count"] += 1
+            categories[category]["success_rates"].append(result.get("success_rate", 0))
+
+        for category, data in categories.items():
+            data["avg_success_rate"] = round(
+                statistics.mean(data["success_rates"]), 2
+            ) if data["success_rates"] else 0
+
+        summary["category_breakdown"] = categories
+
+        return summary
+
+    def save_results(self, summary: Dict[str, Any], detailed_results: List[Dict[str, Any]]):
+        """Save test results to files."""
+        results_dir = Path("test_results")
+        results_dir.mkdir(exist_ok=True)
+
+        timestamp = int(time.time())
+
+        # Save summary
+        summary_path = results_dir / f"test_summary_{timestamp}.json"
+        with open(summary_path, 'w') as f:
+            json.dump(summary, f, indent=2)
+
+        # Save detailed results
+        detailed_path = results_dir / f"test_detailed_{timestamp}.json"
+        with open(detailed_path, 'w') as f:
+            json.dump(detailed_results, f, indent=2)
+
+        print(f" Results saved:")
+        print(f"   Summary: {summary_path}")
+        print(f"   Details: {detailed_path}")
+
+    def print_summary(self, summary: Dict[str, Any]):
+        """Print test summary to console."""
+        print("\n" + "="*60)
+        print("🏁 DATASET TESTING SUMMARY")
+        print("="*60)
+
+        ts = summary["test_summary"]
+        print(f"Datasets tested: {ts['total_datasets']}")
+        print(f"Successful datasets: {ts['successful_datasets']}")
+        print(f"Failed datasets: {ts['failed_datasets']}")
+        print(f"Total samples: {ts['total_samples_tested']}")
+        print(f"Overall success rate: {ts['overall_success_rate']}%")
+        print(f"Test duration: {ts['total_test_time_seconds']}s")
+
+        pm = summary["performance_metrics"]
+        if pm["avg_latency_ms"]:
+            print(f"\nPerformance:")
+            print(f"  Avg latency: {pm['avg_latency_ms']}ms")
+            print(f"  Median latency: {pm['median_latency_ms']}ms")
+            print(f"  Min latency: {pm['min_latency_ms']}ms")
+            print(f"  Max latency: {pm['max_latency_ms']}ms")
+            print(f"  Requests/sec: {pm['requests_per_second']}")
+
+        print(f"\nCategory breakdown:")
+        for category, data in summary["category_breakdown"].items():
+            print(f"  {category}: {data['count']} datasets, {data['avg_success_rate']}% avg success")
+
+        if summary["failed_datasets"]:
+            print(f"\nFailed datasets: {', '.join(summary['failed_datasets'])}")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Test PyArrow datasets against ML inference service")
+    parser.add_argument("--base-url", default="http://127.0.0.1:8000", help="Base URL of the API")
+    parser.add_argument("--datasets-dir", default="scripts/test_datasets", help="Directory containing datasets")
+    parser.add_argument("--max-samples", type=int, help="Max samples per dataset to test")
+    parser.add_argument("--category", help="Filter datasets by category (standard, edge_case, performance, model_comparison)")
+    parser.add_argument("--quick", action="store_true", help="Quick test with max 5 samples per dataset")
+
+    args = parser.parse_args()
+
+    tester = DatasetTester(args.base_url, args.datasets_dir)
+
+    max_samples = args.max_samples
+    if args.quick:
+        max_samples = 5
+
+    results = tester.test_all_datasets(max_samples, args.category)
+
+    if "error" not in results:
+        tester.print_summary(results)
+
+        if results["test_summary"]["overall_success_rate"] > 90:
+            print("\n🎉 Excellent! API is working great with the datasets!")
+        elif results["test_summary"]["overall_success_rate"] > 70:
+            print("\n👍 Good! API works well, minor issues detected.")
+        else:
+            print("\n⚠️  Warning: Several issues detected. Check the detailed results.")
+
+
+if __name__ == "__main__":
+    main()

test_main.http

@@ -0,0 +1,12 @@
+# Test Prediction Endpoint
+# Works with any model configured at startup (default: ResNet-18)
+
+POST http://127.0.0.1:8000/predict
+Content-Type: application/json
+
+{
+  "image": {
+    "mediaType": "image/jpeg",
+    "data": "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"
+    }
+}