refactor: replace VLM with rule-based skin type classifier, fix timing to seconds, Sri Lanka timezone

app/routes/analysis.py

@@ -1,13 +1,13 @@
 """
 POST /analyze — full skin analysis pipeline.
 
-Pipeline (all steps after skin crop run in parallel threads):
+Pipeline:
   1. FaceLandmarker → skin mask crop
   2a. OpenCV feature extraction  ┐ ThreadPoolExecutor
-  2b. EfficientNet + skintel     │ (4 threads, wall time ≈ slowest)
-  2c. Face detection             │
-  2d. Qwen3-VL-2B-Instruct      ┘ → skin type + vlm concern scores
-  3. Scoring engine → 10 concern scores (existing pipeline)
+  2b. EfficientNet + skintel     │ (3 threads, wall time ≈ slowest)
+  2c. Face detection             ┘
+  3. Rule-based skin type classification (from OpenCV features, ~0ms)
+  4. Scoring engine → 10 concern scores
 """
 
 import base64
@@ -15,19 +15,20 @@ import io
 import logging
 import time
 from concurrent.futures import ThreadPoolExecutor
-from datetime import datetime
+from datetime import datetime, timezone, timedelta
 
 import cv2
 import numpy as np
 from fastapi import APIRouter, File, Form, HTTPException, UploadFile
 from PIL import Image
 
-from app.schemas import AnalysisResponse, ConcernResult, OpenCVFeatures, PipelineTiming, VLMConcernResult
+from app.schemas import AnalysisResponse, ConcernResult, OpenCVFeatures, PipelineTiming
 from app.services.face_detection import detect_faces
 from app.services.feature_extraction import extract_opencv_features
-from app.services.model_inference import _models_available, run_parallel_inference, run_vlm_analysis
+from app.services.model_inference import _models_available, run_parallel_inference
 from app.services.scoring import calculate_concerns
 from app.services.skin_crop import extract_skin_crop
+from app.services.skin_type import classify_skin_type
 
 router = APIRouter(prefix="/analyze", tags=["analysis"])
 log = logging.getLogger("skinscope.pipeline")
@@ -38,6 +39,9 @@ logging.basicConfig(
     datefmt="%H:%M:%S",
 )
 
+# Sri Lanka Standard Time = UTC+5:30
+_SL_TZ = timezone(timedelta(hours=5, minutes=30))
+
 
 def _encode(image_rgb: np.ndarray) -> str:
     bgr = cv2.cvtColor(image_rgb, cv2.COLOR_RGB2BGR)
@@ -50,8 +54,8 @@ async def analyze(
     file: UploadFile = File(...),
     confidence: float = Form(0.5),
 ):
-    t_start    = time.perf_counter()
-    dt_start   = datetime.now()
+    t_start  = time.perf_counter()
+    dt_start = datetime.now(_SL_TZ)
 
     # ── 1. Decode image ───────────────────────────────────────────────────────
     contents = await file.read()
@@ -61,7 +65,7 @@ async def analyze(
 
     log.info("═" * 65)
     log.info("  SKINSCOPE ANALYSIS PIPELINE")
-    log.info(f"  START   {dt_start.strftime('%Y-%m-%d %H:%M:%S.%f')[:-3]}")
+    log.info(f"  START   {dt_start.strftime('%Y-%m-%d %H:%M:%S')} (Sri Lanka Time)")
     log.info("═" * 65)
     log.info(f"  INPUT   filename={file.filename}  size={w}×{h}px  "
              f"conf_threshold={confidence}")
@@ -70,36 +74,32 @@ async def analyze(
     # ── 2. Skin crop ──────────────────────────────────────────────────────────
     t0 = time.perf_counter()
     skin_crop = extract_skin_crop(image_rgb)
-    skin_time = time.perf_counter() - t0
+    skin_s = time.perf_counter() - t0
 
     if skin_crop is None:
         log.warning("  SKIN CROP  no face detected — aborting")
         raise HTTPException(status_code=422, detail="No face detected in image.")
 
     skin_px = int(np.any(skin_crop > 0, axis=2).sum())
-    log.info(f"  SKIN CROP  {skin_px:,} skin pixels extracted  ({skin_time*1000:.0f}ms)")
+    log.info(f"  SKIN CROP  {skin_px:,} skin pixels extracted  ({skin_s:.3f}s)")
 
-    # ── 3. Parallel feature extraction (4 threads) ───────────────────────────
-    log.info("  PARALLEL THREADS  starting OpenCV + EfficientNet + Detection + Qwen3-VL …")
+    # ── 3. Parallel feature extraction (3 threads) ───────────────────────────
+    log.info("  PARALLEL THREADS  starting OpenCV + EfficientNet + Detection …")
     t0 = time.perf_counter()
 
-    with ThreadPoolExecutor(max_workers=4) as pool:
+    with ThreadPoolExecutor(max_workers=3) as pool:
         f_opencv = pool.submit(extract_opencv_features, skin_crop)
         f_ml     = pool.submit(run_parallel_inference,  image_rgb, skin_crop)
         f_detect = pool.submit(detect_faces,            image_rgb, confidence)
-        f_vlm    = pool.submit(run_vlm_analysis,        skin_crop)
 
         opencv_features  = f_opencv.result()
         ml_features      = f_ml.result()
         detection_result = f_detect.result()
-        vlm_result       = f_vlm.result()
-
-    parallel_time = time.perf_counter() - t0
 
-    # ── 4. Log raw features ───────────────────────────────────────────────────
+    parallel_s = time.perf_counter() - t0
     all_features = {**opencv_features, **ml_features}
 
-    log.info(f"  PARALLEL THREADS  done in {parallel_time*1000:.0f}ms")
+    log.info(f"  PARALLEL THREADS  done in {parallel_s:.3f}s")
     log.info("  ┌─ RAW FEATURES ───────────────────────────────────────")
     log.info(f"  │  OpenCV")
     for k, v in opencv_features.items():
@@ -111,19 +111,16 @@ async def analyze(
         log.info(f"  │    {k:<28} = {v:.4f}  {bar}")
     log.info(f"  │  Face Detection")
     log.info(f"  │    faces_detected           = {detection_result.face_count}")
-    log.info(f"  │  Qwen3-VL-2B")
-    log.info(f"  │    skin_type                = {vlm_result['skin_type']}")
-    log.info(f"  │    vlm_inference_time        = {vlm_result['vlm_inference_ms']:.0f}ms")
-    for c in vlm_result["vlm_concerns"]:
-        bar = "▓" * int((c["score"] - 10) / 85 * 20)
-        log.info(f"  │    {c['name']:<28} = {c['score']:.1f}/95  [{c['severity']:<8}]  {bar}")
     log.info("  └──────────────────────────────────────────────────────")
 
+    # ── 4. Rule-based skin type classification ────────────────────────────────
+    skin_type = classify_skin_type(opencv_features)
+
     # ── 5. Score 10 concerns ──────────────────────────────────────────────────
     t0 = time.perf_counter()
     concerns = calculate_concerns(all_features)
-    score_time = time.perf_counter() - t0
-    log.info(f"  SCORING  done in {score_time*1000:.0f}ms")
+    scoring_s = time.perf_counter() - t0
+    log.info(f"  SCORING  done in {scoring_s:.3f}s")
 
     # ── 6. Build response ─────────────────────────────────────────────────────
     models_used = ["OpenCV"]
@@ -131,25 +128,22 @@ async def analyze(
         models_used.append("EfficientNet-B0")
     if _models_available.get("skintel"):
         models_used.append("skintelligent-acne")
-    if _models_available.get("qwen_vlm"):
-        models_used.append("Qwen3-VL-2B-Instruct")
 
     annotated_bytes = base64.b64decode(detection_result.annotated_image)
     annotated_array = np.array(Image.open(io.BytesIO(annotated_bytes)).convert("RGB"))
 
-    total_ms   = (time.perf_counter() - t_start) * 1000
-    dt_end     = datetime.now()
+    total_s  = time.perf_counter() - t_start
+    dt_end   = datetime.now(_SL_TZ)
 
     log.info(f"  OUTPUT  top concern = {concerns[0].name} ({concerns[0].score}/95)")
-    log.info(f"  OUTPUT  skin type   = {vlm_result['skin_type']}")
+    log.info(f"  OUTPUT  skin type   = {skin_type}")
     log.info(f"  ┌─ TIMING BREAKDOWN ───────────────────────────────────")
-    log.info(f"  │  Skin Crop          : {skin_time*1000:>7.1f} ms")
-    log.info(f"  │  Parallel Threads   : {parallel_time*1000:>7.1f} ms  (wall time, 4 threads)")
-    log.info(f"  │    └─ Qwen3-VL only : {vlm_result['vlm_inference_ms']:>7.1f} ms")
-    log.info(f"  │  Scoring            : {score_time*1000:>7.1f} ms")
-    log.info(f"  │  TOTAL              : {total_ms:>7.1f} ms")
+    log.info(f"  │  Skin Crop        : {skin_s:.3f}s")
+    log.info(f"  │  Parallel Threads : {parallel_s:.3f}s  (wall time, 3 threads)")
+    log.info(f"  │  Scoring          : {scoring_s:.3f}s")
+    log.info(f"  │  TOTAL            : {total_s:.3f}s")
     log.info(f"  └──────────────────────────────────────────────────────")
-    log.info(f"  END     {dt_end.strftime('%Y-%m-%d %H:%M:%S.%f')[:-3]}")
+    log.info(f"  END     {dt_end.strftime('%Y-%m-%d %H:%M:%S')} (Sri Lanka Time)")
     log.info("═" * 65)
 
     return AnalysisResponse(
@@ -169,20 +163,11 @@ async def analyze(
         skin_crop_image=_encode(skin_crop),
         annotated_image=_encode(annotated_array),
         models_used=models_used,
-        skin_type=vlm_result["skin_type"],
-        vlm_concerns=[
-            VLMConcernResult(
-                name=c["name"],
-                score=c["score"],
-                severity=c["severity"],
-            )
-            for c in vlm_result["vlm_concerns"]
-        ],
+        skin_type=skin_type,
         timing=PipelineTiming(
-            skin_crop_ms=round(skin_time * 1000, 1),
-            parallel_pipeline_ms=round(parallel_time * 1000, 1),
-            vlm_inference_ms=round(vlm_result["vlm_inference_ms"], 1),
-            scoring_ms=round(score_time * 1000, 1),
-            total_ms=round(total_ms, 1),
+            skin_crop_s=round(skin_s, 3),
+            parallel_pipeline_s=round(parallel_s, 3),
+            scoring_s=round(scoring_s, 3),
+            total_s=round(total_s, 3),
         ),
     )

app/schemas.py

@@ -1,5 +1,5 @@
 from pydantic import BaseModel
-from typing import List, Optional
+from typing import List
 
 
 # ---------------------------------------------------------------------------
@@ -30,18 +30,11 @@ class ConcernResult(BaseModel):
     description: str
 
 
-class VLMConcernResult(BaseModel):
-    name: str
-    score: float                  # 10–95
-    severity: str                 # Low | Moderate | High
-
-
 class PipelineTiming(BaseModel):
-    skin_crop_ms: float
-    parallel_pipeline_ms: float   # OpenCV + ML + face detection threads
-    vlm_inference_ms: float       # Qwen3-VL thread
-    scoring_ms: float
-    total_ms: float
+    skin_crop_s: float
+    parallel_pipeline_s: float
+    scoring_s: float
+    total_s: float
 
 
 class OpenCVFeatures(BaseModel):
@@ -64,7 +57,5 @@ class AnalysisResponse(BaseModel):
     skin_crop_image: str          # base64-encoded PNG of masked skin region
     annotated_image: str          # base64-encoded PNG with face box
     models_used: List[str]        # which ML models contributed
-    # VLM additions
-    skin_type: str                # normal | oily | dry | combination | sensitive | unknown
-    vlm_concerns: List[VLMConcernResult]   # same 10 concerns scored by Qwen3-VL
+    skin_type: str                # normal | oily | dry | combination | sensitive
     timing: PipelineTiming

app/services/model_inference.py

@@ -1,23 +1,18 @@
 """
-ML model inference — EfficientNet-B0 (texture) + skintelligent-acne ViT (acne)
-                   + Qwen3-VL-2B-Instruct (skin type + concern scoring).
+ML model inference — EfficientNet-B0 (texture) + skintelligent-acne ViT (acne).
 
 Models are loaded once at startup as module-level singletons.
-run_parallel_inference() runs all models concurrently via ThreadPoolExecutor.
+run_parallel_inference() runs both models concurrently via ThreadPoolExecutor.
 """
 
-import json
 import os
-import re
 import threading
-import time
 from concurrent.futures import ThreadPoolExecutor
 from pathlib import Path
 from typing import Any
 
 os.environ.setdefault("HF_HUB_DISABLE_IMPLICIT_TOKEN", "1")
 
-import cv2
 import numpy as np
 
 # ---------------------------------------------------------------------------
@@ -28,9 +23,7 @@ _effnet: Any = None
 _effnet_transforms: Any = None
 _skintel: Any = None
 _skintel_processor: Any = None
-_qwen: Any = None
-_qwen_processor: Any = None
-_models_available = {"effnet": False, "skintel": False, "qwen_vlm": False}
+_models_available = {"effnet": False, "skintel": False}
 
 MODELS_DIR = Path(__file__).parent.parent.parent / "models"
 
@@ -79,41 +72,13 @@ def _load_skintelligent() -> None:
         print(f"[WARN] skintelligent-acne unavailable: {e}.")
 
 
-def _load_qwen_vlm() -> None:
-    global _qwen, _qwen_processor
-    try:
-        print("Loading Qwen3-VL-2B-Instruct VLM …")
-        # Try Qwen2.5-VL class first (used by Qwen3-VL), fall back to Qwen2-VL
-        try:
-            from transformers import Qwen2_5_VLForConditionalGeneration, AutoProcessor
-            _qwen = Qwen2_5_VLForConditionalGeneration.from_pretrained(
-                "Qwen/Qwen3-VL-2B-Instruct",
-                torch_dtype="auto",
-                device_map="auto",
-            )
-        except (ImportError, AttributeError):
-            from transformers import Qwen2VLForConditionalGeneration, AutoProcessor
-            _qwen = Qwen2VLForConditionalGeneration.from_pretrained(
-                "Qwen/Qwen3-VL-2B-Instruct",
-                torch_dtype="auto",
-                device_map="auto",
-            )
-        _qwen_processor = AutoProcessor.from_pretrained("Qwen/Qwen3-VL-2B-Instruct")
-        _qwen.eval()
-        _models_available["qwen_vlm"] = True
-        print("Qwen3-VL-2B-Instruct ready.")
-    except Exception as e:
-        print(f"[WARN] Qwen3-VL unavailable: {e}. VLM skin type/concerns will be skipped.")
-
-
 def load_all_models() -> None:
     """Call once at application startup to pre-warm all models."""
     with _lock:
         t1 = threading.Thread(target=_load_efficientnet,  daemon=True)
         t2 = threading.Thread(target=_load_skintelligent, daemon=True)
-        t3 = threading.Thread(target=_load_qwen_vlm,      daemon=True)
-        t1.start(); t2.start(); t3.start()
-        t1.join();  t2.join();  t3.join()
+        t1.start(); t2.start()
+        t1.join();  t2.join()
 
 
 # ---------------------------------------------------------------------------
@@ -185,181 +150,6 @@ def _run_efficientnet(skin_crop_rgb: np.ndarray) -> dict[str, float]:
     }
 
 
-# ---------------------------------------------------------------------------
-# VLM — Qwen3-VL-2B-Instruct
-# ---------------------------------------------------------------------------
-
-_VLM_CONCERN_NAMES = [
-    "Acne / Breakouts",
-    "Redness / Inflammation",
-    "Dark Spots / Hyperpigmentation",
-    "Enlarged Pores",
-    "Wrinkles / Fine Lines",
-    "Excess Oiliness",
-    "Dryness / Dehydration",
-    "Uneven Skin Tone",
-    "Dullness",
-    "Rough Texture",
-]
-
-_VLM_PROMPT = """You are a professional dermatologist analyzing a facial skin image.
-
-Task 1 — Skin Type: Classify the skin type as EXACTLY one of:
-  normal, oily, dry, combination, sensitive
-
-Task 2 — Skin Concerns: Score each concern on a scale of 10 to 95
-  (10 = completely clear, 95 = very severe).
-
-Respond with ONLY a valid JSON object. No explanation, no markdown, no extra text.
-Format:
-{
-  "skin_type": "<one of: normal | oily | dry | combination | sensitive>",
-  "concerns": {
-    "Acne / Breakouts": <int 10-95>,
-    "Redness / Inflammation": <int 10-95>,
-    "Dark Spots / Hyperpigmentation": <int 10-95>,
-    "Enlarged Pores": <int 10-95>,
-    "Wrinkles / Fine Lines": <int 10-95>,
-    "Excess Oiliness": <int 10-95>,
-    "Dryness / Dehydration": <int 10-95>,
-    "Uneven Skin Tone": <int 10-95>,
-    "Dullness": <int 10-95>,
-    "Rough Texture": <int 10-95>
-  }
-}"""
-
-
-def _parse_vlm_output(text: str) -> dict:
-    """Extract JSON from VLM output robustly."""
-    # Strip markdown code fences if present
-    text = re.sub(r"```(?:json)?", "", text).strip()
-    # Find first { ... } block
-    match = re.search(r"\{.*\}", text, re.DOTALL)
-    if match:
-        try:
-            return json.loads(match.group())
-        except json.JSONDecodeError:
-            pass
-    return {}
-
-
-def _vlm_severity(score: float) -> str:
-    if score < 35:
-        return "Low"
-    if score < 65:
-        return "Moderate"
-    return "High"
-
-
-def run_vlm_analysis(skin_crop_rgb: np.ndarray) -> dict:
-    """
-    Run Qwen3-VL-2B-Instruct on the skin crop.
-    Returns:
-        skin_type: str
-        vlm_concerns: list of dicts {name, score, severity}
-        vlm_inference_ms: float
-    """
-    default = {
-        "skin_type": "unknown",
-        "vlm_concerns": [],
-        "vlm_inference_ms": 0.0,
-    }
-
-    if not _models_available["qwen_vlm"]:
-        return default
-
-    try:
-        import torch
-        from PIL import Image as PILImage
-
-        t0 = time.perf_counter()
-
-        pil_img = PILImage.fromarray(skin_crop_rgb)
-
-        messages = [
-            {
-                "role": "user",
-                "content": [
-                    {"type": "image", "image": pil_img},
-                    {"type": "text",  "text": _VLM_PROMPT},
-                ],
-            }
-        ]
-
-        # Build inputs using the processor's chat template
-        text_input = _qwen_processor.apply_chat_template(
-            messages, tokenize=False, add_generation_prompt=True
-        )
-
-        # process_vision_info is part of qwen_vl_utils; fall back to manual if missing
-        try:
-            from qwen_vl_utils import process_vision_info
-            image_inputs, video_inputs = process_vision_info(messages)
-            inputs = _qwen_processor(
-                text=[text_input],
-                images=image_inputs,
-                videos=video_inputs,
-                padding=True,
-                return_tensors="pt",
-            )
-        except ImportError:
-            inputs = _qwen_processor(
-                text=[text_input],
-                images=[pil_img],
-                padding=True,
-                return_tensors="pt",
-            )
-
-        inputs = inputs.to(_qwen.device)
-
-        with torch.no_grad():
-            output_ids = _qwen.generate(
-                **inputs,
-                max_new_tokens=300,
-                do_sample=False,
-            )
-
-        # Decode only the newly generated tokens
-        generated = output_ids[:, inputs["input_ids"].shape[1]:]
-        raw_text = _qwen_processor.batch_decode(
-            generated, skip_special_tokens=True, clean_up_tokenization_spaces=False
-        )[0]
-
-        vlm_inference_ms = (time.perf_counter() - t0) * 1000
-
-        import logging
-        logging.getLogger("skinscope.vlm").info(
-            f"  Qwen3-VL raw output: {raw_text[:200]}"
-        )
-
-        parsed = _parse_vlm_output(raw_text)
-        skin_type = parsed.get("skin_type", "unknown").strip().lower()
-        if skin_type not in {"normal", "oily", "dry", "combination", "sensitive"}:
-            skin_type = "unknown"
-
-        raw_concerns = parsed.get("concerns", {})
-        vlm_concerns = []
-        for name in _VLM_CONCERN_NAMES:
-            score = float(raw_concerns.get(name, 10))
-            score = max(10.0, min(95.0, score))
-            vlm_concerns.append({
-                "name": name,
-                "score": score,
-                "severity": _vlm_severity(score),
-            })
-
-        return {
-            "skin_type": skin_type,
-            "vlm_concerns": vlm_concerns,
-            "vlm_inference_ms": vlm_inference_ms,
-        }
-
-    except Exception as e:
-        import logging
-        logging.getLogger("skinscope.vlm").warning(f"  Qwen3-VL inference failed: {e}")
-        return default
-
-
 # ---------------------------------------------------------------------------
 # Public API — parallel execution
 # ---------------------------------------------------------------------------

app/services/skin_type.py

@@ -0,0 +1,72 @@
+"""
+Rule-based skin type classifier.
+
+Derives skin type from OpenCV features already extracted by the pipeline.
+No extra model or inference time required.
+
+Rules (thresholds tuned to normalised 0–1 feature range):
+  oily        : oiliness high, redness low
+  dry         : flakiness high, oiliness low
+  sensitive   : redness high (inflammation markers)
+  combination : moderate oiliness with uneven texture/color variance
+  normal      : all features in balanced range
+"""
+
+import logging
+
+log = logging.getLogger("skinscope.skintype")
+
+# Thresholds
+_OILY_THRESH       = 0.30   # oiliness >= this → leaning oily
+_DRY_OILY_MAX      = 0.15   # oiliness <= this for dry classification
+_FLAKY_THRESH      = 0.40   # flakiness >= this → dry indicator
+_REDNESS_SENSITIVE = 0.45   # redness >= this → sensitive
+_COMBO_OILY        = 0.20   # moderate oiliness for combination
+_COLOR_VAR_COMBO   = 0.45   # color variance for combination (uneven zones)
+
+
+def classify_skin_type(features: dict[str, float]) -> str:
+    """
+    Classify skin type from extracted OpenCV features.
+
+    Args:
+        features: dict containing at minimum:
+            oiliness, redness, flakiness, brightness,
+            texture_variance, color_variance, saturation_inv
+
+    Returns:
+        One of: "oily" | "dry" | "sensitive" | "combination" | "normal"
+    """
+    oiliness      = features.get("oiliness",        0.0)
+    redness       = features.get("redness",          0.0)
+    flakiness     = features.get("flakiness",        0.0)
+    color_var     = features.get("color_variance",   0.0)
+    saturation_inv = features.get("saturation_inv",  0.0)
+
+    # ── Sensitive: high redness is the dominant signal ────────────────────────
+    if redness >= _REDNESS_SENSITIVE:
+        skin_type = "sensitive"
+
+    # ── Oily: high oiliness, redness not dominant ────────────────────────────
+    elif oiliness >= _OILY_THRESH and redness < _REDNESS_SENSITIVE:
+        skin_type = "oily"
+
+    # ── Dry: low oiliness + high flakiness or high saturation drop ───────────
+    elif oiliness <= _DRY_OILY_MAX and (flakiness >= _FLAKY_THRESH or saturation_inv >= 0.35):
+        skin_type = "dry"
+
+    # ── Combination: moderate oiliness + uneven color zones ──────────────────
+    elif oiliness >= _COMBO_OILY and color_var >= _COLOR_VAR_COMBO:
+        skin_type = "combination"
+
+    # ── Normal: nothing stands out ────────────────────────────────────────────
+    else:
+        skin_type = "normal"
+
+    log.info(
+        f"  SKIN TYPE  {skin_type:<12}  "
+        f"oiliness={oiliness:.3f}  redness={redness:.3f}  "
+        f"flakiness={flakiness:.3f}  color_var={color_var:.3f}  "
+        f"saturation_inv={saturation_inv:.3f}"
+    )
+    return skin_type

requirements.txt

@@ -16,8 +16,6 @@ torch
 torchvision
 timm
 transformers
-accelerate
-qwen-vl-utils
 
 # HTTP client (frontend → backend)
 requests