edited docker and main.py

Dockerfile

@@ -4,45 +4,32 @@ FROM python:3.12-slim
 # 1. Create non‑root user
 RUN useradd --create-home --shell /bin/bash --uid 1000 appuser
 
-# 2. Environment variables
+# 2. Environment variables - set HF_HOME to match what's used in lifespan
 ENV PYTHONDONTWRITEBYTECODE=1 \
     PYTHONUNBUFFERED=1 \
-    HF_HOME=/tmp/huggingface \
-    TRANSFORMERS_CACHE=/tmp/huggingface/transformers \
-    HF_HUB_CACHE=/tmp/huggingface/hub \
+    HF_HOME=/home/appuser/huggingface \
     PORT=7860 \
     PATH=/home/appuser/.local/bin:$PATH
 
 # 3. Set working directory
 WORKDIR /home/appuser/app
 
-# 4. Install Python dependencies (as root)
+# 4. Install Python dependencies
 COPY requirements.txt .
 RUN pip install --upgrade pip \
- && pip install --no-cache-dir -i https://pypi.tuna.tsinghua.edu.cn/simple -r requirements.txt
+    && pip install --no-cache-dir -r requirements.txt
 
 # 5. Copy code and set permissions
 COPY --chown=appuser:appuser . .
-RUN chown -R appuser:appuser /home/appuser
 
-# 6. Switch to appuser BEFORE downloading the model
-USER appuser
-
-# 7. Download model (as appuser)
-RUN python - <<'PY'
-import os, pathlib
-from huggingface_hub import hf_hub_download
+# 6. Create huggingface directory with proper permissions
+RUN mkdir -p /home/appuser/huggingface && \
+    chown -R appuser:appuser /home/appuser
 
-hf_home = os.environ.get("HF_HOME", "/tmp/huggingface")
-pathlib.Path(hf_home).mkdir(parents=True, exist_ok=True)
+# 7. Switch to appuser
+USER appuser
 
-hf_hub_download(
-    repo_id="yasyn14/skin-analyzer",
-    filename="model-v1.keras",
-    cache_dir=hf_home
-)
-PY
 
-# 8. Expose port & run app
+# 9. Expose port & run app using uvicorn
 EXPOSE 7860
-CMD ["sh", "-c", "fastapi run main.py --host 0.0.0.0 --port 7860"]
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

main.py

@@ -11,34 +11,44 @@ from api.v1 import router as v1_router
 from models.model_loader import load_skin_condition_model
 from utils.predictor import predict_skin_condition
 
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+# Disable OneDNN optimizations if needed
 os.environ["TF_ENABLE_ONEDNN_OPTS"] = "0"
-logger = logging.getLogger("uvicorn.error")
 
 @asynccontextmanager
 async def lifespan(app: FastAPI):
     try:
-        logger.info("Downloading model from Hugging Face Hub…")
+        # Get cache directory from environment variable or use a default
+        cache_dir = os.environ.get("HF_HOME", "/tmp/huggingface")
+        
+        logger.info(f"Downloading model from Hugging Face Hub using cache_dir: {cache_dir}...")
         model_path = hf_hub_download(
             repo_id="yasyn14/skin-analyzer",
             filename="model-v1.keras",
-            cache_dir="/tmp/huggingface"
+            cache_dir=cache_dir
         )
-
-        logger.info("Loading model…")
+        
+        logger.info(f"Loading model from path: {model_path}")
         model = await asyncio.to_thread(load_skin_condition_model, model_path)
-
+        
         # warm‑up
         dummy = np.zeros((1, 224, 224, 3), dtype=np.uint8)
         await asyncio.to_thread(model.predict, dummy)
-
+        
         app.state.model = model
         logger.info("Model ready ✅")
         yield
-
+    
     except Exception as e:
         logger.exception("Failed during startup:")
         raise RuntimeError("Failed to load skin-condition model") from e
-
+    
     finally:
         logger.info("Shutting down: releasing resources")
         if hasattr(app.state, "model"):
@@ -60,7 +70,6 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-
 @app.get("/healthz", tags=["Health"])
 async def health_check():
     return {"status": "ok"}
@@ -68,33 +77,45 @@ async def health_check():
 # include your versioned REST API
 app.include_router(v1_router)
 
-
 # === Gradio UI Setup ===
 def predict_skin_condition_grad(image: Image.Image):
     if image is None:
         return "No image provided"
-
+    
+    if not hasattr(app.state, "model"):
+        return "Model is not loaded yet. Please try again in a moment."
+    
     model = app.state.model
-
+    
     # Preprocess image
     img = image.resize((224, 224)).convert("RGB")
     img_array = np.array(img)
-
+    
     # Predict
     prediction = predict_skin_condition(img_array, model)
-
     
     confidence = prediction.get("confidence")
     label = prediction.get("condition")
-
+    
     return f"{label} ({confidence:.2%} confidence)"
 
 gradio_interface = gr.Interface(
     fn=predict_skin_condition_grad,
-    inputs=gr.Image(type="pil", label="Upload a skin image"),
+    inputs=gr.Image(
+        type="pil", 
+        label="Upload or capture a skin image",
+        sources=["upload", "webcam"],  # Explicitly enable both upload and webcam
+        webcam_options={"facingMode": "environment"}  # Use back camera by default (better for skin photos)
+    ),
     outputs=gr.Text(label="Prediction"),
     title="Skin Analyzer",
-    description="Upload a photo of skin to detect conditions like acne, eczema, dryness, etc."
+    description="Upload a photo or use your camera to detect skin conditions like acne, eczema, dryness, etc.",
+    examples=[
+        # Optional: Add example images if you have them
+        # ["examples/acne.jpg"],
+        # ["examples/eczema.jpg"]
+    ],
+    allow_flagging="never"  # Disable flagging option
 )
 
 # Mount Gradio on root

routes/predict.py

@@ -1,5 +1,5 @@
 import io
-
+import asyncio
 from fastapi import APIRouter, Depends, Request, UploadFile, File, HTTPException
 from PIL import Image
 import numpy as np
@@ -10,6 +10,9 @@ from utils.recommend import get_recommended_products
 
 router = APIRouter()
 
+# Maximum file size (10MB)
+MAX_FILE_SIZE = 10 * 1024 * 1024
+
 def get_model(request: Request):
     """
     Dependency that retrieves the preloaded ML model from app state.
@@ -20,6 +23,12 @@ def get_model(request: Request):
         raise HTTPException(status_code=500, detail="Model not loaded")
     return model
 
+async def preprocess_image(image_data: bytes) -> np.ndarray:
+    """Preprocess raw image bytes into model-ready numpy array"""
+    return await asyncio.to_thread(
+        lambda: np.array(Image.open(io.BytesIO(image_data)).convert("RGB").resize((224, 224)))
+    )
+
 @router.post(
     "/predict/",
     response_model=PredictionResponse,
@@ -37,35 +46,41 @@ async def predict(
     # Validate content type
     if not file.content_type.startswith("image/"):
         raise HTTPException(status_code=415, detail="Unsupported file type. Please upload an image.")
-
+    
     try:
-        contents = await file.read()
+        # Check file size before reading
+        contents = await file.read(MAX_FILE_SIZE + 1)
+        if len(contents) > MAX_FILE_SIZE:
+            raise HTTPException(
+                status_code=413, 
+                detail=f"File too large. Maximum size is {MAX_FILE_SIZE/(1024*1024)}MB"
+            )
+        
+        # Process image
+        img_array = await preprocess_image(contents)
+        
+        # Release file resources
         await file.close()
-
-        # Load and preprocess image
-        img = Image.open(io.BytesIO(contents)).convert("RGB")
-        img = img.resize((224, 224))
-        img_array = np.array(img)
-
+        
         # Run prediction
         prediction = predict_skin_condition(img_array, model)
         predicted_condition = prediction.get("condition")
         confidence = prediction.get("confidence")
-
+        
         # Handle no-detection case
         if not predicted_condition:
             raise HTTPException(
                 status_code=422,
                 detail="Unable to detect a skin condition from the provided image."
             )
-
+        
         # Build response
         result = {
             "predicted_condition": predicted_condition,
             "confidence": confidence,
             "info": None,
         }
-
+        
         # Attach recommendations if available
         condition_data = get_recommended_products(predicted_condition)
         if not condition_data:
@@ -73,13 +88,16 @@ async def predict(
                 status_code=404,
                 detail=f"No recommendation data found for detected condition: {predicted_condition}"
             )
-
+        
         result["info"] = ConditionInfo(**condition_data)
         return result
-
+    
     except HTTPException:
         # Propagate HTTPExceptions
         raise
-    except Exception:
+    except Exception as e:
+        # Log the actual error in production systems
+        # logger.exception(f"Prediction error: {str(e)}")
+        
         # Hide technical details from client
-        raise HTTPException(status_code=500, detail="Internal server error")
+        raise HTTPException(status_code=500, detail="Internal server error")

utils/predictor.py

@@ -1,15 +1,50 @@
 import numpy as np
+from typing import Dict, Any, Union
+import tensorflow as tf
 import keras
 from config import CLASS_NAMES
 
-def predict_skin_condition(img_array, model):
-    img_array = np.expand_dims(img_array, axis=0)
-    img_array = keras.applications.efficientnet.preprocess_input(img_array)
-
-    pred_probs = model.predict(img_array)[0]
-    top_index = np.argmax(pred_probs)
-
-    return {
-        "condition": CLASS_NAMES[top_index],
-        "confidence": float(pred_probs[top_index])
-    }
+def predict_skin_condition(img_array: np.ndarray, model: tf.keras.Model) -> Dict[str, Union[str, float]]:
+    """
+    Predict skin condition from an input image using the provided model.
+    
+    Args:
+        img_array: Input image as numpy array (H, W, C) with RGB channels
+        model: Loaded Keras/TensorFlow model for prediction
+        
+    Returns:
+        Dictionary containing predicted condition name and confidence score
+    """
+    try:
+        # Add batch dimension if not present
+        if len(img_array.shape) == 3:
+            img_array = np.expand_dims(img_array, axis=0)
+        
+        # Apply EfficientNet preprocessing
+        preprocessed_img = keras.applications.efficientnet.preprocess_input(img_array)
+        
+        # Make prediction (with TF warning suppression)
+        with tf.device('/CPU:0'):  # Force CPU prediction for consistent behavior
+            pred_probs = model.predict(preprocessed_img, verbose=0)[0]
+        
+        # Get top prediction
+        top_index = np.argmax(pred_probs)
+        
+        # Ensure index is valid
+        if top_index >= len(CLASS_NAMES):
+            raise ValueError(f"Predicted index {top_index} exceeds available class names")
+        
+        return {
+            "condition": CLASS_NAMES[top_index],
+            "confidence": float(pred_probs[top_index])
+        }
+    
+    except Exception as e:
+        # Log error in production systems
+        # logger.error(f"Prediction error: {str(e)}")
+        
+        # Return empty result with error indication
+        return {
+            "condition": "error",
+            "confidence": 0.0
+        }

utils/recommend.py

@@ -1,18 +1,87 @@
 import json
+import os
+from typing import Dict, Any, Optional
+import logging
 
-try:
-    with open('data/skin_conditions.json', encoding='utf-8') as f:
-        json_data = json.load(f)
-except (FileNotFoundError, json.JSONDecodeError) as e:
-    print(f"Error loading JSON: {e}")
-    json_data = []
+# Setup logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
+# Global variables
+_condition_data = {}
+_last_load_time = 0
+
+def _load_condition_data() -> Dict[str, Any]:
+    """Load skin condition data from JSON file with proper error handling"""
+    json_path = 'data/skin_conditions.json'
+    
+    try:
+        # Get file modification time to check for changes
+        mtime = os.path.getmtime(json_path)
+        
+        # If we've already loaded and file hasn't changed, return cached data
+        global _condition_data, _last_load_time
+        if _condition_data and mtime <= _last_load_time:
+            return _condition_data
+        
+        # Load and parse JSON file
+        with open(json_path, encoding='utf-8') as f:
+            data = json.load(f)
+        
+        # Index data by lowercase condition name for faster lookups
+        condition_map = {}
+        for entry in data:
+            condition = entry.get("condition", "").strip().lower()
+            if condition:  # Only add entries with a valid condition name
+                condition_map[condition] = entry
+        
+        # Update cache
+        _condition_data = condition_map
+        _last_load_time = mtime
+        logger.info(f"Loaded {len(condition_map)} skin conditions from {json_path}")
+        return condition_map
+        
+    except FileNotFoundError:
+        logger.error(f"Skin conditions file not found: {json_path}")
+        return {}
+    except json.JSONDecodeError as e:
+        logger.error(f"Invalid JSON in skin conditions file: {e}")
+        return {}
+    except Exception as e:
+        logger.error(f"Error loading skin conditions: {e}")
+        return {}
+
+def get_recommended_products(condition_query: str) -> Dict[str, Any]:
+    """
+    Get recommended products for a given skin condition.
     
+    Args:
+        condition_query: The skin condition to look up
+        
+    Returns:
+        Dictionary containing condition info and product recommendations,
+        or empty dict if no match found
+    """
+    if not condition_query:
+        return {}
     
-def get_recommended_products(condition_query):
+    # Standardize the query
     condition_query = condition_query.strip().lower()
-    for entry in json_data:
-        condition = entry.get("condition", "").strip().lower()
-        if condition_query in condition:
+    
+    # Load or refresh condition data
+    condition_data = _load_condition_data()
+    
+    # Try exact match first (most reliable)
+    if condition_query in condition_data:
+        return condition_data[condition_query]
+    
+    # If exact match fails, try to find the closest match
+    # This is a fallback for when condition names might have slight variations
+    for cond_name, entry in condition_data.items():
+        # Check if query is a substring of a condition or vice versa
+        if condition_query in cond_name or cond_name in condition_query:
             return entry
-    return {}
+    
+    # No match found
+    logger.warning(f"No recommendations found for condition: {condition_query}")
+    return {}