backend+modell

Dockerfile

@@ -0,0 +1,24 @@
+FROM python:3.9
+
+RUN useradd -m -u 1000 user
+
+USER user
+
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+COPY --chown=user ./requirements.txt requirements.txt
+
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+COPY --chown=user . /app
+
+ENV MODEL_PATH=/app/files/checkpoint.pth
+ENV MODEL_DEVICE=cuda
+ENV LOG_LEVEL=INFO
+
+EXPOSE 7860
+
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]
+

app.py

@@ -0,0 +1,43 @@
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from app.core.config import settings
+from app.core.logging_config import setup_logging
+from app.api.v1.router import api_router
+from app.core.exceptions import setup_exception_handlers
+from app.core.startup import startup_event, shutdown_event
+
+setup_logging()
+
+app = FastAPI(
+    title=settings.APP_NAME,
+    version=settings.APP_VERSION,
+    description=settings.APP_DESCRIPTION
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=settings.ALLOWED_ORIGINS,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+setup_exception_handlers(app)
+app.include_router(api_router, prefix="/api/v1")
+
+@app.on_event("startup")
+async def startup():
+    await startup_event(app)
+
+@app.on_event("shutdown")
+async def shutdown():
+    await shutdown_event(app)
+
+@app.get("/")
+async def root():
+    return {"status": "healthy", "service": settings.APP_NAME}
+
+@app.get("/health")
+async def health_check():
+    return {"status": "healthy"}
+

app/api/v1/endpoints/health.py

@@ -0,0 +1,50 @@
+from fastapi import APIRouter, status
+from fastapi.responses import JSONResponse
+import logging
+from app.services.model_loader import model_loader
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+@router.get("/")
+async def health_check():
+    try:
+        model_loaded = model_loader.model is not None
+        return JSONResponse(
+            status_code=status.HTTP_200_OK,
+            content={
+                "status": "healthy",
+                "model_loaded": model_loaded
+            }
+        )
+    except Exception as e:
+        logger.error(f"Health check error: {str(e)}")
+        return JSONResponse(
+            status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
+            content={
+                "status": "unhealthy",
+                "error": str(e)
+            }
+        )
+
+@router.get("/model")
+async def model_status():
+    try:
+        model_loaded = model_loader.model is not None
+        device = str(model_loader.device) if model_loader.device else None
+        
+        return JSONResponse(
+            status_code=status.HTTP_200_OK,
+            content={
+                "model_loaded": model_loaded,
+                "device": device
+            }
+        )
+    except Exception as e:
+        logger.error(f"Model status error: {str(e)}")
+        return JSONResponse(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            content={"error": str(e)}
+        )
+

app/api/v1/endpoints/inference.py

@@ -0,0 +1,100 @@
+from fastapi import APIRouter, UploadFile, File, HTTPException, status
+from fastapi.responses import Response
+import logging
+from app.services.inference_service import inference_service
+from app.services.image_processor import image_processor
+from app.core.exceptions import ImageProcessingError, InferenceError
+from app.core.config import settings
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+@router.post("/predict")
+async def predict_segmentation(
+    file: UploadFile = File(...)
+):
+    try:
+        if not file.content_type or not file.content_type.startswith("image/"):
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail="File must be an image"
+            )
+        
+        image_bytes = await file.read()
+        image_processor.validate_image(image_bytes)
+        
+        image = image_processor.decode_image(image_bytes)
+        image_tensor = image_processor.preprocess(image)
+        
+        result = inference_service.predict(image_tensor)
+        
+        return Response(
+            content=result["mask"],
+            media_type="image/jpeg",
+            headers={
+                "X-Inference-Time": str(result["inference_time"]),
+                "X-Image-Shape": str(result["image_shape"])
+            }
+        )
+        
+    except ImageProcessingError as e:
+        logger.error(f"Image processing error: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=str(e)
+        )
+    except InferenceError as e:
+        logger.error(f"Inference error: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=str(e)
+        )
+    except Exception as e:
+        logger.exception(f"Unexpected error: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Internal server error"
+        )
+
+@router.post("/predict-with-metadata")
+async def predict_with_metadata(
+    file: UploadFile = File(...)
+):
+    try:
+        if not file.content_type or not file.content_type.startswith("image/"):
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail="File must be an image"
+            )
+        
+        image_bytes = await file.read()
+        image_processor.validate_image(image_bytes)
+        
+        image = image_processor.decode_image(image_bytes)
+        image_tensor = image_processor.preprocess(image)
+        
+        result = inference_service.predict(image_tensor)
+        
+        from app.schemas.response_schemas import InferenceResponse
+        return InferenceResponse(**result)
+        
+    except ImageProcessingError as e:
+        logger.error(f"Image processing error: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=str(e)
+        )
+    except InferenceError as e:
+        logger.error(f"Inference error: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=str(e)
+        )
+    except Exception as e:
+        logger.exception(f"Unexpected error: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Internal server error"
+        )
+

app/api/v1/router.py

@@ -0,0 +1,19 @@
+from fastapi import APIRouter, UploadFile, File, HTTPException
+from fastapi.responses import Response
+from app.api.v1.endpoints import inference, health
+from app.core.config import settings
+
+api_router = APIRouter()
+
+api_router.include_router(
+    inference.router,
+    prefix="/inference",
+    tags=["inference"]
+)
+
+api_router.include_router(
+    health.router,
+    prefix="/health",
+    tags=["health"]
+)
+

app/core/config.py

@@ -0,0 +1,42 @@
+import os
+from pydantic_settings import BaseSettings
+from typing import List
+
+class Settings(BaseSettings):
+    APP_NAME: str = "Dentimap API"
+    APP_VERSION: str = "1.0.0"
+    APP_DESCRIPTION: str = "Medical Image Segmentation API for Dental Mapping"
+    
+    MODEL_PATH: str = os.getenv("MODEL_PATH", "/app/files/checkpoint.pth")
+    MODEL_DEVICE: str = os.getenv("MODEL_DEVICE", "cuda")
+    NUM_CLASSES: int = 4
+    IMAGE_WIDTH: int = 512
+    IMAGE_HEIGHT: int = 256
+    
+    MAX_IMAGE_SIZE: int = 10 * 1024 * 1024
+    ALLOWED_EXTENSIONS: List[str] = [".jpg", ".jpeg", ".png", ".bmp"]
+    
+    ALLOWED_ORIGINS: List[str] = ["*"]
+    
+    LOG_LEVEL: str = os.getenv("LOG_LEVEL", "INFO")
+    
+    COLORMAP: List[List[int]] = [
+        [0, 0, 0],
+        [255, 243, 28],
+        [255, 52, 255],
+        [70, 74, 255],
+    ]
+    
+    CLASS_NAMES: List[str] = [
+        "background",
+        "class_1",
+        "class_2",
+        "class_3"
+    ]
+    
+    class Config:
+        env_file = ".env"
+        case_sensitive = True
+
+settings = Settings()
+

app/core/exceptions.py

@@ -0,0 +1,67 @@
+from fastapi import FastAPI, Request, status
+from fastapi.responses import JSONResponse
+from fastapi.exceptions import RequestValidationError
+from starlette.exceptions import HTTPException as StarletteHTTPException
+import logging
+
+logger = logging.getLogger(__name__)
+
+class InferenceError(Exception):
+    pass
+
+class ModelLoadError(Exception):
+    pass
+
+class ImageProcessingError(Exception):
+    pass
+
+async def validation_exception_handler(request: Request, exc: RequestValidationError):
+    logger.warning(f"Validation error: {exc.errors()}")
+    return JSONResponse(
+        status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+        content={"detail": exc.errors(), "body": exc.body}
+    )
+
+async def http_exception_handler(request: Request, exc: StarletteHTTPException):
+    logger.warning(f"HTTP exception: {exc.status_code} - {exc.detail}")
+    return JSONResponse(
+        status_code=exc.status_code,
+        content={"detail": exc.detail}
+    )
+
+async def inference_exception_handler(request: Request, exc: InferenceError):
+    logger.error(f"Inference error: {str(exc)}")
+    return JSONResponse(
+        status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+        content={"detail": f"Inference error: {str(exc)}"}
+    )
+
+async def model_load_exception_handler(request: Request, exc: ModelLoadError):
+    logger.error(f"Model load error: {str(exc)}")
+    return JSONResponse(
+        status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
+        content={"detail": f"Model load error: {str(exc)}"}
+    )
+
+async def image_processing_exception_handler(request: Request, exc: ImageProcessingError):
+    logger.error(f"Image processing error: {str(exc)}")
+    return JSONResponse(
+        status_code=status.HTTP_400_BAD_REQUEST,
+        content={"detail": f"Image processing error: {str(exc)}"}
+    )
+
+async def general_exception_handler(request: Request, exc: Exception):
+    logger.exception(f"Unhandled exception: {str(exc)}")
+    return JSONResponse(
+        status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+        content={"detail": "Internal server error"}
+    )
+
+def setup_exception_handlers(app: FastAPI):
+    app.add_exception_handler(RequestValidationError, validation_exception_handler)
+    app.add_exception_handler(StarletteHTTPException, http_exception_handler)
+    app.add_exception_handler(InferenceError, inference_exception_handler)
+    app.add_exception_handler(ModelLoadError, model_load_exception_handler)
+    app.add_exception_handler(ImageProcessingError, image_processing_exception_handler)
+    app.add_exception_handler(Exception, general_exception_handler)
+

app/core/logging_config.py

@@ -0,0 +1,16 @@
+import logging
+import sys
+from app.core.config import settings
+
+def setup_logging():
+    logging.basicConfig(
+        level=getattr(logging, settings.LOG_LEVEL.upper()),
+        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+        handlers=[
+            logging.StreamHandler(sys.stdout)
+        ]
+    )
+    
+    logging.getLogger("uvicorn").setLevel(logging.INFO)
+    logging.getLogger("fastapi").setLevel(logging.INFO)
+

app/core/startup.py

@@ -0,0 +1,20 @@
+import logging
+from fastapi import FastAPI
+from app.services.model_loader import model_loader
+from app.services.inference_service import inference_service
+
+logger = logging.getLogger(__name__)
+
+async def startup_event(app: FastAPI):
+    try:
+        logger.info("Starting up application...")
+        model_loader.load_model()
+        inference_service.initialize()
+        logger.info("Application startup complete")
+    except Exception as e:
+        logger.error(f"Startup error: {str(e)}")
+        raise
+
+async def shutdown_event(app: FastAPI):
+    logger.info("Shutting down application...")
+

app/models/unet_model.py

@@ -0,0 +1,68 @@
+import torch
+import torch.nn as nn
+
+class ConvBlock(nn.Module):
+    def __init__(self, in_c, out_c):
+        super().__init__()
+        self.conv = nn.Sequential(
+            nn.Conv2d(in_c, out_c, kernel_size=3, padding=1),
+            nn.BatchNorm2d(out_c),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(out_c, out_c, kernel_size=3, padding=1),
+            nn.BatchNorm2d(out_c),
+            nn.ReLU(inplace=True)
+        )
+
+    def forward(self, inputs):
+        return self.conv(inputs)
+
+class EncoderBlock(nn.Module):
+    def __init__(self, in_c, out_c):
+        super().__init__()
+        self.conv = ConvBlock(in_c, out_c)
+        self.pool = nn.MaxPool2d((2, 2))
+
+    def forward(self, inputs):
+        x = self.conv(inputs)
+        p = self.pool(x)
+        return x, p
+
+class DecoderBlock(nn.Module):
+    def __init__(self, in_c, out_c):
+        super().__init__()
+        self.up = nn.ConvTranspose2d(in_c, out_c, kernel_size=2, stride=2, padding=0)
+        self.conv = ConvBlock(out_c+out_c, out_c)
+
+    def forward(self, inputs, skip):
+        x = self.up(inputs)
+        x = torch.cat([x, skip], axis=1)
+        x = self.conv(x)
+        return x
+
+class BuildUNet(nn.Module):
+    def __init__(self, num_classes=4):
+        super().__init__()
+        self.e1 = EncoderBlock(3, 64)
+        self.e2 = EncoderBlock(64, 128)
+        self.e3 = EncoderBlock(128, 256)
+        self.e4 = EncoderBlock(256, 512)
+        self.b = ConvBlock(512, 1024)
+        self.d1 = DecoderBlock(1024, 512)
+        self.d2 = DecoderBlock(512, 256)
+        self.d3 = DecoderBlock(256, 128)
+        self.d4 = DecoderBlock(128, 64)
+        self.outputs = nn.Conv2d(64, num_classes, kernel_size=1, padding=0)
+
+    def forward(self, inputs):
+        s1, p1 = self.e1(inputs)
+        s2, p2 = self.e2(p1)
+        s3, p3 = self.e3(p2)
+        s4, p4 = self.e4(p3)
+        b = self.b(p4)
+        d1 = self.d1(b, s4)
+        d2 = self.d2(d1, s3)
+        d3 = self.d3(d2, s2)
+        d4 = self.d4(d3, s1)
+        outputs = self.outputs(d4)
+        return outputs
+

app/schemas/request_schemas.py

@@ -0,0 +1,8 @@
+from pydantic import BaseModel, Field
+from typing import Optional
+
+class InferenceRequest(BaseModel):
+    image: bytes = Field(..., description="Image file as bytes")
+    return_overlay: Optional[bool] = Field(False, description="Return overlay visualization")
+    format: Optional[str] = Field(".jpg", description="Output format (.jpg or .png)")
+

app/schemas/response_schemas.py

@@ -0,0 +1,17 @@
+from pydantic import BaseModel
+from typing import Dict
+
+class ClassDistribution(BaseModel):
+    pixel_count: int
+    percentage: float
+
+class InferenceResponse(BaseModel):
+    mask: bytes
+    inference_time: float
+    class_distribution: Dict[str, ClassDistribution]
+    image_shape: tuple
+
+class HealthResponse(BaseModel):
+    status: str
+    model_loaded: bool
+

app/services/image_processor.py

@@ -0,0 +1,61 @@
+import cv2
+import numpy as np
+import torch
+from typing import Tuple
+from app.core.config import settings
+from app.core.exceptions import ImageProcessingError
+import logging
+
+logger = logging.getLogger(__name__)
+
+class ImageProcessor:
+    def __init__(self):
+        self.target_size = (settings.IMAGE_WIDTH, settings.IMAGE_HEIGHT)
+        self.max_size = settings.MAX_IMAGE_SIZE
+    
+    def validate_image(self, image_bytes: bytes) -> None:
+        if len(image_bytes) > self.max_size:
+            raise ImageProcessingError(f"Image size exceeds maximum allowed size of {self.max_size} bytes")
+    
+    def decode_image(self, image_bytes: bytes) -> np.ndarray:
+        try:
+            nparr = np.frombuffer(image_bytes, np.uint8)
+            image = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
+            if image is None:
+                raise ImageProcessingError("Failed to decode image")
+            return image
+        except Exception as e:
+            raise ImageProcessingError(f"Error decoding image: {str(e)}")
+    
+    def preprocess(self, image: np.ndarray) -> torch.Tensor:
+        try:
+            resized = cv2.resize(image, self.target_size)
+            normalized = resized.astype(np.float32) / 255.0
+            transposed = np.transpose(normalized, (2, 0, 1))
+            tensor = torch.from_numpy(transposed).unsqueeze(0)
+            return tensor
+        except Exception as e:
+            raise ImageProcessingError(f"Error preprocessing image: {str(e)}")
+    
+    def postprocess_mask(self, mask: np.ndarray) -> np.ndarray:
+        h, w = mask.shape
+        output = np.zeros((h, w, 3), dtype=np.uint8)
+        for idx, color in enumerate(settings.COLORMAP):
+            output[mask == idx] = color
+        return output
+    
+    def encode_image(self, image: np.ndarray, format: str = ".jpg") -> bytes:
+        try:
+            encode_param = [int(cv2.IMWRITE_JPEG_QUALITY), 95]
+            if format == ".png":
+                encode_param = [int(cv2.IMWRITE_PNG_COMPRESSION), 9]
+            
+            success, encoded = cv2.imencode(format, image, encode_param)
+            if not success:
+                raise ImageProcessingError("Failed to encode image")
+            return encoded.tobytes()
+        except Exception as e:
+            raise ImageProcessingError(f"Error encoding image: {str(e)}")
+
+image_processor = ImageProcessor()
+

app/services/inference_service.py

@@ -0,0 +1,71 @@
+import torch
+import numpy as np
+import time
+import logging
+from app.services.model_loader import model_loader
+from app.services.image_processor import image_processor
+from app.core.exceptions import InferenceError
+from app.core.config import settings
+
+logger = logging.getLogger(__name__)
+
+class InferenceService:
+    def __init__(self):
+        self.model = None
+        self.device = None
+    
+    def initialize(self):
+        if self.model is None:
+            model_loader.load_model()
+            self.model = model_loader.get_model()
+            self.device = model_loader.get_device()
+            logger.info("Inference service initialized")
+    
+    def predict(self, image_tensor: torch.Tensor) -> dict:
+        if self.model is None:
+            self.initialize()
+        
+        try:
+            start_time = time.time()
+            
+            image_tensor = image_tensor.to(self.device)
+            
+            with torch.no_grad():
+                logits = self.model(image_tensor)
+                probs = torch.softmax(logits, dim=1)
+                pred_mask = torch.argmax(probs, dim=1)
+                pred_mask = pred_mask.squeeze(0).cpu().numpy().astype(np.uint8)
+            
+            inference_time = time.time() - start_time
+            
+            colored_mask = image_processor.postprocess_mask(pred_mask)
+            
+            mask_bytes = image_processor.encode_image(colored_mask)
+            
+            class_counts = self._calculate_class_distribution(pred_mask)
+            
+            return {
+                "mask": mask_bytes,
+                "inference_time": round(inference_time, 4),
+                "class_distribution": class_counts,
+                "image_shape": pred_mask.shape
+            }
+            
+        except Exception as e:
+            logger.error(f"Inference error: {str(e)}")
+            raise InferenceError(f"Inference failed: {str(e)}")
+    
+    def _calculate_class_distribution(self, mask: np.ndarray) -> dict:
+        unique, counts = np.unique(mask, return_counts=True)
+        total_pixels = mask.size
+        distribution = {}
+        for class_idx, count in zip(unique, counts):
+            class_name = settings.CLASS_NAMES[class_idx] if class_idx < len(settings.CLASS_NAMES) else f"class_{class_idx}"
+            distribution[class_name] = {
+                "pixel_count": int(count),
+                "percentage": round((count / total_pixels) * 100, 2)
+            }
+        return distribution
+
+inference_service = InferenceService()
+

app/services/model_loader.py

@@ -0,0 +1,56 @@
+import torch
+import logging
+from pathlib import Path
+from app.models.unet_model import BuildUNet
+from app.core.config import settings
+from app.core.exceptions import ModelLoadError
+
+logger = logging.getLogger(__name__)
+
+class ModelLoader:
+    def __init__(self):
+        self.model = None
+        self.device = None
+        self._load_device()
+    
+    def _load_device(self):
+        if settings.MODEL_DEVICE == "cuda" and torch.cuda.is_available():
+            self.device = torch.device("cuda")
+            logger.info(f"Using GPU: {torch.cuda.get_device_name(0)}")
+        else:
+            self.device = torch.device("cpu")
+            logger.info("Using CPU")
+    
+    def load_model(self):
+        try:
+            model_path = Path(settings.MODEL_PATH)
+            if not model_path.exists():
+                raise ModelLoadError(f"Model file not found at {settings.MODEL_PATH}")
+            
+            logger.info(f"Loading model from {settings.MODEL_PATH}")
+            self.model = BuildUNet(num_classes=settings.NUM_CLASSES)
+            
+            checkpoint = torch.load(model_path, map_location=self.device)
+            if isinstance(checkpoint, dict) and "model_state_dict" in checkpoint:
+                self.model.load_state_dict(checkpoint["model_state_dict"])
+            else:
+                self.model.load_state_dict(checkpoint)
+            
+            self.model.to(self.device)
+            self.model.eval()
+            logger.info("Model loaded successfully")
+            
+        except Exception as e:
+            logger.error(f"Failed to load model: {str(e)}")
+            raise ModelLoadError(f"Failed to load model: {str(e)}")
+    
+    def get_model(self):
+        if self.model is None:
+            raise ModelLoadError("Model not loaded. Call load_model() first.")
+        return self.model
+    
+    def get_device(self):
+        return self.device
+
+model_loader = ModelLoader()
+

app/utils/helpers.py

@@ -0,0 +1,13 @@
+import os
+from pathlib import Path
+
+def ensure_directory(path: str):
+    Path(path).mkdir(parents=True, exist_ok=True)
+
+def get_file_extension(filename: str) -> str:
+    return os.path.splitext(filename)[1].lower()
+
+def is_valid_image_extension(extension: str) -> bool:
+    from app.core.config import settings
+    return extension in settings.ALLOWED_EXTENSIONS
+

files/checkpoint.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:78915f441ab9c40b36fa65924e3dc94643af8b57811f71bd364aee37a6dcf7b8
+size 372687676

files/score.csv

@@ -0,0 +1,6 @@
+Class,F1,Jaccard
+background     ,0.99707,0.99418
+class_1        ,0.50255,0.37771
+class_2        ,0.20351,0.15947
+class_3        ,0.24261,0.21064
+Mean           ,0.31622,0.24927

files/train.log

@@ -0,0 +1,104 @@
+INFO:root:Image Size: (512, 256) - Batch Size: 16 - LR: 0.0001 - Epochs: 500 - Num Classes: 4 - Early Stopping Patience: 50 - Checkpoint Path: files/checkpoint.pth
+INFO:root:Dataset Size: Train: 997 - Valid: 125 - Test: 125
+INFO:root:Optimizer: Adam - Loss: Dice + Cross Entropy Loss
+INFO:root:[01/500] | Epoch Time: 0m 45s - Train Loss: 1.7755 - Val. Loss: 1.5772
+INFO:root:[02/500] | Epoch Time: 0m 43s - Train Loss: 1.4858 - Val. Loss: 1.4231
+INFO:root:[03/500] | Epoch Time: 0m 45s - Train Loss: 1.3734 - Val. Loss: 1.3292
+INFO:root:[04/500] | Epoch Time: 0m 45s - Train Loss: 1.2654 - Val. Loss: 1.2256
+INFO:root:[05/500] | Epoch Time: 0m 43s - Train Loss: 1.1833 - Val. Loss: 1.1446
+INFO:root:[06/500] | Epoch Time: 0m 44s - Train Loss: 1.1178 - Val. Loss: 1.0963
+INFO:root:[07/500] | Epoch Time: 0m 45s - Train Loss: 1.0638 - Val. Loss: 1.0379
+INFO:root:[08/500] | Epoch Time: 0m 44s - Train Loss: 1.0216 - Val. Loss: 1.0046
+INFO:root:[09/500] | Epoch Time: 0m 45s - Train Loss: 0.9865 - Val. Loss: 0.9672
+INFO:root:[10/500] | Epoch Time: 0m 45s - Train Loss: 0.9562 - Val. Loss: 0.9460
+INFO:root:[11/500] | Epoch Time: 0m 44s - Train Loss: 0.9275 - Val. Loss: 0.9191
+INFO:root:[12/500] | Epoch Time: 0m 44s - Train Loss: 0.8998 - Val. Loss: 0.8899
+INFO:root:[13/500] | Epoch Time: 0m 45s - Train Loss: 0.8679 - Val. Loss: 0.8517
+INFO:root:[14/500] | Epoch Time: 0m 44s - Train Loss: 0.8437 - Val. Loss: 0.8339
+INFO:root:[15/500] | Epoch Time: 0m 44s - Train Loss: 0.8209 - Val. Loss: 0.8063
+INFO:root:[16/500] | Epoch Time: 0m 45s - Train Loss: 0.8010 - Val. Loss: 0.8048
+INFO:root:[17/500] | Epoch Time: 0m 44s - Train Loss: 0.7818 - Val. Loss: 0.7597
+INFO:root:[18/500] | Epoch Time: 0m 44s - Train Loss: 0.7642 - Val. Loss: 0.7592
+INFO:root:[19/500] | Epoch Time: 0m 44s - Train Loss: 0.7497 - Val. Loss: 0.7385
+INFO:root:[20/500] | Epoch Time: 0m 43s - Train Loss: 0.7323 - Val. Loss: 0.7252
+INFO:root:[21/500] | Epoch Time: 0m 44s - Train Loss: 0.7137 - Val. Loss: 0.7007
+INFO:root:[22/500] | Epoch Time: 0m 45s - Train Loss: 0.6846 - Val. Loss: 0.6937
+INFO:root:[23/500] | Epoch Time: 0m 43s - Train Loss: 0.6579 - Val. Loss: 0.6572
+INFO:root:[24/500] | Epoch Time: 0m 43s - Train Loss: 0.6364 - Val. Loss: 0.6567
+INFO:root:[25/500] | Epoch Time: 0m 44s - Train Loss: 0.6198 - Val. Loss: 0.6438
+INFO:root:[26/500] | Epoch Time: 0m 44s - Train Loss: 0.5977 - Val. Loss: 0.6061
+INFO:root:[27/500] | Epoch Time: 0m 44s - Train Loss: 0.5792 - Val. Loss: 0.6231
+INFO:root:[28/500] | Epoch Time: 0m 44s - Train Loss: 0.5741 - Val. Loss: 0.5708
+INFO:root:[29/500] | Epoch Time: 0m 45s - Train Loss: 0.5648 - Val. Loss: 0.5588
+INFO:root:[30/500] | Epoch Time: 0m 44s - Train Loss: 0.5409 - Val. Loss: 0.5468
+INFO:root:[31/500] | Epoch Time: 0m 44s - Train Loss: 0.5281 - Val. Loss: 0.5506
+INFO:root:[32/500] | Epoch Time: 0m 45s - Train Loss: 0.5159 - Val. Loss: 0.5223
+INFO:root:[33/500] | Epoch Time: 0m 46s - Train Loss: 0.5047 - Val. Loss: 0.5157
+INFO:root:[34/500] | Epoch Time: 0m 44s - Train Loss: 0.4786 - Val. Loss: 0.4986
+INFO:root:[35/500] | Epoch Time: 0m 43s - Train Loss: 0.4561 - Val. Loss: 0.4820
+INFO:root:[36/500] | Epoch Time: 0m 43s - Train Loss: 0.4309 - Val. Loss: 0.4508
+INFO:root:[37/500] | Epoch Time: 0m 44s - Train Loss: 0.4149 - Val. Loss: 0.4227
+INFO:root:[38/500] | Epoch Time: 0m 43s - Train Loss: 0.3990 - Val. Loss: 0.4630
+INFO:root:[39/500] | Epoch Time: 0m 43s - Train Loss: 0.3912 - Val. Loss: 0.4266
+INFO:root:[40/500] | Epoch Time: 0m 44s - Train Loss: 0.3742 - Val. Loss: 0.4057
+INFO:root:[41/500] | Epoch Time: 0m 43s - Train Loss: 0.3660 - Val. Loss: 0.4384
+INFO:root:[42/500] | Epoch Time: 0m 44s - Train Loss: 0.3825 - Val. Loss: 0.3945
+INFO:root:[43/500] | Epoch Time: 0m 44s - Train Loss: 0.3646 - Val. Loss: 0.3884
+INFO:root:[44/500] | Epoch Time: 0m 45s - Train Loss: 0.3517 - Val. Loss: 0.3977
+INFO:root:[45/500] | Epoch Time: 0m 44s - Train Loss: 0.3455 - Val. Loss: 0.3796
+INFO:root:[46/500] | Epoch Time: 0m 44s - Train Loss: 0.3314 - Val. Loss: 0.3821
+INFO:root:[47/500] | Epoch Time: 0m 44s - Train Loss: 0.3292 - Val. Loss: 0.3628
+INFO:root:[48/500] | Epoch Time: 0m 44s - Train Loss: 0.3312 - Val. Loss: 0.4099
+INFO:root:[49/500] | Epoch Time: 0m 48s - Train Loss: 0.3316 - Val. Loss: 0.3946
+INFO:root:[50/500] | Epoch Time: 0m 46s - Train Loss: 0.3257 - Val. Loss: 0.3603
+INFO:root:[51/500] | Epoch Time: 0m 46s - Train Loss: 0.3187 - Val. Loss: 0.3697
+INFO:root:[52/500] | Epoch Time: 0m 45s - Train Loss: 0.3075 - Val. Loss: 0.3591
+INFO:root:[53/500] | Epoch Time: 0m 45s - Train Loss: 0.3054 - Val. Loss: 0.3669
+INFO:root:[54/500] | Epoch Time: 0m 44s - Train Loss: 0.3056 - Val. Loss: 0.3759
+INFO:root:[55/500] | Epoch Time: 0m 45s - Train Loss: 0.2982 - Val. Loss: 0.3600
+INFO:root:[56/500] | Epoch Time: 0m 46s - Train Loss: 0.3139 - Val. Loss: 0.3601
+INFO:root:[57/500] | Epoch Time: 0m 45s - Train Loss: 0.2982 - Val. Loss: 0.3492
+INFO:root:[58/500] | Epoch Time: 0m 44s - Train Loss: 0.2901 - Val. Loss: 0.3509
+INFO:root:[59/500] | Epoch Time: 0m 45s - Train Loss: 0.2882 - Val. Loss: 0.3435
+INFO:root:[60/500] | Epoch Time: 0m 45s - Train Loss: 0.3006 - Val. Loss: 0.3488
+INFO:root:[61/500] | Epoch Time: 0m 45s - Train Loss: 0.2909 - Val. Loss: 0.3451
+INFO:root:[62/500] | Epoch Time: 0m 45s - Train Loss: 0.2773 - Val. Loss: 0.3355
+INFO:root:[63/500] | Epoch Time: 0m 45s - Train Loss: 0.2825 - Val. Loss: 0.3429
+INFO:root:[64/500] | Epoch Time: 0m 45s - Train Loss: 0.2780 - Val. Loss: 0.3552
+INFO:root:[65/500] | Epoch Time: 0m 45s - Train Loss: 0.2746 - Val. Loss: 0.3410
+INFO:root:[66/500] | Epoch Time: 0m 44s - Train Loss: 0.2721 - Val. Loss: 0.3723
+INFO:root:[67/500] | Epoch Time: 0m 45s - Train Loss: 0.2732 - Val. Loss: 0.3285
+INFO:root:[68/500] | Epoch Time: 0m 46s - Train Loss: 0.2609 - Val. Loss: 0.3399
+INFO:root:[69/500] | Epoch Time: 0m 45s - Train Loss: 0.2624 - Val. Loss: 0.3225
+INFO:root:[70/500] | Epoch Time: 0m 45s - Train Loss: 0.2581 - Val. Loss: 0.3274
+INFO:root:[71/500] | Epoch Time: 0m 46s - Train Loss: 0.2552 - Val. Loss: 0.3262
+INFO:root:[72/500] | Epoch Time: 0m 46s - Train Loss: 0.2590 - Val. Loss: 0.3256
+INFO:root:[73/500] | Epoch Time: 0m 45s - Train Loss: 0.2525 - Val. Loss: 0.3265
+INFO:root:[74/500] | Epoch Time: 0m 44s - Train Loss: 0.2468 - Val. Loss: 0.3360
+INFO:root:[75/500] | Epoch Time: 0m 44s - Train Loss: 0.2521 - Val. Loss: 0.3264
+INFO:root:[76/500] | Epoch Time: 0m 45s - Train Loss: 0.2282 - Val. Loss: 0.3195
+INFO:root:[77/500] | Epoch Time: 0m 45s - Train Loss: 0.2253 - Val. Loss: 0.3177
+INFO:root:[78/500] | Epoch Time: 0m 44s - Train Loss: 0.2172 - Val. Loss: 0.3139
+INFO:root:[79/500] | Epoch Time: 0m 45s - Train Loss: 0.2129 - Val. Loss: 0.3127
+INFO:root:[80/500] | Epoch Time: 0m 45s - Train Loss: 0.2131 - Val. Loss: 0.3142
+INFO:root:[81/500] | Epoch Time: 0m 45s - Train Loss: 0.2151 - Val. Loss: 0.3115
+INFO:root:[82/500] | Epoch Time: 0m 45s - Train Loss: 0.2107 - Val. Loss: 0.3152
+INFO:root:[83/500] | Epoch Time: 0m 44s - Train Loss: 0.2113 - Val. Loss: 0.3127
+INFO:root:[84/500] | Epoch Time: 0m 46s - Train Loss: 0.2122 - Val. Loss: 0.3145
+INFO:root:[85/500] | Epoch Time: 0m 44s - Train Loss: 0.2051 - Val. Loss: 0.3147
+INFO:root:[86/500] | Epoch Time: 0m 46s - Train Loss: 0.2066 - Val. Loss: 0.3137
+INFO:root:[87/500] | Epoch Time: 0m 46s - Train Loss: 0.2065 - Val. Loss: 0.3177
+INFO:root:[88/500] | Epoch Time: 0m 45s - Train Loss: 0.2032 - Val. Loss: 0.3159
+INFO:root:[89/500] | Epoch Time: 0m 44s - Train Loss: 0.2030 - Val. Loss: 0.3155
+INFO:root:[90/500] | Epoch Time: 0m 44s - Train Loss: 0.2021 - Val. Loss: 0.3152
+INFO:root:[91/500] | Epoch Time: 0m 46s - Train Loss: 0.2036 - Val. Loss: 0.3140
+INFO:root:[92/500] | Epoch Time: 0m 45s - Train Loss: 0.2042 - Val. Loss: 0.3151
+INFO:root:[93/500] | Epoch Time: 0m 45s - Train Loss: 0.2025 - Val. Loss: 0.3152
+INFO:root:[94/500] | Epoch Time: 0m 46s - Train Loss: 0.2093 - Val. Loss: 0.3145
+INFO:root:[95/500] | Epoch Time: 0m 45s - Train Loss: 0.2048 - Val. Loss: 0.3147
+INFO:root:[96/500] | Epoch Time: 0m 45s - Train Loss: 0.2015 - Val. Loss: 0.3149
+INFO:root:[97/500] | Epoch Time: 0m 44s - Train Loss: 0.2011 - Val. Loss: 0.3142
+INFO:root:[98/500] | Epoch Time: 0m 44s - Train Loss: 0.2020 - Val. Loss: 0.3148
+INFO:root:[99/500] | Epoch Time: 0m 44s - Train Loss: 0.2054 - Val. Loss: 0.3145
+INFO:root:[100/500] | Epoch Time: 0m 45s - Train Loss: 0.2028 - Val. Loss: 0.3147
+INFO:root:[101/500] | Epoch Time: 0m 45s - Train Loss: 0.2036 - Val. Loss: 0.3150

requirements.txt

@@ -0,0 +1,10 @@
+fastapi==0.104.1
+uvicorn[standard]==0.24.0
+pydantic==2.5.0
+pydantic-settings==2.1.0
+torch>=2.0.0
+torchvision>=0.15.0
+numpy>=1.24.0
+opencv-python-headless>=4.8.0
+python-multipart==0.0.6
+Pillow>=8.3.0