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,7 @@
+dyff-outputs/
+models/
+test_datasets/
+test_results/
+venv/
+**/__pycache__
+*.tmp

.python-version

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

Dockerfile

@@ -0,0 +1,24 @@
+FROM python:3.12-slim
+
+ENV PYTHONDONTWRITEBYTECODE="1" \
+    PYTHONUNBUFFERED="1"
+
+# hadolint ignore=DL3013
+RUN python3 -m pip install --no-cache-dir --upgrade pip setuptools wheel
+
+WORKDIR /app/
+
+COPY requirements.cpu.txt ./
+RUN python3 -m pip install --no-cache-dir -r ./requirements.cpu.txt
+
+COPY requirements.torch.cpu.txt ./
+RUN python3 -m pip install --no-cache-dir -r ./requirements.torch.cpu.txt
+
+COPY app ./app
+COPY models ./models
+COPY main.py ./
+
+EXPOSE 8000
+
+# ENTRYPOINT ["python3", "-m", "uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]
+ENTRYPOINT ["python3", "-m", "uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -0,0 +1,371 @@
+---
+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
+
+**Install `uv`:**
+https://docs.astral.sh/uv/getting-started/installation/
+
+**Local development:**
+```bash
+# Install dependencies
+make setup
+source venv/bin/activate
+
+# Download the example model
+make download
+
+# Run it
+make serve
+```
+
+In a second terminal:
+```bash
+# Process an example input
+./prompt.sh cat.json
+```
+
+Server runs on `http://127.0.0.1:8000`. Check `/docs` for the interactive API documentation.
+
+**Docker:**
+```bash
+# Build
+make docker-build
+
+# Run
+make docker-run
+```
+
+## 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
+{
+  "logprobs": [-0.859380304813385,-1.2701971530914307,-2.1918208599090576,-1.69235098361969],
+  "localizationMask": {
+    "mediaType":"image/png",
+    "data":"iVBORw0KGgoAAAANSUhEUgAAA8AAAAKDAQAAAAD9Fl5AAAAAu0lEQVR4nO3NsREAMAgDMWD/nZMVKEwn1T5/FQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMCl3g5f+HC24TRhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAj70gwKsTlmdBwAAAABJRU5ErkJggg=="
+  }
+}
+```
+
+## Project Structure
+
+```
+example-submission/
+├── main.py                      # Entry point
+├── app/
+│   ├── core/
+│   │   ├── app.py               # <= INSTANTIATE YOUR DETECTOR HERE
+│   │   └── logging.py           # Logging setup
+│   ├── api/
+│   │   ├── models.py            # Request/response schemas
+│   │   ├── controllers.py       # Business logic
+│   │   └── routes/
+│   │       └── prediction.py    # POST /predict
+│   └── services/
+│       ├── base.py              # <= YOUR DETECTOR IMPLEMENTS THIS INTERFACE
+│       └── inference.py         # Example service based on ResNet-18
+├── models/
+│   └── microsoft/
+│       └── resnet-18/           # Model weights and config
+├── scripts/
+│   ├── model_download.bash
+│   ├── generate_test_datasets.py
+│   └── test_datasets.py
+├── Dockerfile
+├── .env.example                 # Environment config template
+├── cat.json                     # An example /predict request object
+├── makefile
+├── prompt.sh                    # Script that makes a /predict request
+├── requirements.in              
+├── requirements.txt
+├── response.json                # An example /predict response object
+└──
+```
+
+## How to Plug In Your Own Model
+
+To integrate your model, implement the `InferenceService` abstract class defined in `app/services/base.py`. You can follow the example implementation in `app/services/inference.py`, which is based on ResNet-18. After implementing the required interface, instantiate your model in the `lifespan()` function in `app/core/app.py`, replacing the `ResNetInferenceService` instance.
+
+### 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
+
+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
+
+    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
+
+    def predict(self, request: ImageRequest) -> PredictionResponse:
+        """Actual inference happens here."""
+        image = decode_base64_image(request.image.data)
+        result = self.model(image)
+
+        logprobs = ...
+        mask = ...
+
+        return PredictionResponse(
+            logprobs=logprobs,
+            localizationMask=mask,
+        )
+
+    @property
+    def is_loaded(self) -> bool:
+        return self._is_loaded
+```
+
+### 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(...)
+```
+
+That's it. The `/predict` endpoint now serves your model.
+
+### Model Files
+
+Put your model files under the `models/` directory:
+
+```
+models/
+└── your-org/
+    └── your-model/
+        ├── config.json
+        ├── weights.bin
+        └── (other files)
+```
+
+## 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 string>"
+  }
+}
+```
+
+**Response:**
+```json
+{
+  "logprobs": [float],         // Log-probabilities of each label
+  "localizationMask": {        // [Optional] binary mask
+    "mediaType": "image/png",  // Always png
+    "data": "<base64 string>"  // Image data
+  }
+}
+```
+
+**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
+make serve
+```
+
+In another terminal:
+
+```bash
+# 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>/`
+- If you're trying to run the example ResNet-based model, make sure you ran `make download` to fetch the model weights.
+- 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,109 @@
+"""
+Pydantic models for request/response validation.
+"""
+
+from __future__ import annotations
+
+import base64
+import enum
+import io
+import typing
+from typing import Literal, Optional
+
+import numpy as np
+import pydantic
+from PIL import Image
+
+if typing.TYPE_CHECKING:
+    from numpy.typing import NDArray
+
+
+class ImageData(pydantic.BaseModel):
+    """Image data model for base64 encoded images."""
+    mediaType: str = pydantic.Field(
+        description="The IETF Media Type (MIME type) of the data"
+    )
+    data: str = pydantic.Field(
+        description="A base64 string encoding of the data.",
+        # 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 BinaryMask(pydantic.BaseModel):
+    """A bit mask indicating which pixels are manipulated / synthesized. A
+    pixel value of ``0`` means "no detection", and a value of ``1`` means
+    "detection".
+    
+    The mask data must be encoded in PNG format, so that typical mask data is
+    compressed effectively. The PNG encoding **should** use "bilevel" mode for
+    maximum compactness. You can use the ``BinaryMask.from_numpy()``
+    function to convert a 0-1 numpy array to a BinaryMask.
+    """
+    mediaType: Literal["image/png"] = pydantic.Field(
+        description="The IETF Media Type (MIME type) of the data."
+    )
+    data: str = pydantic.Field(
+        description="A base64 string encoding of the data.",
+        # 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]=)?$",
+    )
+
+    @staticmethod
+    def from_numpy(mask: NDArray[np.uint8]) -> BinaryMask:
+        """Convert a 0-1 numpy array to a BinaryMask.
+
+        The numpy data must be in row-major order. That means the first
+        dimension corresponds to **height** and the second dimension corresponds
+        to **width**.
+        """
+        # Convert to "L" (grayscale) then "1" (bilevel) for compact binary representation
+        mask_img = Image.fromarray(mask * 255, mode="L").convert("1", dither=None)
+        mask_img_buffer = io.BytesIO()
+        mask_img.save(mask_img_buffer, format="png")
+        mask_data = base64.b64encode(mask_img_buffer.getbuffer()).decode("utf-8")
+        return BinaryMask(mediaType="image/png", data=mask_data)
+
+
+class ImageRequest(pydantic.BaseModel):
+    """Request model for image classification."""
+    image: ImageData
+
+
+class Labels(enum.IntEnum):
+    Natural = 0
+    FullySynthesized = 1
+    LocallyEdited = 2
+    LocallySynthesized = 3
+
+
+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[BinaryMask] = 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,80 @@
+"""FastAPI application factory and core infrastructure."""
+
+import asyncio
+import warnings
+from contextlib import asynccontextmanager
+from typing import AsyncGenerator
+
+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.services.inference_clip import CLIPInferenceService
+
+from app.services.inference_dino import DINOInferenceService
+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")
+            # service = CLIPInferenceService(model_name="clip")
+            service = DINOInferenceService(model_name = "dino")
+            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,92 @@
+"""ResNet inference service implementation."""
+
+import base64
+import os
+from io import BytesIO
+
+import numpy as np
+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 BinaryMask, ImageRequest, Labels, 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))
+
+        if image.mode != 'RGB':
+            image = image.convert('RGB')
+
+        inputs = self.processor(image, return_tensors="pt")
+
+        with torch.no_grad():
+            logits = self.model(**inputs).logits.squeeze()   # pyright: ignore
+
+        # Convert the ImageNet output vector of dimension 1000 to the expected
+        # output format. This is for demonstration purposes
+        # and obviously will not perform well on the actual task.
+        logprobs = torch.nn.functional.log_softmax(logits[:len(Labels)]).tolist()
+       
+        # Dummy localization mask: a rectangle approximately in the middle
+        x = image.width // 3
+        y = image.height // 3
+        # Row-major order
+        mask = np.zeros((image.height, image.width), dtype=np.uint8)
+        mask[y:(2*y), x:(2*x)] = 1
+        mask_obj = BinaryMask.from_numpy(mask)
+
+        return PredictionResponse(
+            logprobs=logprobs,
+            localizationMask=mask_obj,
+        )
+
+    @property
+    def is_loaded(self) -> bool:
+        return self._is_loaded

app/services/inference_clip.py

@@ -0,0 +1,171 @@
+"""ResNet inference service implementation."""
+
+import base64
+import os
+from io import BytesIO
+
+import numpy as np
+import torch
+import torchvision.transforms as transforms
+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 BinaryMask, ImageRequest, Labels, PredictionResponse
+
+from app.services.models.alignment_pretrained.unet import UNetImageDecoder
+from app.services.models.CLIPSvD import CLIPSvD
+from app.services.models.alignment_pretrained.model_with_bce_images_blip import MMModerator
+
+
+class CLIPDINOProcessor:
+    """Image processor for CLIP and DINO models with 224x224 resizing and normalization."""
+    
+    def __init__(self, image_size: int = 224):
+        self.image_size = image_size
+        # Standard ImageNet normalization used by both CLIP and DINO
+        self.transform = transforms.Compose([
+            transforms.Resize((image_size, image_size), interpolation=transforms.InterpolationMode.BICUBIC),
+            transforms.ToTensor(),
+            transforms.Normalize(
+                mean=[0.485, 0.456, 0.406],  # ImageNet mean
+                std=[0.229, 0.224, 0.225]    # ImageNet std
+            )
+        ])
+    
+    def __call__(self, image: Image.Image, return_tensors: str = "pt"):
+        """
+        Process an image for CLIP/DINO input.
+        
+        Args:
+            image: PIL Image object
+            return_tensors: Format of returned tensors (default: "pt" for PyTorch)
+        
+        Returns:
+            Dictionary with 'pixel_values' key containing the processed tensor
+        """
+        if not isinstance(image, Image.Image):
+            raise ValueError("Input must be a PIL Image")
+        
+        # Apply transforms
+        pixel_values = self.transform(image)
+        
+        # Add batch dimension if needed
+        if pixel_values.dim() == 3:
+            pixel_values = pixel_values.unsqueeze(0)
+        
+        return {"pixel_values": pixel_values}
+
+
+def create_vision_encoder():
+    REPO_DIR = "/media/NAS/USERS/shahid/MultimodalAudioVisualModerator/dinov3"
+    model = CLIPSvD()
+    return model
+
+          
+
+class CLIPInferenceService(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 = CLIPDINOProcessor(image_size=224)
+        self._is_loaded = False
+        self.model_path = os.path.join("models", model_name)
+
+        pretraining = False
+        num_classes = 4
+        self.vision_encoder = create_vision_encoder()
+        # self.vision_encoder.to(device=device, dtype=torch.float32)
+        self.unet_decoder = UNetImageDecoder(
+                num_patches=256,       # 7 × 7 grid (ViT-B/32)
+                token_dim=1024,        # ViT-B/32 embedding dim
+                out_channels=3,       # mask or 3 for RGB
+                base_channels=256,
+                img_size=256,
+                grid_hw=(16, 16)        # explicitly set to match patch grid
+            )
+        self.model = MMModerator(pretraining=pretraining,vision_encoder=self.vision_encoder, unet_decoder=self.unet_decoder, num_classes=num_classes)
+        logger.info(f"Initializing CLIP 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}")
+        checkpoint_path = os.path.join(self.model_path, "model_state.pt")
+        checkpoint_path_encoder = os.path.join(self.model_path, "model_state_encoder.pt")
+        checkpoint_path_decoder = os.path.join(self.model_path, "model_state_decoder.pt")
+        raw   = torch.load(checkpoint_path)
+        raw_encoder   = torch.load(checkpoint_path_encoder)
+        raw_decoder   = torch.load(checkpoint_path_decoder)
+        sd    = raw.get("model_state_dict", raw)
+        new_sd = {}
+        for k, v in sd.items():
+            new_key = k.replace("module.", "")  
+            new_sd[new_key] = v
+            
+        self.model.load_state_dict(new_sd) 
+        sd_encoder    = raw_encoder.get("model_state_dict", raw_encoder)
+        new_sd_encoder = {}
+        for k, v in sd_encoder.items():
+            new_key = k.replace("module.", "")  
+            new_sd_encoder[new_key] = v
+        self.vision_encoder.load_state_dict(new_sd_encoder)
+        sd_decoder    = raw_decoder.get("model_state_dict", raw_decoder)
+        new_sd_decoder = {}
+        for k, v in sd_decoder.items():
+            new_key = k.replace("module.", "")  
+            new_sd_decoder[new_key] = v
+        self.unet_decoder.load_state_dict(new_sd_decoder)        # strict=True by default
+        
+        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))
+        if image.mode != 'RGB':
+            image = image.convert('RGB')
+
+        processed = self.processor(image, return_tensors="pt")
+        pixel_values = processed["pixel_values"]
+       
+        self.model.eval()
+        with torch.no_grad():
+            # logits, losses, label, image_recon, overlay = 
+            logits_cls,logits, losses, labels_expanded,data_labels_expanded, image_recon, overlay = self.model(images=pixel_values)
+        
+        logprobs = torch.nn.functional.log_softmax(logits[:len(Labels)]).tolist()[0]
+        
+        # x = image.width // 3
+        # y = image.height // 3
+        # # Row-major order
+        # mask = np.zeros((image.height, image.width), dtype=np.uint8)
+        # mask[y:(2*y), x:(2*x)] = 1
+        # mask_obj = BinaryMask.from_numpy(image_recon.cpu().numpy())
+        # mask_obj = BinaryMask.from_numpy(image_recon.cpu().numpy())
+        print(logprobs)
+        return PredictionResponse(
+            logprobs=logprobs,
+            localizationMask=None,
+        )
+
+    @property
+    def is_loaded(self) -> bool:
+        return self._is_loaded

app/services/inference_dino.py

@@ -0,0 +1,177 @@
+"""ResNet inference service implementation."""
+
+import base64
+import os
+from io import BytesIO
+
+import numpy as np
+import torch
+import torchvision.transforms as transforms
+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 BinaryMask, ImageRequest, Labels, PredictionResponse
+
+from app.services.models.alignment_pretrained.unet import UNetImageDecoder
+
+from app.services.models.DinoLORA import DINOEncoderLoRA
+from app.services.models.alignment_pretrained.model_with_bce_images_dino import MMModerator
+
+
+class DINODINOProcessor:
+    """Image processor for DINO and DINO models with 224x224 resizing and normalization."""
+    
+    def __init__(self, image_size: int = 512):
+        self.image_size = image_size
+        # Standard ImageNet normalization used by both DINO and DINO
+        self.transform = transforms.Compose([
+            transforms.Resize((image_size, image_size), interpolation=transforms.InterpolationMode.BICUBIC),
+            transforms.ToTensor(),
+            transforms.Normalize(
+                mean=[0.485, 0.456, 0.406],  # ImageNet mean
+                std=[0.229, 0.224, 0.225]    # ImageNet std
+            )
+        ])
+    
+    def __call__(self, image: Image.Image, return_tensors: str = "pt"):
+        """
+        Process an image for DINO/DINO input.
+        
+        Args:
+            image: PIL Image object
+            return_tensors: Format of returned tensors (default: "pt" for PyTorch)
+        
+        Returns:
+            Dictionary with 'pixel_values' key containing the processed tensor
+        """
+        if not isinstance(image, Image.Image):
+            raise ValueError("Input must be a PIL Image")
+        
+        # Apply transforms
+        pixel_values = self.transform(image)
+        
+        # Add batch dimension if needed
+        if pixel_values.dim() == 3:
+            pixel_values = pixel_values.unsqueeze(0)
+        
+        return {"pixel_values": pixel_values}
+
+
+def create_vision_encoder():
+    REPO_DIR = "/media/NAS/USERS/shahid/MultimodalAudioVisualModerator/dinov3"
+    
+    
+    encoder = torch.hub.load(REPO_DIR, 'dinov3_vitb16', source='local', weights="https://dinov3.llamameta.net/dinov3_vitb16/dinov3_vitb16_pretrain_lvd1689m-73cec8be.pth?Policy=eyJTdGF0ZW1lbnQiOlt7InVuaXF1ZV9oYXNoIjoib3VpbXR2cHlhZXE5c2JwajNucnN3aWF2IiwiUmVzb3VyY2UiOiJodHRwczpcL1wvZGlub3YzLmxsYW1hbWV0YS5uZXRcLyoiLCJDb25kaXRpb24iOnsiRGF0ZUxlc3NUaGFuIjp7IkFXUzpFcG9jaFRpbWUiOjE3NTk5MDI0NDF9fX1dfQ__&Signature=GIYJR4%7ESJVx0gkcm7lgAvDljIfpR30MXgWb2VpCqbDeVpnwjn97k%7EOcPeGF-lkR0q1Sn3Iw5Y3iYWqspcpPoDJ4FXUmMKhWtd-m00HO73Aknq2kyrKVMBpzwQB-k-2zZe7okJfXTj46EWbzu9mNcxt%7ErDPe7phQpRJi8Dleida1BJ823oXFx8d7oRSa4NDSzT2TNXqNNZ8ux7N0aDfdT9dupEeEr4AP06LhYB2I7kF%7Ef4bvKQsKnlPMVDAADyYG9nQ7HqAW41LaWZtR-BrDGm%7ESNu-6L44cUVnk3qEPVRMQB4GW7ixRGGhtr37F6HVz%7EKilrCpivFD6ej4reNUWaGQ__&Key-Pair-Id=K15QRJLYKIFSLZ&Download-Request-ID=829796286371500")
+    model = DINOEncoderLoRA(encoder, r=16, emb_dim=1024, use_lora=True)
+    return model
+
+          
+
+class DINOInferenceService(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 = DINODINOProcessor(image_size=512)
+        self._is_loaded = False
+        self.model_path = os.path.join("models", model_name)
+
+        pretraining = False
+        num_classes = 4
+        self.vision_encoder = create_vision_encoder()
+        # self.vision_encoder.to(device=device, dtype=torch.float32)
+            
+        self.unet_decoder = UNetImageDecoder(
+            num_patches=1024,      # MUST match N=1024
+            token_dim=768,         # because tokens are [B,1024,768]
+            out_channels=1,        # RGB reconstructed output
+            base_channels=128,     # recommended for 512px
+            img_size=512,          # image resolution
+            grid_hw=(32, 32)       # MUST match N=1024
+        )
+        self.model = MMModerator(pretraining=pretraining,vision_encoder=self.vision_encoder, unet_decoder=self.unet_decoder, num_classes=num_classes)
+        self.model.eval()
+        logger.info(f"Initializing DINO 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}")
+        checkpoint_path = os.path.join(self.model_path, "model_state.pt")
+        checkpoint_path_encoder = os.path.join(self.model_path, "model_state_encoder.pt")
+        checkpoint_path_decoder = os.path.join(self.model_path, "model_state_decoder.pt")
+        raw   = torch.load(checkpoint_path)
+        raw_encoder   = torch.load(checkpoint_path_encoder)
+        raw_decoder   = torch.load(checkpoint_path_decoder)
+        sd    = raw.get("model_state_dict", raw)
+        new_sd = {}
+        for k, v in sd.items():
+            new_key = k.replace("module.", "")  
+            new_sd[new_key] = v
+            
+        self.model.load_state_dict(new_sd) 
+        sd_encoder    = raw_encoder.get("model_state_dict", raw_encoder)
+        new_sd_encoder = {}
+        for k, v in sd_encoder.items():
+            new_key = k.replace("module.", "")  
+            new_sd_encoder[new_key] = v
+        self.vision_encoder.load_state_dict(new_sd_encoder)
+        sd_decoder    = raw_decoder.get("model_state_dict", raw_decoder)
+        new_sd_decoder = {}
+        for k, v in sd_decoder.items():
+            new_key = k.replace("module.", "")  
+            new_sd_decoder[new_key] = v
+        self.unet_decoder.load_state_dict(new_sd_decoder)        # strict=True by default
+        
+        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))
+        if image.mode != 'RGB':
+            image = image.convert('RGB')
+
+        processed = self.processor(image, return_tensors="pt")
+        pixel_values = processed["pixel_values"]
+       
+        self.model.eval()
+        with torch.no_grad():
+            # logits, losses, label, image_recon, overlay = 
+            logits,logits_multi_cls, losses, label,data_label, image_recon, overlay, shuffled_images, gt_masks  = self.model(images=pixel_values)
+        
+        logprobs = torch.nn.functional.log_softmax(logits_multi_cls[:len(Labels)]).tolist()[0]
+        
+        # x = image.width // 3
+        # y = image.height // 3
+        # # Row-major order
+        # mask = np.zeros((image.height, image.width), dtype=np.uint8)
+        # mask[y:(2*y), x:(2*x)] = 1
+        # mask_obj = BinaryMask.from_numpy(image_recon.cpu().numpy())
+        # mask_obj = BinaryMask.from_numpy(image_recon.cpu().numpy())
+        print(logprobs)
+        return PredictionResponse(
+            logprobs=logprobs,
+            localizationMask=None,
+        )
+
+    @property
+    def is_loaded(self) -> bool:
+        return self._is_loaded

challenge-cli.py

@@ -0,0 +1,310 @@
+# SPDX-FileCopyrightText: 2025 UL Research Institutes
+# SPDX-License-Identifier: Apache-2.0
+
+import functools
+import time
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+
+import click
+import httpx
+
+from dyff.client import Client, errors
+from dyff.schema.platform import *
+from dyff.schema.requests import *
+
+from app.api.models import PredictionResponse
+
+# ----------------------------------------------------------------------------
+
+
+def _wait_for_status(
+    get_entity_fn, target_status: str | list[str], *, timeout: timedelta
+) -> str:
+    if isinstance(target_status, str):
+        target_status = [target_status]
+    then = datetime.now(timezone.utc)
+    while True:
+        try:
+            status = get_entity_fn().status
+            if status in target_status:
+                return status
+        except errors.HTTPError as ex:
+            if ex.status != 404:
+                raise
+        except httpx.HTTPStatusError as ex:
+            if ex.response.status_code != 404:
+                raise
+        if (datetime.now(timezone.utc) - then) >= timeout:
+            break
+        time.sleep(5)
+    raise AssertionError("timeout")
+
+
+def _common_options(f):
+    @click.option(
+        "--account",
+        type=str,
+        required=True,
+        help="Your account ID",
+        metavar="ID",
+    )
+    @functools.wraps(f)
+    def wrapper(*args, **kwargs):
+        return f(*args, **kwargs)
+    return wrapper
+
+
+@click.group()
+def cli():
+    pass
+
+
+@cli.command()
+@_common_options
+@click.option(
+    "--name",
+    type=str,
+    required=True,
+    help="The name of your detector model. For display and querying purposes only.",
+)
+@click.option(
+    "--image",
+    type=str,
+    default=None,
+    help="The Docker image to upload (e.g., 'some/image:latest')."
+    " Must exist in your local Docker deamon."
+    " Required if --artifact is not specified.",
+)
+@click.option(
+    "--endpoint",
+    type=str,
+    default="predict",
+    help="The endpoint to call on your service to make a prediction.",
+)
+@click.option(
+    "--volume",
+    type=click.Path(exists=True, file_okay=False, readable=True, resolve_path=True, path_type=Path),
+    default=None,
+    help="A local directory path containing files to upload and mount in the running Docker container."
+    " You should use this if your submission includes large files like neural network weights."
+)
+@click.option(
+    "--volume-mount",
+    type=click.Path(exists=False, path_type=Path),
+    default=None,
+    help="The path to mount your uploaded directory in the running Docker container."
+    " Must be an absolute path."
+    " Required if --volume is specified.")
+@click.option(
+    "--artifact",
+    "artifact_id",
+    type=str,
+    default=None,
+    help="The ID of the Artifact (i.e., Docker image) to use in the submission, if it already exists."
+    " You can pass the artifact.id from a previous invocation.",
+    metavar="ID",
+)
+@click.option(
+    "--model",
+    "model_id",
+    type=str,
+    default=None,
+    help="The ID of the Model (i.e., neural network weights) to use in the submission, if it already exists."
+    " You can pass the model.id from a previous invocation.",
+    metavar="ID",
+)
+@click.option(
+    "--gpu",
+    is_flag=True,
+    default=False,
+    help="Request a GPU (NVIDIA L4) for the inference service.",
+)
+def upload_submission(
+    account: str,
+    name: str,
+    image: str | None,
+    endpoint: str,
+    volume: Path | None,
+    volume_mount: Path | None,
+    artifact_id: str | None,
+    model_id: str | None,
+    gpu: bool,
+) -> None:
+    dyffapi = Client()
+
+    # Upload the image
+    if artifact_id is None:
+        # Create an Artifact resource
+        click.echo(f"creating Artifact ... {account}")
+        artifact = dyffapi.artifacts.create(ArtifactCreateRequest(account=account))
+        click.echo(f"artifact.id: \"{artifact.id}\"")
+        _wait_for_status(
+            lambda: dyffapi.artifacts.get(artifact.id),
+            "WaitingForUpload",
+            timeout=timedelta(seconds=30),
+        )
+
+        # Push the image from the local Docker daemon
+        click.echo("pushing Artifact ...")
+        dyffapi.artifacts.push(artifact, source=f"docker-daemon:{image}")
+        time.sleep(5)
+
+        # Indicate that we're done pushing
+        dyffapi.artifacts.finalize(artifact.id)
+        _wait_for_status(
+            lambda: dyffapi.artifacts.get(artifact.id),
+            "Ready",
+            timeout=timedelta(seconds=30),
+        )
+
+        click.echo("... done")
+    else:
+        artifact = dyffapi.artifacts.get(artifact_id)
+        assert artifact is not None
+
+    model: Model | None = None
+    if model_id is None:
+        if volume is not None:
+            if volume_mount is None:
+                raise click.UsageError("--volume-mount is required when --volume is used")
+            
+            click.echo("creating Model from local directory ...")
+
+            model = dyffapi.models.create_from_volume(
+                volume, name="model_volume", account=account, resources=ModelResources()
+            )
+            click.echo(f"model.id: \"{model.id}\"")
+            _wait_for_status(
+                lambda: dyffapi.models.get(model.id),
+                "WaitingForUpload",
+                timeout=timedelta(seconds=30),
+            )
+
+            click.echo("uploading Model ...")
+            dyffapi.models.upload_volume(model, volume)
+            _wait_for_status(
+                lambda: dyffapi.models.get(model.id),
+                "Ready",
+                timeout=timedelta(seconds=30),
+            )
+
+            click.echo("... done")
+        else:
+            model = None
+    else:
+        model = dyffapi.models.get(model_id)
+        assert model is not None
+
+    # Create a runnable InferenceService
+    if volume_mount is not None:
+        if model is None:
+            raise click.UsageError("--volume-mount requires --volume or --model")
+        if not volume_mount.is_absolute():
+            raise click.UsageError("--volume-mount must be an absolute path")
+        volumeMounts=[
+            VolumeMount(
+                kind=VolumeMountKind.data,
+                name="model",
+                mountPath=volume_mount,
+                data=VolumeMountData(
+                    source=EntityIdentifier.of(model),
+                ),
+            ),
+        ]
+    else:
+        volumeMounts = None
+
+    accelerator: Accelerator | None = None
+    if gpu:
+        accelerator = Accelerator(
+            kind="GPU",
+            gpu=AcceleratorGPU(
+                hardwareTypes=["nvidia.com/gpu-l4"],
+                count=1,
+            ),
+        )
+
+    # Don't change this
+    service_request = InferenceServiceCreateRequest(
+        account=account,
+        name=name,
+        model=None,
+        runner=InferenceServiceRunner(
+            kind=InferenceServiceRunnerKind.CONTAINER,
+            imageRef=EntityIdentifier.of(artifact),
+            resources=ModelResources(),
+            volumeMounts=volumeMounts,
+            accelerator=accelerator,
+        ),
+        interface=InferenceInterface(
+            endpoint=endpoint,
+            outputSchema=DataSchema.make_output_schema(PredictionResponse),
+        ),
+    )
+    click.echo("creating InferenceService ...")
+    service = dyffapi.inferenceservices.create(service_request)
+    click.echo(f"service.id: \"{service.id}\"")
+    click.echo("... done")
+
+
+@cli.command()
+@_common_options
+@click.option(
+    "--task",
+    "task_id",
+    type=str,
+    required=True,
+    help="The Task ID to submit to.",
+    metavar="ID",
+)
+@click.option(
+    "--team",
+    "team_id",
+    type=str,
+    required=True,
+    help="The Team ID making the submission.",
+    metavar="ID",
+)
+@click.option(
+    "--service",
+    "service_id",
+    type=str,
+    required=True,
+    help="The InferenceService ID to submit.",
+    metavar="ID",
+)
+@click.option(
+    "--challenge",
+    "challenge_id",
+    type=str,
+    default="dc509a8c771b492b90c43012fde9a04f",
+    help="The Challenge ID to submit to.",
+    metavar="ID",
+)
+def submit(account: str, task_id: str, team_id: str, service_id: str, challenge_id: str) -> None:
+    dyffapi = Client()
+
+    challenge = dyffapi.challenges.get(challenge_id)
+    # print(challenge)
+    challengetask = challenge.tasks[task_id]
+
+    team = dyffapi.teams.get(team_id)
+
+    service = dyffapi.inferenceservices.get(service_id)
+
+    submission = dyffapi.challenges.submit(
+        challenge.id,
+        challengetask.id,
+        SubmissionCreateRequest(
+            account=account,
+            team=team.id,
+            submission=EntityIdentifier(kind="InferenceService", id=service.id),
+        ),
+    )
+    click.echo(submission.model_dump_json(indent=2))
+    click.echo(f"submission.id: \"{submission.id}\"")
+
+
+if __name__ == "__main__":
+    cli(show_default=True)

delete_corrupted_files.py

@@ -0,0 +1,55 @@
+import os
+import cv2
+from PIL import Image
+
+def is_image_corrupted(path):
+    """
+    Returns True if the image cannot be opened by cv2 or PIL.
+    """
+    # ---- Try reading with OpenCV ----
+    img = cv2.imread(path)
+    if img is None:
+        return True  # cv2 failed to decode
+
+    # ---- Try reading with PIL ----
+    try:
+        with Image.open(path) as im:
+            im.verify()  # Validate without fully loading
+    except Exception:
+        return True  # PIL failed to open / verify
+
+    return False  # Image is valid
+
+
+def delete_corrupted_images(directory):
+    """
+    Deletes all unreadable / corrupted images in the directory.
+    """
+    valid_extensions = {".jpg", ".jpeg", ".png", ".bmp", ".tiff", ".webp"}
+
+    deleted_count = 0
+
+    for filename in os.listdir(directory):
+        path = os.path.join(directory, filename)
+
+        # Skip folders
+        if not os.path.isfile(path):
+            continue
+
+        # Check valid image extensions
+        ext = os.path.splitext(filename)[1].lower()
+        if ext not in valid_extensions:
+            continue
+
+        # Check corruption
+        if is_image_corrupted(path):
+            print(f"Deleting corrupted image: {filename}")
+            os.remove(path)
+            deleted_count += 1
+
+    print(f"\nDone. Deleted {deleted_count} corrupted images.")
+
+
+# --------- RUN ----------
+directory = "/media/NAS/DATASET/wacv_safe_challenge_2025_dataset/physical_fakes/PS-Battles/originals/"   # <-- change this
+delete_corrupted_images(directory)

main.py

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

makefile

@@ -0,0 +1,58 @@
+VENV ?= venv
+PYTHON ?= $(VENV)/bin/python3
+UVICORN ?= $(VENV)/bin/uvicorn
+DOCKER ?= docker
+IMAGE ?= safe-challenge-2025/example-submission
+GID ?= $(shell id -g)
+UID ?= $(shell id -u)
+
+.PHONY: setup
+setup: $(VENV)/requirements.cpu.txt
+
+.PHONY: download
+download:
+	bash scripts/model_download.bash
+
+.PHONY: serve
+serve:
+	$(UVICORN) main:app
+
+.PHONY: docker-build
+docker-build:
+	docker build -t $(IMAGE) .
+
+.PHONY: docker-run
+docker-run:
+	docker run --rm -it -p 8000:8000 $(IMAGE)
+
+.PHONY: compile
+compile:
+	uv pip compile --python-version 3.12 --upgrade -o requirements.torch.cpu.txt.tmp requirements.torch.cpu.in
+	echo "--index-url https://download.pytorch.org/whl/cpu" > requirements.torch.cpu.txt
+	grep -e '^torch' requirements.torch.cpu.txt.tmp >> requirements.torch.cpu.txt
+	uv pip compile --python-version 3.12 --upgrade -o requirements.cpu.txt requirements.cpu.in
+
+.PHONY: compile-gpu
+compile-gpu:
+	uv pip compile --python-version 3.12 --upgrade -o requirements.torch.gpu.txt requirements.torch.gpu.in
+
+.PHONY: docker-build-gpu
+docker-build-gpu:
+	docker build -t $(IMAGE)-gpu -f Dockerfile.gpu .
+
+requirements.cpu.txt: requirements.in requirements.torch.cpu.txt | $(VENV)
+	uv pip compile --python-version 3.12 --upgrade -o requirements.cpu.txt requirements.cpu.in
+
+requirements.torch.cpu.txt: requirements.torch.cpu.in | $(VENV)
+	uv pip compile --python-version 3.12 --upgrade -o requirements.torch.cpu.txt.tmp requirements.torch.cpu.in
+	echo "--index-url https://download.pytorch.org/whl/cpu" > requirements.torch.cpu.txt
+	cat requirements.torch.cpu.txt.tmp | grep '^torch' >> requirements.torch.cpu.txt
+
+$(VENV)/requirements.cpu.txt: requirements.cpu.txt | $(VENV)
+	VIRTUAL_ENV=$(VENV) uv pip install -r requirements.cpu.txt
+	VIRTUAL_ENV=$(VENV) uv pip install -r requirements.torch.cpu.txt
+	cp -f requirements.cpu.txt $(VENV)/requirements.cpu.txt
+	cp -f requirements.torch.cpu.txt $(VENV)/requirements.torch.cpu.txt
+
+$(VENV):
+	uv venv $(VENV)

prompt.sh

@@ -0,0 +1,6 @@
+#!/bin/bash
+
+curl -X POST http://localhost:8000/predict \
+    -H "Content-Type: application/json" \
+    -d @"$1"
+

requirements copy.txt

@@ -0,0 +1,26 @@
+
+numpy==1.26.1
+pandas==2.2.1
+scipy==1.12.0
+
+torch==2.4.0
+torchvision==0.19.0
+torchaudio==2.4.0
+
+opencv-contrib-python==4.11.0.86
+av==14.0.1
+decord
+kornia==0.7.4
+timm
+einops
+beartype
+lpips==0.1.4
+imageio
+
+audiomentations==0.36.0
+librosa==0.10.2.post1
+soundfile==0.12.1
+
+transformers==4.49.0
+datasets==3.5.1
+tqdm

requirements.cpu.in

@@ -0,0 +1 @@
+-r requirements.in

requirements.cpu.txt

@@ -0,0 +1,561 @@
+# This file was autogenerated by uv via the following command:
+#    uv pip compile --python-version 3.12 -o requirements.cpu.txt requirements.cpu.in
+absl-py==2.3.1
+    # via dyff-client
+annotated-doc==0.0.4
+    # via fastapi
+annotated-types==0.7.0
+    # via pydantic
+anyio==4.12.0
+    # via
+    #   httpx
+    #   jupyter-server
+    #   starlette
+    #   watchfiles
+argon2-cffi==25.1.0
+    # via jupyter-server
+argon2-cffi-bindings==25.1.0
+    # via argon2-cffi
+arrow==1.4.0
+    # via isoduration
+asttokens==3.0.1
+    # via stack-data
+async-lru==2.0.5
+    # via jupyterlab
+attrs==25.4.0
+    # via
+    #   jsonschema
+    #   referencing
+azure-core==1.36.0
+    # via dyff-client
+babel==2.17.0
+    # via jupyterlab-server
+beartype==0.22.8
+    # via -r requirements.in
+beautifulsoup4==4.14.3
+    # via
+    #   dyff-audit
+    #   nbconvert
+bleach==6.3.0
+    # via nbconvert
+canonicaljson==2.0.0
+    # via dyff-schema
+certifi==2025.11.12
+    # via
+    #   httpcore
+    #   httpx
+    #   requests
+cffi==2.0.0
+    # via argon2-cffi-bindings
+charset-normalizer==3.4.4
+    # via requests
+click==8.3.1
+    # via
+    #   -r requirements.in
+    #   uvicorn
+comm==0.2.3
+    # via ipykernel
+contourpy==1.3.3
+    # via matplotlib
+cycler==0.12.1
+    # via matplotlib
+debugpy==1.8.17
+    # via ipykernel
+decorator==5.2.1
+    # via ipython
+defusedxml==0.7.1
+    # via nbconvert
+dnspython==2.8.0
+    # via email-validator
+dyff-audit==0.16.7
+    # via -r requirements.in
+dyff-client==0.23.9
+    # via
+    #   -r requirements.in
+    #   dyff-audit
+dyff-schema==0.40.1
+    # via
+    #   -r requirements.in
+    #   dyff-audit
+    #   dyff-client
+einops==0.8.1
+    # via -r requirements.in
+email-validator==2.3.0
+    # via dyff-schema
+executing==2.2.1
+    # via stack-data
+fastapi==0.124.1
+    # via -r requirements.in
+fastjsonschema==2.21.2
+    # via nbformat
+filelock==3.20.0
+    # via
+    #   huggingface-hub
+    #   torch
+    #   transformers
+fonttools==4.61.0
+    # via matplotlib
+fqdn==1.5.1
+    # via jsonschema
+fsspec==2025.12.0
+    # via
+    #   huggingface-hub
+    #   torch
+google-i18n-address==3.1.1
+    # via dyff-schema
+h11==0.16.0
+    # via
+    #   httpcore
+    #   uvicorn
+hf-xet==1.2.0
+    # via huggingface-hub
+httpcore==1.0.9
+    # via httpx
+httptools==0.7.1
+    # via uvicorn
+httpx==0.28.1
+    # via
+    #   dyff-client
+    #   jupyterlab
+huggingface-hub==0.36.0
+    # via
+    #   timm
+    #   tokenizers
+    #   transformers
+hypothesis==6.148.7
+    # via
+    #   dyff-schema
+    #   hypothesis-jsonschema
+hypothesis-jsonschema==0.23.1
+    # via dyff-schema
+idna==3.11
+    # via
+    #   anyio
+    #   email-validator
+    #   httpx
+    #   jsonschema
+    #   requests
+ipykernel==7.1.0
+    # via jupyterlab
+ipython==9.8.0
+    # via ipykernel
+ipython-pygments-lexers==1.1.1
+    # via ipython
+isodate==0.7.2
+    # via dyff-client
+isoduration==20.11.0
+    # via jsonschema
+jedi==0.19.2
+    # via ipython
+jinja2==3.1.6
+    # via
+    #   jupyter-server
+    #   jupyterlab
+    #   jupyterlab-server
+    #   nbconvert
+    #   torch
+json5==0.12.1
+    # via jupyterlab-server
+jsonpath-ng==1.7.0
+    # via
+    #   dyff-client
+    #   dyff-schema
+jsonpointer==3.0.0
+    # via jsonschema
+jsonschema==4.25.1
+    # via
+    #   hypothesis-jsonschema
+    #   jupyter-events
+    #   jupyterlab-server
+    #   nbformat
+jsonschema-specifications==2025.9.1
+    # via jsonschema
+jupyter-client==8.7.0
+    # via
+    #   ipykernel
+    #   jupyter-server
+    #   nbclient
+jupyter-core==5.9.1
+    # via
+    #   ipykernel
+    #   jupyter-client
+    #   jupyter-server
+    #   jupyterlab
+    #   nbclient
+    #   nbconvert
+    #   nbformat
+jupyter-events==0.12.0
+    # via jupyter-server
+jupyter-lsp==2.3.0
+    # via jupyterlab
+jupyter-server==2.17.0
+    # via
+    #   jupyter-lsp
+    #   jupyterlab
+    #   jupyterlab-server
+    #   notebook
+    #   notebook-shim
+jupyter-server-terminals==0.5.3
+    # via jupyter-server
+jupyterlab==4.5.0
+    # via notebook
+jupyterlab-pygments==0.3.0
+    # via nbconvert
+jupyterlab-server==2.28.0
+    # via
+    #   jupyterlab
+    #   notebook
+kiwisolver==1.4.9
+    # via matplotlib
+lark==1.3.1
+    # via rfc3987-syntax
+lpips==0.1.4
+    # via -r requirements.in
+lxml==6.0.2
+    # via dyff-audit
+markupsafe==3.0.3
+    # via
+    #   jinja2
+    #   nbconvert
+matplotlib==3.10.7
+    # via -r requirements.in
+matplotlib-inline==0.2.1
+    # via
+    #   ipykernel
+    #   ipython
+mistune==3.1.4
+    # via nbconvert
+mpmath==1.3.0
+    # via sympy
+nbclient==0.10.2
+    # via nbconvert
+nbconvert==7.16.6
+    # via
+    #   dyff-audit
+    #   jupyter-server
+nbformat==5.10.4
+    # via
+    #   dyff-audit
+    #   jupyter-server
+    #   nbclient
+    #   nbconvert
+nest-asyncio==1.6.0
+    # via ipykernel
+networkx==3.6.1
+    # via torch
+notebook==7.5.0
+    # via dyff-audit
+notebook-shim==0.2.4
+    # via
+    #   jupyterlab
+    #   notebook
+numpy==1.26.4
+    # via
+    #   -r requirements.in
+    #   contourpy
+    #   dyff-audit
+    #   dyff-client
+    #   dyff-schema
+    #   lpips
+    #   matplotlib
+    #   opencv-python
+    #   pandas
+    #   scipy
+    #   torchvision
+    #   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.5
+    # via torch
+nvidia-nvjitlink-cu12==12.8.93
+    # via
+    #   nvidia-cufft-cu12
+    #   nvidia-cusolver-cu12
+    #   nvidia-cusparse-cu12
+    #   torch
+nvidia-nvshmem-cu12==3.3.20
+    # via torch
+nvidia-nvtx-cu12==12.8.90
+    # via torch
+opencv-python==4.11.0.86
+    # via -r requirements.in
+packaging==25.0
+    # via
+    #   huggingface-hub
+    #   ipykernel
+    #   jupyter-events
+    #   jupyter-server
+    #   jupyterlab
+    #   jupyterlab-server
+    #   matplotlib
+    #   nbconvert
+    #   transformers
+pandas==2.3.3
+    # via
+    #   -r requirements.in
+    #   dyff-audit
+    #   dyff-client
+pandocfilters==1.5.1
+    # via nbconvert
+parso==0.8.5
+    # via jedi
+pexpect==4.9.0
+    # via ipython
+pillow==12.0.0
+    # via
+    #   -r requirements.in
+    #   matplotlib
+    #   torchvision
+platformdirs==4.5.1
+    # via jupyter-core
+ply==3.11
+    # via jsonpath-ng
+prometheus-client==0.23.1
+    # via jupyter-server
+prompt-toolkit==3.0.52
+    # via ipython
+psutil==7.1.3
+    # via ipykernel
+ptyprocess==0.7.0
+    # via
+    #   pexpect
+    #   terminado
+pure-eval==0.2.3
+    # via stack-data
+pyarrow==22.0.0
+    # via
+    #   -r requirements.in
+    #   dyff-audit
+    #   dyff-client
+    #   dyff-schema
+pycparser==2.23
+    # via cffi
+pydantic==2.12.5
+    # via
+    #   -r requirements.in
+    #   dyff-audit
+    #   dyff-client
+    #   dyff-schema
+    #   fastapi
+    #   pydantic-settings
+pydantic-core==2.41.5
+    # via pydantic
+pydantic-settings==2.12.0
+    # via -r requirements.in
+pygments==2.19.2
+    # via
+    #   ipython
+    #   ipython-pygments-lexers
+    #   nbconvert
+pyparsing==3.2.5
+    # via matplotlib
+python-dateutil==2.9.0.post0
+    # via
+    #   arrow
+    #   jupyter-client
+    #   matplotlib
+    #   pandas
+python-dotenv==1.2.1
+    # via
+    #   -r requirements.in
+    #   pydantic-settings
+    #   uvicorn
+python-json-logger==4.0.0
+    # via jupyter-events
+python-multipart==0.0.20
+    # via -r requirements.in
+pytz==2025.2
+    # via pandas
+pyyaml==6.0.3
+    # via
+    #   huggingface-hub
+    #   jupyter-events
+    #   timm
+    #   transformers
+    #   uvicorn
+pyzmq==27.1.0
+    # via
+    #   ipykernel
+    #   jupyter-client
+    #   jupyter-server
+referencing==0.37.0
+    # via
+    #   jsonschema
+    #   jsonschema-specifications
+    #   jupyter-events
+regex==2025.11.3
+    # via transformers
+requests==2.32.5
+    # via
+    #   -r requirements.in
+    #   azure-core
+    #   google-i18n-address
+    #   huggingface-hub
+    #   jupyterlab-server
+    #   transformers
+rfc3339-validator==0.1.4
+    # via
+    #   jsonschema
+    #   jupyter-events
+rfc3986-validator==0.1.1
+    # via
+    #   jsonschema
+    #   jupyter-events
+rfc3987-syntax==1.1.0
+    # via jsonschema
+rpds-py==0.30.0
+    # via
+    #   jsonschema
+    #   referencing
+ruamel-yaml==0.18.16
+    # via dyff-audit
+ruamel-yaml-clib==0.2.15
+    # via ruamel-yaml
+safetensors==0.7.0
+    # via
+    #   timm
+    #   transformers
+scipy==1.16.3
+    # via lpips
+send2trash==1.8.3
+    # via jupyter-server
+setuptools==80.9.0
+    # via
+    #   jupyterlab
+    #   torch
+six==1.17.0
+    # via
+    #   python-dateutil
+    #   rfc3339-validator
+sortedcontainers==2.4.0
+    # via hypothesis
+soupsieve==2.8
+    # via beautifulsoup4
+stack-data==0.6.3
+    # via ipython
+starlette==0.50.0
+    # via fastapi
+sympy==1.14.0
+    # via torch
+terminado==0.18.1
+    # via
+    #   jupyter-server
+    #   jupyter-server-terminals
+timm==1.0.22
+    # via -r requirements.in
+tinycss2==1.4.0
+    # via bleach
+tokenizers==0.22.1
+    # via transformers
+torch==2.9.1
+    # via
+    #   lpips
+    #   timm
+    #   torchvision
+torchvision==0.24.1
+    # via
+    #   lpips
+    #   timm
+tornado==6.5.2
+    # via
+    #   ipykernel
+    #   jupyter-client
+    #   jupyter-server
+    #   jupyterlab
+    #   notebook
+    #   terminado
+tqdm==4.67.1
+    # via
+    #   dyff-client
+    #   huggingface-hub
+    #   lpips
+    #   transformers
+traitlets==5.14.3
+    # via
+    #   ipykernel
+    #   ipython
+    #   jupyter-client
+    #   jupyter-core
+    #   jupyter-events
+    #   jupyter-server
+    #   jupyterlab
+    #   matplotlib-inline
+    #   nbclient
+    #   nbconvert
+    #   nbformat
+transformers==4.57.3
+    # via -r requirements.in
+triton
+    # via torch
+typing
+    # via -r requirements.in
+typing-extensions
+    # via
+    #   anyio
+    #   azure-core
+    #   beautifulsoup4
+    #   fastapi
+    #   huggingface-hub
+    #   pydantic
+    #   pydantic-core
+    #   referencing
+    #   starlette
+    #   torch
+    #   typing-inspection
+typing-inspection
+    # via
+    #   pydantic
+    #   pydantic-settings
+tzdata
+    # via
+    #   arrow
+    #   pandas
+uri-template
+    # via jsonschema
+urllib3
+    # via requests
+uvicorn
+    # via -r requirements.in
+uvloop
+    # via uvicorn
+watchfiles
+    # via uvicorn
+wcwidth==0.2.14
+    # via prompt-toolkit
+webcolors==25.10.0
+    # via jsonschema
+webencodings==0.5.1
+    # via
+    #   bleach
+    #   tinycss2
+websocket-client==1.9.0
+    # via jupyter-server
+websockets==15.0.1
+    # via
+    #   dyff-client
+    #   uvicorn

requirements.in

@@ -0,0 +1,34 @@
+dyff-audit
+dyff-client
+dyff-schema>=0.39.1
+
+click
+
+# Web framework
+fastapi
+uvicorn[standard]
+
+# Configuration management
+pydantic>=2.0.0,<3.0.0
+pydantic-settings
+python-dotenv
+
+# File upload handling
+python-multipart
+
+# ML/AI dependencies (newly added)
+transformers>=4.35.0
+pillow>=10.0.0
+
+# Dataset generation and testing
+pyarrow>=14.0.0
+numpy
+pandas
+requests>=2.25.0
+opencv-python
+matplotlib
+typing
+einops
+timm
+beartype
+lpips

requirements.torch.cpu.in

@@ -0,0 +1,3 @@
+--index-url https://download.pytorch.org/whl/cpu
+torch==2.9.1+cpu
+torchvision==0.24.1+cpu

requirements.torch.cpu.txt

@@ -0,0 +1,9 @@
+#--index-url https://download.pytorch.org/whl/cu126
+#torch==2.9.1
+#torchvision==0.24.1
+#torchaudio==2.9.0
+
+ --index-url https://download.pytorch.org/whl/nightly/cu121
+torch
+torchvision
+torchaudio

requirements.torch.gpu.in

@@ -0,0 +1,2 @@
+torch
+torchvision

requirements.torch.gpu.txt

@@ -0,0 +1,71 @@
+# This file was autogenerated by uv via the following command:
+#    uv pip compile --python-version 3.12 -o requirements.torch.gpu.txt requirements.torch.gpu.in
+filelock==3.20.0
+    # via torch
+fsspec==2025.12.0
+    # via torch
+jinja2==3.1.6
+    # via torch
+markupsafe==3.0.3
+    # via jinja2
+mpmath==1.3.0
+    # via sympy
+networkx==3.6.1
+    # via torch
+numpy==2.3.5
+    # via torchvision
+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.5
+    # via torch
+nvidia-nvjitlink-cu12==12.8.93
+    # via
+    #   nvidia-cufft-cu12
+    #   nvidia-cusolver-cu12
+    #   nvidia-cusparse-cu12
+    #   torch
+nvidia-nvshmem-cu12==3.3.20
+    # via torch
+nvidia-nvtx-cu12==12.8.90
+    # via torch
+pillow==12.0.0
+    # via torchvision
+setuptools==80.9.0
+    # via torch
+sympy==1.14.0
+    # via torch
+torch==2.9.1
+    # via
+    #   -r requirements.torch.gpu.in
+    #   torchvision
+torchvision==0.24.1
+    # via -r requirements.torch.gpu.in
+triton==3.5.1
+    # via torch
+typing-extensions==4.15.0
+    # via torch

requirements.txt

@@ -0,0 +1,530 @@
+# This file was autogenerated by uv via the following command:
+#    uv pip compile --python-version 3.12 -o requirements.txt requirements.in
+absl-py==2.3.1
+    # via dyff-client
+annotated-types==0.7.0
+    # via pydantic
+anyio==3.7.1
+    # via
+    #   fastapi
+    #   httpx
+    #   jupyter-server
+    #   starlette
+    #   watchfiles
+argon2-cffi==25.1.0
+    # via jupyter-server
+argon2-cffi-bindings==25.1.0
+    # via argon2-cffi
+arrow==1.4.0
+    # via isoduration
+asttokens==3.0.1
+    # via stack-data
+async-lru==2.0.5
+    # via jupyterlab
+attrs==25.4.0
+    # via
+    #   jsonschema
+    #   referencing
+azure-core==1.36.0
+    # via dyff-client
+babel==2.17.0
+    # via jupyterlab-server
+beautifulsoup4==4.14.2
+    # via
+    #   dyff-audit
+    #   nbconvert
+bleach==6.3.0
+    # via nbconvert
+canonicaljson==2.0.0
+    # via dyff-schema
+certifi==2025.11.12
+    # via
+    #   httpcore
+    #   httpx
+    #   requests
+cffi==2.0.0
+    # via argon2-cffi-bindings
+charset-normalizer==3.4.4
+    # via requests
+click==8.3.1
+    # via
+    #   -r requirements.in
+    #   uvicorn
+comm==0.2.3
+    # via ipykernel
+debugpy==1.8.17
+    # via ipykernel
+decorator==5.2.1
+    # via ipython
+defusedxml==0.7.1
+    # via nbconvert
+dnspython==2.8.0
+    # via email-validator
+dyff-audit==0.16.1
+    # via -r requirements.in
+dyff-client==0.23.5
+    # via
+    #   -r requirements.in
+    #   dyff-audit
+dyff-schema==0.39.1
+    # via
+    #   -r requirements.in
+    #   dyff-audit
+    #   dyff-client
+email-validator==2.3.0
+    # via dyff-schema
+executing==2.2.1
+    # via stack-data
+fastapi==0.104.1
+    # via -r requirements.in
+fastjsonschema==2.21.2
+    # via nbformat
+filelock==3.20.0
+    # via
+    #   huggingface-hub
+    #   torch
+    #   transformers
+fqdn==1.5.1
+    # via jsonschema
+fsspec==2025.10.0
+    # via
+    #   huggingface-hub
+    #   torch
+google-i18n-address==3.1.1
+    # via dyff-schema
+h11==0.16.0
+    # via
+    #   httpcore
+    #   uvicorn
+hf-xet==1.2.0
+    # via huggingface-hub
+httpcore==1.0.9
+    # via httpx
+httptools==0.7.1
+    # via uvicorn
+httpx==0.28.1
+    # via
+    #   dyff-client
+    #   jupyterlab
+huggingface-hub==0.36.0
+    # via
+    #   tokenizers
+    #   transformers
+hypothesis==6.148.1
+    # via
+    #   dyff-schema
+    #   hypothesis-jsonschema
+hypothesis-jsonschema==0.23.1
+    # via dyff-schema
+idna==3.11
+    # via
+    #   anyio
+    #   email-validator
+    #   httpx
+    #   jsonschema
+    #   requests
+ipykernel==7.1.0
+    # via jupyterlab
+ipython==9.7.0
+    # via ipykernel
+ipython-pygments-lexers==1.1.1
+    # via ipython
+isodate==0.7.2
+    # via dyff-client
+isoduration==20.11.0
+    # via jsonschema
+jedi==0.19.2
+    # via ipython
+jinja2==3.1.6
+    # via
+    #   jupyter-server
+    #   jupyterlab
+    #   jupyterlab-server
+    #   nbconvert
+    #   torch
+json5==0.12.1
+    # via jupyterlab-server
+jsonpath-ng==1.7.0
+    # via
+    #   dyff-client
+    #   dyff-schema
+jsonpointer==3.0.0
+    # via jsonschema
+jsonschema==4.25.1
+    # via
+    #   hypothesis-jsonschema
+    #   jupyter-events
+    #   jupyterlab-server
+    #   nbformat
+jsonschema-specifications==2025.9.1
+    # via jsonschema
+jupyter-client==8.6.3
+    # via
+    #   ipykernel
+    #   jupyter-server
+    #   nbclient
+jupyter-core==5.9.1
+    # via
+    #   ipykernel
+    #   jupyter-client
+    #   jupyter-server
+    #   jupyterlab
+    #   nbclient
+    #   nbconvert
+    #   nbformat
+jupyter-events==0.12.0
+    # via jupyter-server
+jupyter-lsp==2.3.0
+    # via jupyterlab
+jupyter-server==2.17.0
+    # via
+    #   jupyter-lsp
+    #   jupyterlab
+    #   jupyterlab-server
+    #   notebook
+    #   notebook-shim
+jupyter-server-terminals==0.5.3
+    # via jupyter-server
+jupyterlab==4.4.10
+    # via notebook
+jupyterlab-pygments==0.3.0
+    # via nbconvert
+jupyterlab-server==2.28.0
+    # via
+    #   jupyterlab
+    #   notebook
+lark==1.3.1
+    # via rfc3987-syntax
+lxml==6.0.2
+    # via dyff-audit
+markupsafe==3.0.3
+    # via
+    #   jinja2
+    #   nbconvert
+matplotlib-inline==0.2.1
+    # via
+    #   ipykernel
+    #   ipython
+mistune==3.1.4
+    # via nbconvert
+mpmath==1.3.0
+    # via sympy
+nbclient==0.10.2
+    # via nbconvert
+nbconvert==7.16.6
+    # via
+    #   dyff-audit
+    #   jupyter-server
+nbformat==5.10.4
+    # via
+    #   dyff-audit
+    #   jupyter-server
+    #   nbclient
+    #   nbconvert
+nest-asyncio==1.6.0
+    # via ipykernel
+networkx==3.5
+    # via torch
+notebook==7.4.7
+    # via dyff-audit
+notebook-shim==0.2.4
+    # via
+    #   jupyterlab
+    #   notebook
+numpy==1.26.4
+    # via
+    #   -r requirements.in
+    #   dyff-audit
+    #   dyff-client
+    #   dyff-schema
+    #   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.5
+    # via torch
+nvidia-nvjitlink-cu12==12.8.93
+    # via
+    #   nvidia-cufft-cu12
+    #   nvidia-cusolver-cu12
+    #   nvidia-cusparse-cu12
+    #   torch
+nvidia-nvshmem-cu12==3.3.20
+    # via torch
+nvidia-nvtx-cu12==12.8.90
+    # via torch
+packaging==25.0
+    # via
+    #   huggingface-hub
+    #   ipykernel
+    #   jupyter-events
+    #   jupyter-server
+    #   jupyterlab
+    #   jupyterlab-server
+    #   nbconvert
+    #   transformers
+pandas==2.3.3
+    # via
+    #   -r requirements.in
+    #   dyff-audit
+    #   dyff-client
+pandocfilters==1.5.1
+    # via nbconvert
+parso==0.8.5
+    # via jedi
+pexpect==4.9.0
+    # via ipython
+pillow==12.0.0
+    # via -r requirements.in
+platformdirs==4.5.0
+    # via jupyter-core
+ply==3.11
+    # via jsonpath-ng
+prometheus-client==0.23.1
+    # via jupyter-server
+prompt-toolkit==3.0.52
+    # via ipython
+psutil==7.1.3
+    # via ipykernel
+ptyprocess==0.7.0
+    # via
+    #   pexpect
+    #   terminado
+pure-eval==0.2.3
+    # via stack-data
+pyarrow==22.0.0
+    # via
+    #   -r requirements.in
+    #   dyff-audit
+    #   dyff-client
+    #   dyff-schema
+pycparser==2.23
+    # via cffi
+pydantic==2.5.0
+    # via
+    #   -r requirements.in
+    #   dyff-audit
+    #   dyff-client
+    #   dyff-schema
+    #   fastapi
+    #   pydantic-settings
+pydantic-core==2.14.1
+    # via pydantic
+pydantic-settings==2.0.3
+    # via -r requirements.in
+pygments==2.19.2
+    # via
+    #   ipython
+    #   ipython-pygments-lexers
+    #   nbconvert
+python-dateutil==2.9.0.post0
+    # via
+    #   arrow
+    #   jupyter-client
+    #   pandas
+python-dotenv==0.21.0
+    # via
+    #   -r requirements.in
+    #   pydantic-settings
+    #   uvicorn
+python-json-logger==4.0.0
+    # via jupyter-events
+python-multipart==0.0.6
+    # via -r requirements.in
+pytz==2025.2
+    # via pandas
+pyyaml==6.0.3
+    # via
+    #   huggingface-hub
+    #   jupyter-events
+    #   transformers
+    #   uvicorn
+pyzmq==27.1.0
+    # via
+    #   ipykernel
+    #   jupyter-client
+    #   jupyter-server
+referencing==0.37.0
+    # via
+    #   jsonschema
+    #   jsonschema-specifications
+    #   jupyter-events
+regex==2025.11.3
+    # via transformers
+requests==2.32.5
+    # via
+    #   -r requirements.in
+    #   azure-core
+    #   google-i18n-address
+    #   huggingface-hub
+    #   jupyterlab-server
+    #   transformers
+rfc3339-validator==0.1.4
+    # via
+    #   jsonschema
+    #   jupyter-events
+rfc3986-validator==0.1.1
+    # via
+    #   jsonschema
+    #   jupyter-events
+rfc3987-syntax==1.1.0
+    # via jsonschema
+rpds-py==0.29.0
+    # via
+    #   jsonschema
+    #   referencing
+ruamel-yaml==0.18.16
+    # via dyff-audit
+ruamel-yaml-clib==0.2.15
+    # via ruamel-yaml
+safetensors==0.6.2
+    # via transformers
+send2trash==1.8.3
+    # via jupyter-server
+setuptools==80.9.0
+    # via
+    #   jupyterlab
+    #   torch
+six==1.17.0
+    # via
+    #   python-dateutil
+    #   rfc3339-validator
+sniffio==1.3.1
+    # via anyio
+sortedcontainers==2.4.0
+    # via hypothesis
+soupsieve==2.8
+    # via beautifulsoup4
+stack-data==0.6.3
+    # via ipython
+starlette==0.27.0
+    # via fastapi
+sympy==1.14.0
+    # via torch
+terminado==0.18.1
+    # via
+    #   jupyter-server
+    #   jupyter-server-terminals
+tinycss2==1.4.0
+    # via bleach
+tokenizers==0.22.1
+    # via transformers
+torch==2.9.1
+    # via -r requirements.in
+tornado==6.5.2
+    # via
+    #   ipykernel
+    #   jupyter-client
+    #   jupyter-server
+    #   jupyterlab
+    #   notebook
+    #   terminado
+tqdm==4.67.1
+    # via
+    #   dyff-client
+    #   huggingface-hub
+    #   transformers
+traitlets==5.14.3
+    # via
+    #   ipykernel
+    #   ipython
+    #   jupyter-client
+    #   jupyter-core
+    #   jupyter-events
+    #   jupyter-server
+    #   jupyterlab
+    #   matplotlib-inline
+    #   nbclient
+    #   nbconvert
+    #   nbformat
+transformers==4.57.1
+    # via -r requirements.in
+triton==3.5.1
+    # via torch
+typing-extensions==4.15.0
+    # via
+    #   azure-core
+    #   beautifulsoup4
+    #   fastapi
+    #   huggingface-hub
+    #   pydantic
+    #   pydantic-core
+    #   referencing
+    #   torch
+tzdata==2025.2
+    # via
+    #   arrow
+    #   pandas
+uri-template==1.3.0
+    # via jsonschema
+urllib3==2.5.0
+    # via requests
+uvicorn==0.24.0
+    # via -r requirements.in
+uvloop==0.22.1
+    # via uvicorn
+watchfiles==1.1.1
+    # via uvicorn
+wcwidth==0.2.14
+    # via prompt-toolkit
+webcolors==25.10.0
+    # via jsonschema
+webencodings==0.5.1
+    # via
+    #   bleach
+    #   tinycss2
+websocket-client==1.9.0
+    # via jupyter-server
+websockets==15.0.1
+    # via
+    #   dyff-client
+    #   uvicorn
+
+numpy
+pandas
+scipy==1.12.0
+
+
+opencv-contrib-python==4.11.0.86
+av==14.0.1
+decord
+kornia==0.7.4
+timm
+einops
+beartype
+lpips==0.1.4
+imageio
+
+audiomentations==0.36.0
+librosa==0.10.2.post1
+soundfile==0.12.1
+
+transformers
+datasets
+tqdm
+opencv-python

response.json

@@ -0,0 +1 @@
+{"logprobs":[-0.859380304813385,-1.2701971530914307,-2.1918208599090576,-1.69235098361969],"localizationMask":{"mediaType":"image/png","data":"iVBORw0KGgoAAAANSUhEUgAAA8AAAAKDAQAAAAD9Fl5AAAAAu0lEQVR4nO3NsREAMAgDMWD/nZMVKEwn1T5/FQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMCl3g5f+HC24TRhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAj70gwKsTlmdBwAAAABJRU5ErkJggg=="}}

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,10 @@
+mkdir -p "models/microsoft/resnet-18"
+
+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"
+        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="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()

submit.sh

@@ -0,0 +1,2 @@
+export DYFF_API_TOKEN=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJqdGkiOiJiODBkZGY4NmUyNzk0MzI3OTNkOTlmNTk2MGE1MWRlZSIsInN1YiI6IkFjY291bnQvN2IxZWZiOWMwMDMyNGNkYzlhNDEyY2M4YmQ4ZjcwZTIiLCJuYmYiOjE3NjUzMTg1NjMsImV4cCI6MTc5Njg1NDU2MywiaWF0IjoxNzY1MzE4NTYzLCJncmFudHMiOlt7InJlc291cmNlcyI6WyIqIl0sImZ1bmN0aW9ucyI6WyJjb25zdW1lIiwiZGF0YSIsImdldCIsInF1ZXJ5Il0sImFjY291bnRzIjpbInB1YmxpYyJdLCJlbnRpdGllcyI6W119LHsicmVzb3VyY2VzIjpbImNoYWxsZW5nZXMiXSwiZnVuY3Rpb25zIjpbImdldCIsInF1ZXJ5Il0sImFjY291bnRzIjpbXSwiZW50aXRpZXMiOlsiZGM1MDlhOGM3NzFiNDkyYjkwYzQzMDEyZmRlOWEwNGYiXX0seyJyZXNvdXJjZXMiOlsidGVhbXMiXSwiZnVuY3Rpb25zIjpbIioiXSwiYWNjb3VudHMiOltdLCJlbnRpdGllcyI6WyIzYWUzMzdjMTY2MGQ0YjczOGM0NDNjMmMzN2ZjMWJjYSJdfSx7InJlc291cmNlcyI6WyJhcnRpZmFjdHMiLCJpbmZlcmVuY2VzZXJ2aWNlcyIsIm1vZGVscyIsInN1Ym1pc3Npb25zIl0sImZ1bmN0aW9ucyI6WyIqIl0sImFjY291bnRzIjpbIjdiMWVmYjljMDAzMjRjZGM5YTQxMmNjOGJkOGY3MGUyIl0sImVudGl0aWVzIjpbXX0seyJyZXNvdXJjZXMiOlsiKiJdLCJmdW5jdGlvbnMiOlsiY29uc3VtZSIsImRhdGEiLCJnZXQiLCJxdWVyeSJdLCJhY2NvdW50cyI6WyI3YjFlZmI5YzAwMzI0Y2RjOWE0MTJjYzhiZDhmNzBlMiJdLCJlbnRpdGllcyI6W119XSwic2VjcmV0IjoiM3p3MjFHUFI0WGRpenpIVTdnT0ZBdyJ9.bR71zVzqrRRsK_FZCYMGmTYCsQekz6LfmzM-EoyBOW0 
+venv/bin/python challenge-cli.py submit --team 3ae337c1660d4b738c443c2c37fc1bca --account Account/7b1efb9c00324cdc9a412cc8bd8f70e2 --task 567316f19d37490b97aa647e7017ef44 --service sida

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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"
+    }
+}

upload_model.py

@@ -0,0 +1,93 @@
+# SPDX-FileCopyrightText: 2025 UL Research Institutes
+# SPDX-License-Identifier: Apache-2.0
+
+import sys
+import time
+from pathlib import Path
+
+import click
+
+from dyff.client import Client
+from dyff.schema.platform import *
+from dyff.schema.requests import *
+
+from app.api.models import PredictionResponse
+
+# ----------------------------------------------------------------------------
+
+WORKDIR = Path(__file__).resolve().parent
+
+
+@click.command()
+@click.option(
+    "--account",
+    type=str,
+    required=True,
+    help="Your account ID",
+)
+@click.option(
+    "--name",
+    type=str,
+    required=True,
+    help="The name of your detector model. For display and querying purposes only.",
+)
+@click.option(
+    "--image",
+    type=str,
+    required=True,
+    help="The Docker image to upload. Must exist in your local Docker deamon.",
+)
+@click.option(
+    "--endpoint",
+    type=str,
+    default="predict",
+    help="The endpoint to call on your model to make a prediction.",
+)
+def main(account: str, name: str, image: str, endpoint: str) -> None:
+    dyffapi = Client()
+
+    # You can set these to a known ID to skip that step
+    artifact_id = None
+    service_id = None
+
+    # Upload the image
+    if artifact_id is None:
+        # Create an Artifact resource
+        artifact = dyffapi.artifacts.create(ArtifactCreateRequest(account=account))
+        click.echo(f"artifact_id = \"{artifact.id}\"")
+        time.sleep(5)
+        # Push the image from the local Docker daemon
+        dyffapi.artifacts.push(artifact, source=f"docker-daemon:{image}")
+        time.sleep(5)
+        # Indicate that we're done pushing
+        dyffapi.artifacts.finalize(artifact.id)
+    else:
+        artifact = dyffapi.artifacts.get(artifact_id)
+        assert artifact is not None
+
+    # Create a runnable InferenceService
+    if service_id is None:
+        # Don't change this
+        service_request = InferenceServiceCreateRequest(
+            account=account,
+            name=name,
+            model=None,
+            runner=InferenceServiceRunner(
+                kind=InferenceServiceRunnerKind.CONTAINER,
+                imageRef=EntityIdentifier.of(artifact),
+                resources=ModelResources(),
+            ),
+            interface=InferenceInterface(
+                endpoint=endpoint,
+                outputSchema=DataSchema.make_output_schema(PredictionResponse),
+            ),
+        )
+        service = dyffapi.inferenceservices.create(service_request)
+        click.echo(f"service_id = \"{service.id}\"")
+    else:
+        service = dyffapi.inferenceservices.get(service_id)
+        assert service is not None
+
+
+if __name__ == "__main__":
+    main()

upload_submission.sh

@@ -0,0 +1,5 @@
+export DOCKER_HOST=$DOCKER_HOST
+echo DOCKER_HOST is $DOCKER_HOST
+export DYFF_API_TOKEN=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJqdGkiOiJiODBkZGY4NmUyNzk0MzI3OTNkOTlmNTk2MGE1MWRlZSIsInN1YiI6IkFjY291bnQvN2IxZWZiOWMwMDMyNGNkYzlhNDEyY2M4YmQ4ZjcwZTIiLCJuYmYiOjE3NjUzMTg1NjMsImV4cCI6MTc5Njg1NDU2MywiaWF0IjoxNzY1MzE4NTYzLCJncmFudHMiOlt7InJlc291cmNlcyI6WyIqIl0sImZ1bmN0aW9ucyI6WyJjb25zdW1lIiwiZGF0YSIsImdldCIsInF1ZXJ5Il0sImFjY291bnRzIjpbInB1YmxpYyJdLCJlbnRpdGllcyI6W119LHsicmVzb3VyY2VzIjpbImNoYWxsZW5nZXMiXSwiZnVuY3Rpb25zIjpbImdldCIsInF1ZXJ5Il0sImFjY291bnRzIjpbXSwiZW50aXRpZXMiOlsiZGM1MDlhOGM3NzFiNDkyYjkwYzQzMDEyZmRlOWEwNGYiXX0seyJyZXNvdXJjZXMiOlsidGVhbXMiXSwiZnVuY3Rpb25zIjpbIioiXSwiYWNjb3VudHMiOltdLCJlbnRpdGllcyI6WyIzYWUzMzdjMTY2MGQ0YjczOGM0NDNjMmMzN2ZjMWJjYSJdfSx7InJlc291cmNlcyI6WyJhcnRpZmFjdHMiLCJpbmZlcmVuY2VzZXJ2aWNlcyIsIm1vZGVscyIsInN1Ym1pc3Npb25zIl0sImZ1bmN0aW9ucyI6WyIqIl0sImFjY291bnRzIjpbIjdiMWVmYjljMDAzMjRjZGM5YTQxMmNjOGJkOGY3MGUyIl0sImVudGl0aWVzIjpbXX0seyJyZXNvdXJjZXMiOlsiKiJdLCJmdW5jdGlvbnMiOlsiY29uc3VtZSIsImRhdGEiLCJnZXQiLCJxdWVyeSJdLCJhY2NvdW50cyI6WyI3YjFlZmI5YzAwMzI0Y2RjOWE0MTJjYzhiZDhmNzBlMiJdLCJlbnRpdGllcyI6W119XSwic2VjcmV0IjoiM3p3MjFHUFI0WGRpenpIVTdnT0ZBdyJ9.bR71zVzqrRRsK_FZCYMGmTYCsQekz6LfmzM-EoyBOW0 
+/media/NAS/USERS/shahid/WACV/example-submission/venv/bin/python challenge-cli.py upload-submission --name "dino" --account 7b1efb9c00324cdc9a412cc8bd8f70e2 --image safe-challenge-2025/example-submission:latest
+# 

utils/My_version.py

@@ -0,0 +1,207 @@
+# %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+# Copyright (c) 2023 Image Processing Research Group of University Federico II of Naples ('GRIP-UNINA').
+#
+# All rights reserved.
+# This work should only be used for nonprofit purposes.
+#
+# By downloading and/or using any of these files, you implicitly agree to all the
+# terms of the license, as specified in the document LICENSE.txt
+# (included in this package) and online at
+# http://www.grip.unina.it/download/LICENSE_OPEN.txt
+
+"""
+Created in September 2022
+@author: fabrizio.guillaro
+"""
+
+import torch
+import torch.nn as nn
+from torch.nn import functional as F
+
+
+
+class CrossEntropy(nn.Module):
+    def __init__(self, ignore_label=-1, weight=None):
+        super(CrossEntropy, self).__init__()
+        self.ignore_label = ignore_label
+        self.criterion = nn.CrossEntropyLoss(weight=weight, 
+                                             ignore_index=ignore_label)
+
+    def forward(self, score, target):        
+        ph, pw = score.size(2), score.size(3)
+        h, w = target.size(1), target.size(2)
+        if ph != h or pw != w:
+            score = F.upsample(
+                    input=score, size=(h, w), mode='bilinear')
+
+        loss = self.criterion(score, target)
+        return loss
+
+    
+    
+class DiceLoss(nn.Module):
+    def __init__(self, ignore_label=-1, smooth=1, exponent=2): #because padding adds -1 to the targets
+        super(DiceLoss, self).__init__()  
+        self.ignore_index = ignore_label
+        self.smooth = smooth
+        self.exponent = exponent
+        
+    def dice_loss(self, pred, target, valid_mask):
+        assert pred.shape[0] == target.shape[0]
+        total_loss = 0
+        num_classes = pred.shape[1]
+        for i in range(num_classes):
+            if i != self.ignore_index:
+                dice_loss = self.binary_dice_loss(
+                    pred[:, i],
+                    target[..., i],
+                    valid_mask=valid_mask,)
+                total_loss += dice_loss
+        return total_loss / num_classes
+
+    def binary_dice_loss(self, pred, target, valid_mask):
+        assert pred.shape[0] == target.shape[0]
+        pred = pred.reshape(pred.shape[0], -1)
+        target = target.reshape(target.shape[0], -1)
+        valid_mask = valid_mask.reshape(valid_mask.shape[0], -1)
+
+        num = torch.sum(torch.mul(pred, target) * valid_mask, dim=1) * 2 + self.smooth
+        den = torch.sum(pred.pow(self.exponent)*valid_mask + target.pow(self.exponent)*valid_mask, dim=1) + max(self.smooth, 1e-5)
+        
+        dice = num / den
+        dice = torch.mean(dice)
+        return 1 - dice
+        
+    def forward(self, score, target):
+        ph, pw = score.size(2), score.size(3)
+        h, w = target.size(1), target.size(2)
+        if ph != h or pw != w:
+            score = F.upsample(
+                    input=score, size=(h, w), mode='bilinear')
+        
+        score = F.softmax(score,dim=1)
+        num_classes = score.shape[1]
+        
+        one_hot_target = F.one_hot(
+            torch.clamp(target.long(), 0, num_classes - 1),
+            num_classes=num_classes)
+        valid_mask = (target != self.ignore_index).long()
+        
+        loss = self.dice_loss(score, one_hot_target, valid_mask)
+        return loss
+    
+
+class BinaryDiceLoss(nn.Module):
+    def __init__(self, smooth=1, exponent=2, ignore_label=-1): #because padding adds -1 to the targets
+        super(BinaryDiceLoss, self).__init__()  
+        self.ignore_index = ignore_label
+        self.smooth = smooth
+        self.exponent = exponent
+
+    def binary_dice_loss(self, pred, target, valid_mask):
+        assert pred.shape[0] == target.shape[0]
+        pred = pred.reshape(pred.shape[0], -1)
+        target = target.reshape(target.shape[0], -1)
+        valid_mask = valid_mask.reshape(valid_mask.shape[0], -1)
+
+        num = torch.sum(torch.mul(pred, target) * valid_mask, dim=1) * 2 + self.smooth
+        den = torch.sum(pred.pow(self.exponent)*valid_mask + target.pow(self.exponent)*valid_mask, dim=1) + max(self.smooth, 1e-5)
+        
+        dice = num / den
+        dice = torch.mean(dice)
+        return 1 - dice
+        
+    def forward(self, score, target):
+        ph, pw = score.size(2), score.size(3)
+        h, w = target.size(1), target.size(2)
+        if ph != h or pw != w:
+            score = F.upsample(
+                    input=score, size=(h, w), mode='bilinear')
+        
+        score = F.softmax(score,dim=1)
+        num_classes = score.shape[1]
+        
+        one_hot_target = F.one_hot(
+            torch.clamp(target.long(), 0, num_classes - 1),
+            num_classes=num_classes)
+        valid_mask = (target != self.ignore_index).long()
+        
+        loss = self.binary_dice_loss(
+                    score[:, 1],
+                    one_hot_target[..., 1],
+                    valid_mask)
+        return loss
+    
+
+class DiceEntropyLoss(nn.Module):
+    def __init__(self, smooth=1, exponent=2, ignore_label=-1, weight=None): #because padding adds -1 to the targets
+        super(DiceEntropyLoss, self).__init__()  
+        self.ignore_label = ignore_label
+        self.smooth = smooth
+        self.exponent = exponent
+        self.cross_entropy = nn.CrossEntropyLoss(weight=weight, 
+                                             ignore_index=ignore_label)
+    
+    def binary_dice_loss(self, pred, target, valid_mask):
+        print(pred.shape, target.shape, "this is second list")
+        assert pred.shape[0] == target.shape[0]
+        pred = pred.reshape(pred.shape[0], -1)
+        target = target.reshape(target.shape[0], -1)
+        valid_mask = valid_mask.reshape(valid_mask.shape[0], -1)
+        
+        # print(pred.shape, target.shape)
+        num = torch.sum(torch.mul(pred, target) * valid_mask, dim=1) * 2 + self.smooth
+        den = torch.sum(pred.pow(self.exponent)*valid_mask + target.pow(self.exponent)*valid_mask, dim=1) + max(self.smooth, 1e-5)
+        
+        dice = num / den
+        dice = torch.mean(dice)
+        return 1 - dice
+        
+    def forward(self, score, target):
+        ph, pw = score.size(2), score.size(3)
+        h, w = target.size(1), target.size(2)
+        # if ph != h or pw != w:
+        #     score = F.upsample(
+        #             input=score, size=(h, w), mode='bilinear')
+        CE_loss   = self.cross_entropy(score, target)
+        
+        
+        score = F.softmax(score,dim=1)
+        num_classes = score.shape[1]
+        
+        one_hot_target = F.one_hot(
+            torch.clamp(target.long(), 0, num_classes - 1),
+            num_classes=num_classes)
+        valid_mask = (target != self.ignore_label).long()
+        # print(score.shape,one_hot_target.shape)
+        dice_loss = self.binary_dice_loss(
+                    score[:, 1],
+                    one_hot_target[:,1][..., 1],
+                    valid_mask)
+
+        return 0.3*CE_loss + 0.7*dice_loss
+
+
+
+    
+class FocalLoss(nn.Module):
+
+    def __init__(self, alpha=0.25, gamma=2., ignore_label=-1):  #alpha 0.25, gamma=2.
+        super(FocalLoss, self).__init__()
+        self.alpha=alpha
+        self.gamma= gamma
+        self.criterion = nn.CrossEntropyLoss(ignore_index=ignore_label, reduction="none")
+       
+    def forward(self, score, target):  
+        ph, pw = score.size(2), score.size(3)
+        h, w = target.size(1), target.size(2)
+        if ph != h or pw != w:
+            score = F.upsample(
+                    input=score, size=(h, w), mode='bilinear')
+            
+        ce_loss = self.criterion(score, target)
+        pt = torch.exp(-ce_loss)
+        f_loss = self.alpha * (1-pt)**self.gamma * ce_loss
+        return f_loss.mean()
+        
+        

utils/losses.py

@@ -0,0 +1,440 @@
+# %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+# Copyright (c) 2023 Image Processing Research Group of University Federico II of Naples ('GRIP-UNINA').
+#
+# All rights reserved.
+# This work should only be used for nonprofit purposes.
+#
+# By downloading and/or using any of these files, you implicitly agree to all the
+# terms of the license, as specified in the document LICENSE.txt
+# (included in this package) and online at
+# http://www.grip.unina.it/download/LICENSE_OPEN.txt
+
+"""
+Created in September 2022
+@author: fabrizio.guillaro
+"""
+
+import torch
+import torch.nn as nn
+from torch.nn import functional as F
+
+
+
+class CrossEntropy(nn.Module):
+    def __init__(self, ignore_label=-1, weight=None):
+        super(CrossEntropy, self).__init__()
+        self.ignore_label = ignore_label
+        self.criterion = nn.CrossEntropyLoss(weight=weight, 
+                                             ignore_index=ignore_label)
+
+    def forward(self, score, target):        
+        ph, pw = score.size(2), score.size(3)
+        h, w = target.size(1), target.size(2)
+        if ph != h or pw != w:
+            score = F.upsample(
+                    input=score, size=(h, w), mode='bilinear')
+
+        loss = self.criterion(score, target)
+        return loss
+
+    
+    
+class DiceLoss(nn.Module):
+    def __init__(self, ignore_label=-1, smooth=1, exponent=2): #because padding adds -1 to the targets
+        super(DiceLoss, self).__init__()  
+        self.ignore_index = ignore_label
+        self.smooth = smooth
+        self.exponent = exponent
+        
+    def dice_loss(self, pred, target, valid_mask):
+        assert pred.shape[0] == target.shape[0]
+        total_loss = 0
+        num_classes = pred.shape[1]
+        for i in range(num_classes):
+            if i != self.ignore_index:
+                dice_loss = self.binary_dice_loss(
+                    pred[:, i],
+                    target[..., i],
+                    valid_mask=valid_mask,)
+                total_loss += dice_loss
+        return total_loss / num_classes
+
+    def binary_dice_loss(self, pred, target, valid_mask):
+        assert pred.shape[0] == target.shape[0]
+        pred = pred.reshape(pred.shape[0], -1)
+        target = target.reshape(target.shape[0], -1)
+        valid_mask = valid_mask.reshape(valid_mask.shape[0], -1)
+
+        num = torch.sum(torch.mul(pred, target) * valid_mask, dim=1) * 2 + self.smooth
+        den = torch.sum(pred.pow(self.exponent)*valid_mask + target.pow(self.exponent)*valid_mask, dim=1) + max(self.smooth, 1e-5)
+        
+        dice = num / den
+        dice = torch.mean(dice)
+        return 1 - dice
+        
+    def forward(self, score, target):
+        ph, pw = score.size(2), score.size(3)
+        h, w = target.size(1), target.size(2)
+        if ph != h or pw != w:
+            score = F.upsample(
+                    input=score, size=(h, w), mode='bilinear')
+        
+        score = F.softmax(score,dim=1)
+        num_classes = score.shape[1]
+        
+        one_hot_target = F.one_hot(
+            torch.clamp(target.long(), 0, num_classes - 1),
+            num_classes=num_classes)
+        valid_mask = (target != self.ignore_index).long()
+        
+        loss = self.dice_loss(score, one_hot_target, valid_mask)
+        return loss
+    
+    
+
+class BinaryDiceLoss(nn.Module):
+    def __init__(self, smooth=1, exponent=2, ignore_label=-1): #because padding adds -1 to the targets
+        super(BinaryDiceLoss, self).__init__()  
+        self.ignore_index = ignore_label
+        self.smooth = smooth
+        self.exponent = exponent
+
+    def binary_dice_loss(self, pred, target, valid_mask):
+        assert pred.shape[0] == target.shape[0]
+        print(pred.shape, target.shape)
+        pred = pred.reshape(pred.shape[0], -1)
+        target = target.reshape(target.shape[0], -1)
+        valid_mask = valid_mask.reshape(valid_mask.shape[0], -1)
+        print(pred.shape, target.shape)
+        num = torch.sum(torch.mul(pred, target) * valid_mask, dim=1) * 2 + self.smooth
+        den = torch.sum(pred.pow(self.exponent)*valid_mask + target.pow(self.exponent)*valid_mask, dim=1) + max(self.smooth, 1e-5)
+        
+        dice = num / den
+        dice = torch.mean(dice)
+        return 1 - dice
+        
+    def forward(self, score, target):
+    
+        ph, pw = score.size(2), score.size(3)
+        h, w = target.size(2), target.size(3)
+        if ph != h or pw != w:
+            score = F.upsample(
+                    input=score, size=(h, w), mode='bilinear')
+        
+        score = F.softmax(score,dim=1)
+        num_classes = score.shape[1]
+        
+        one_hot_target = F.one_hot(
+            torch.clamp(target.long(), 0, num_classes - 1),
+            num_classes=num_classes)
+        valid_mask = (target != self.ignore_index).long()
+       
+        loss = self.binary_dice_loss(
+                    score[:, 1],
+                    one_hot_target[..., 1],
+                    valid_mask)
+        return loss
+    
+def create_target_from_mask_and_label(mask, data_label):
+    """
+    Convert binary mask to class-labeled target based on data_label.
+    
+    Args:
+        mask: B H W  with values 0 (black/background) or 1 (white/foreground)
+        data_label: B×1 tensor or B tensor with values [0, 1, 2, 3]
+                   - 0: background (no edit)
+                   - 1: physical edit (Photoshop)
+                   - 2: synthetic AI edit
+                   - 3: other edit type
+    
+    Returns:
+        target: B H W with values [0, 1, 2, 3]
+               - 0: unedited pixels (mask == 0)
+               - 1, 2, 3: edited pixels with their respective class labels
+    """
+    
+    # Handle if mask has channel dimension
+    if mask.dim() == 4:  # B×1×H×W
+        mask = mask.squeeze(1)  # B×H×W
+    
+    # Handle if data_label has extra dimensions
+    if data_label.dim() > 1:
+        data_label = data_label.squeeze()  # B
+    
+    B, H, W = mask.shape
+    
+    # Initialize target with zeros (background class)
+    target = torch.zeros(B, H, W, dtype=torch.long, device=mask.device)
+    
+    # For each sample in batch
+    for b in range(B):
+        # Get the class label for this sample
+        class_label = data_label[b].item() if data_label.dim() > 0 else data_label.item()
+        
+        # Where mask is white (1), set the target to the class label
+        # Where mask is black (0), keep target as 0 (background)
+        target[b][mask[b] == 1] = class_label
+    
+    return target
+
+
+def debug_target_creation(target, data_label, batch_size=4):
+    """
+    Debug function to print data_label and target mapping before and after conversion.
+    
+    Args:
+        target: Binary mask B×H×W or B×1×H×W with values 0 or 1
+        data_label: B tensor with class labels [0, 1, 2, 3]
+    """
+    
+    print("="*80)
+    print("DEBUGGING TARGET CREATION")
+    print("="*80)
+    
+    # Print original inputs
+    print("\n--- BEFORE CONVERSION ---")
+    print(f"Data Label shape: {data_label.shape}")
+    print(f"Data Label values: {data_label}")
+    print(f"Data Label dtype: {data_label.dtype}")
+    
+    print(f"\nTarget (mask) shape: {target.shape}")
+    print(f"Target (mask) unique values: {torch.unique(target)}")
+    print(f"Target (mask) dtype: {target.dtype}")
+    
+    # Print per-sample details BEFORE
+    print("\n--- PER-SAMPLE BREAKDOWN (BEFORE) ---")
+    if target.dim() == 4:  # B×1×H×W
+        target_2d = target.squeeze(1)
+    else:
+        target_2d = target
+    
+    B = target_2d.shape[0]
+    for b in range(min(B, batch_size)):
+        edited_pixels = (target_2d[b] == 1).sum().item()
+        total_pixels = target_2d[b].numel()
+        label = data_label[b].item() if data_label.dim() > 0 else data_label.item()
+        print(f"  Sample {b}: Label={label}, Edited pixels={edited_pixels}/{total_pixels}")
+    
+    # Create target
+    target_converted = create_target_from_mask_and_label(target, data_label)
+    
+    # Print AFTER conversion
+    print("\n--- AFTER CONVERSION ---")
+    print(f"Target (converted) shape: {target_converted.shape}")
+    print(f"Target (converted) unique values: {torch.unique(target_converted)}")
+    print(f"Target (converted) dtype: {target_converted.dtype}")
+    
+    # Print per-sample details AFTER
+    print("\n--- PER-SAMPLE BREAKDOWN (AFTER) ---")
+    for b in range(min(B, batch_size)):
+        label = data_label[b].item() if data_label.dim() > 0 else data_label.item()
+        
+        # Count pixels for each class
+        class_counts = {}
+        for class_id in range(4):
+            count = (target_converted[b] == class_id).sum().item()
+            class_counts[class_id] = count
+        
+        print(f"  Sample {b}:")
+        print(f"    Label (expected): {label}")
+        print(f"    Class distribution: {class_counts}")
+        
+        # Verify correctness
+        if label == 0:
+            # All pixels should be background (0)
+            if class_counts[0] == target_converted[b].numel():
+                print(f"    ✓ CORRECT: All pixels are class 0 (background)")
+            else:
+                print(f"    ✗ ERROR: Expected all pixels to be 0, but got {class_counts}")
+        else:
+            # Non-background pixels should have the label
+            if class_counts[label] > 0:
+                print(f"    ✓ CORRECT: Found {class_counts[label]} pixels with class {label}")
+            else:
+                print(f"    ✗ ERROR: Expected class {label} pixels but found none")
+    
+    print("\n" + "="*80)
+    
+    return target_converted
+
+class MultiClassDiceEntropyLoss(nn.Module):
+    """
+    Multi-class segmentation loss combining Dice and CrossEntropy.
+    Supports classes: 0 (background), 1, 2, 3
+    """
+    def __init__(self, num_classes=4, smooth=1e-5, dice_weight=0.5, ce_weight=0.5, 
+                 ignore_index=-1):
+        super(MultiClassDiceEntropyLoss, self).__init__()
+        self.num_classes = num_classes
+        self.smooth = smooth
+        self.dice_weight = dice_weight
+        self.ce_weight = ce_weight
+        self.ignore_index = ignore_index
+        
+        # CrossEntropy loss
+        self.ce_loss = nn.CrossEntropyLoss(ignore_index=ignore_index)
+    
+    def dice_loss(self, pred, target, valid_mask=None):
+        """
+        Compute Dice loss per class and average
+        
+        pred: B C H W (softmax probabilities)
+        target: B H W (class indices 0-3)
+        valid_mask: B H W (1 for valid, 0 for ignore)
+        """
+        dice_losses = []
+        
+        for class_id in range(self.num_classes):
+            # One-hot encode for this class
+            pred_class = pred[:, class_id, :, :]  # B×H×W
+            target_class = (target == class_id).float()  # B×H×W
+            
+            # Flatten
+            pred_flat = pred_class.reshape(-1)
+            target_flat = target_class.reshape(-1)
+            
+            # Apply valid mask if provided
+            if valid_mask is not None:
+                valid_flat = valid_mask.reshape(-1)
+                pred_flat = pred_flat * valid_flat
+                target_flat = target_flat * valid_flat
+            
+            # Dice computation
+            intersection = torch.sum(pred_flat * target_flat)
+            union = torch.sum(pred_flat) + torch.sum(target_flat)
+            
+            dice = (2 * intersection + self.smooth) / (union + self.smooth)
+            dice_losses.append(1 - dice)
+        
+        return torch.mean(torch.stack(dice_losses))
+    
+    def forward(self, score, target, data_label):
+        """
+        pred: B 1 H W (U-Net output, raw logits)
+        target: B H W (class labels: 0, 1, 2, or 3)
+        """
+        # Handle if target has channel dimension
+        if target.dim() == 4:  # B×1×H×W
+            target = target.squeeze(1)  # B×H×W
+        # target = create_target_from_mask_and_label(target, data_label)
+        
+        
+        # test_result = debug_target_creation(target, data_label, batch_size=1)
+    
+        # Ensure target i'=s long type
+        target = target.long()
+        
+        # Upsample pred if needed
+        if score.shape[2:] != target.shape[1:]:
+            score = F.interpolate(score, size=target.shape[1:], mode='bilinear', align_corners=False)
+        
+        # Convert single channel to multi-class
+        # If score is B×1×H×W, we need to expand it to B×C×H×W
+        # if score.shape[1] == 1:
+        #     # U-Net outputs 1 channel, we need to create num_classes channels
+        #     # This assumes your U-Net needs modification OR
+        #     # we convert single channel to multi-class logits
+        #     raise ValueError(
+        #         f"U-Net outputs {score.shape[1]} channel but {self.num_classes} classes expected. "
+        #         "Modify U-Net output layer to have num_classes={} channels".format(self.num_classes)
+        #     )
+        
+        # Apply softmax to get probabilities
+        score_probs = F.softmax(score, dim=1)  # B×C×H×W
+    
+        # CrossEntropy loss
+        ce_loss = self.ce_loss(score, target)
+        
+        # Valid mask (exclude ignore_index)
+        valid_mask = (target != self.ignore_index).float()
+        
+        # Dice loss
+        dice_loss = self.dice_loss(score_probs, target, valid_mask)
+        
+        # Combined loss
+        total_loss = self.dice_weight * dice_loss + self.ce_weight * ce_loss
+        
+        return total_loss
+
+
+class DiceEntropyLoss(nn.Module):
+    def __init__(self, smooth=1, exponent=2, ignore_label=-1, weight=None): #because padding adds -1 to the targets
+        super(DiceEntropyLoss, self).__init__()  
+        self.ignore_label = ignore_label
+        self.smooth = smooth
+        self.exponent = exponent
+        self.cross_entropy = nn.CrossEntropyLoss(weight=weight, 
+                                             ignore_index=ignore_label)
+    
+    def binary_dice_loss(self, pred, target, valid_mask):
+        assert pred.shape[0] == target.shape[0]
+        pred = pred.reshape(pred.shape[0], -1)
+        target = target.reshape(target.shape[0], -1)
+        valid_mask = valid_mask.reshape(valid_mask.shape[0], -1)
+
+        num = torch.sum(torch.mul(pred, target) * valid_mask, dim=1) * 2 + self.smooth
+        den = torch.sum(pred.pow(self.exponent)*valid_mask + target.pow(self.exponent)*valid_mask, dim=1) + max(self.smooth, 1e-5)
+        
+        dice = num / den
+        dice = torch.mean(dice)
+        return 1 - dice
+        
+    def forward(self, score, target):
+        target = target.squeeze(1).long()
+
+        target = torch.clamp(target, min=0, max=1)
+        ph, pw = score.size(2), score.size(3) # (B,1,224,224)
+        h, w = target.size(1), target.size(2) # (B,224,224)
+        if ph != h or pw != w:
+            score = F.upsample(
+                    input=score, size=(h, w), mode='bilinear')
+
+        CE_loss   = self.cross_entropy(score, target)
+        
+        
+        score = F.softmax(score,dim=1)
+        num_classes = score.shape[1]
+        
+        one_hot_target = F.one_hot(
+            torch.clamp(target.long(), 0, num_classes - 1),
+            num_classes=num_classes)
+        valid_mask = (target != self.ignore_label).long()
+        
+        # dice_loss = self.binary_dice_loss(
+        #             score[:, 1],
+        #             one_hot_target[..., 1],
+        #             valid_mask)
+
+        number_of_present_classes = 4
+        dice_loss = 0
+        for class_id in [1,2,3]:
+            if (target == class_id).sum() > 0:  
+                dice_loss += dice(pred[:, class_id], target_onehot[:, class_id])
+        dice_loss /= number_of_present_classes
+
+        return 0.3*CE_loss + 0.7*dice_loss
+
+
+
+    
+class FocalLoss(nn.Module):
+
+    def __init__(self, alpha=0.25, gamma=2., ignore_label=-1):  #alpha 0.25, gamma=2.
+        super(FocalLoss, self).__init__()
+        self.alpha=alpha
+        self.gamma= gamma
+        self.criterion = nn.CrossEntropyLoss(ignore_index=ignore_label, reduction="none")
+       
+    def forward(self, score, target):  
+        ph, pw = score.size(2), score.size(3)
+        h, w = target.size(1), target.size(2)
+        if ph != h or pw != w:
+            score = F.upsample(
+                    input=score, size=(h, w), mode='bilinear')
+            
+        ce_loss = self.criterion(score, target)
+        pt = torch.exp(-ce_loss)
+        f_loss = self.alpha * (1-pt)**self.gamma * ce_loss
+        return f_loss.mean()
+        
+