Upload 15 files

.env

@@ -0,0 +1,27 @@
+# =========================
+# API Configuration
+# =========================
+API_HOST=0.0.0.0
+API_PORT=8000
+DEBUG=True
+
+# =========================
+# Model Paths and Google Drive Integration
+# =========================
+# Local model directories (these will be auto-created/downloaded if missing)
+DERM_MODEL_PATH=./derm_foundation
+EASI_MODEL_PATH=./trained_model/easi_severity_model_derm_foundation_individual.pkl
+
+# =========================
+# Image Processing Settings
+# =========================
+MAX_IMAGE_SIZE_MB=10
+PROCESSED_IMAGE_SIZE=448
+
+# =========================
+# API Security (optional for production)
+# =========================
+# API_KEY=your-secret-key-here
+
+
+

.gitattributes

@@ -1,35 +1,2 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+# Auto detect text files and perform LF normalization
+* text=auto

.gitignore

@@ -0,0 +1,181 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Cursor  
+#  Cursor is an AI-powered code editor.`.cursorignore` specifies files/directories to 
+#  exclude from AI features like autocomplete and code analysis. Recommended for sensitive data
+#  refer to https://docs.cursor.com/context/ignore-files
+.cursorignore
+.cursorindexingignore

2.0

@@ -0,0 +1 @@
+Requirement already satisfied: numpy in c:\users\ralph\downloads\eczemanage_api\venv\lib\site-packages (2.2.6)

3.0.0

@@ -0,0 +1 @@
+Requirement already satisfied: keras in c:\users\ralph\downloads\eczemanage_api\venv\lib\site-packages (2.15.0)

Dockerfile

@@ -0,0 +1,31 @@
+**`Dockerfile`** (same as before but optimized for HF):
+```dockerfile
+FROM python:3.9-slim
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    gcc \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements and install
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application files
+COPY . .
+
+# Download model during build (HF has plenty of RAM for this)
+RUN python download_model.py
+
+# Expose port (HF Spaces uses 8000 by default)
+EXPOSE 8000
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
+  CMD curl -f http://localhost:8000/health || exit 1
+
+# Start server
+CMD ["uvicorn", "api:app", "--host", "0.0.0.0", "--port", "8000"]

README.md

@@ -1,12 +1,23 @@
 ---
-title: Eczemanage
-emoji: 🐢
-colorFrom: green
-colorTo: gray
+title: EASI Severity Prediction API
+emoji: 🔬
+colorFrom: blue
+colorTo: green
 sdk: docker
 pinned: false
-license: mit
-short_description: Hosting for Eczemanage App
+app_port: 8000
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# EASI Severity Prediction API
+
+FastAPI-based REST API for predicting EASI scores from dermatological images.
+
+## Endpoints
+- `POST /predict` - Upload image and get EASI predictions
+- `GET /health` - Health check
+- `GET /conditions` - List available conditions
+
+## Usage
+```bash
+curl -X POST "https://YOUR-USERNAME-easi-api.hf.space/predict" \
+  -F "[email protected]"

api.py

@@ -0,0 +1,744 @@
+"""
+EASI Severity Prediction REST API
+==================================
+
+FastAPI-based REST API for predicting EASI scores from dermatological images.
+Designed for integration with Flutter mobile applications.
+
+Endpoints:
+- POST /predict - Upload image and get EASI predictions
+- GET /health - Health check endpoint
+- GET /conditions - Get list of available conditions
+
+Installation:
+pip install fastapi uvicorn python-multipart pillow tensorflow numpy pandas huggingface-hub requests
+
+Run:
+uvicorn api:app --host 0.0.0.0 --port 8000 --reload
+"""
+
+import os
+import warnings
+import logging
+from typing import List, Dict, Any, Optional
+from io import BytesIO
+from pathlib import Path
+
+# Suppress warnings
+os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
+os.environ['TF_ENABLE_ONEDNN_OPTS'] = '0'
+os.environ['MLIR_CRASH_REPRODUCER_DIRECTORY'] = ''
+warnings.filterwarnings('ignore')
+logging.getLogger('absl').setLevel(logging.ERROR)
+
+import tensorflow as tf
+tf.get_logger().setLevel('ERROR')
+tf.compat.v1.logging.set_verbosity(tf.compat.v1.logging.ERROR)
+
+from fastapi import FastAPI, File, UploadFile, HTTPException, status
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+from pydantic import BaseModel, Field
+import numpy as np
+from PIL import Image
+import pickle
+import pandas as pd
+import requests
+from huggingface_hub import hf_hub_download, login
+
+# Initialize FastAPI app
+app = FastAPI(
+    title="EASI Severity Prediction API",
+    description="REST API for predicting EASI scores from skin images",
+    version="1.0.0"
+)
+
+# CORS middleware for Flutter web/mobile
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # In production, specify your Flutter app domain
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Configuration
+HF_REPO_ID = "google/derm-foundation"
+DERM_FOUNDATION_PATH = "./derm_foundation/"
+R2_BASE_URL = os.environ.get("R2_BASE_URL", "https://r2-worker.eczemanage.workers.dev")
+
+# Get Hugging Face token from environment variable
+HF_TOKEN = os.environ.get("HUGGINGFACE_TOKEN")
+
+# Response Models
+class ConditionPrediction(BaseModel):
+    condition: str
+    probability: float = Field(..., ge=0, le=1)
+    confidence: float = Field(..., ge=0)
+    weight: float = Field(..., ge=0)
+    easi_category: Optional[str] = None
+    easi_contribution: int = Field(..., ge=0, le=3)
+
+class EASIComponent(BaseModel):
+    name: str
+    score: int = Field(..., ge=0, le=3)
+    contributing_conditions: List[Dict[str, Any]]
+
+class PredictionResponse(BaseModel):
+    success: bool
+    total_easi_score: int = Field(..., ge=0, le=12)
+    severity_interpretation: str
+    easi_components: Dict[str, EASIComponent]
+    predicted_conditions: List[ConditionPrediction]
+    summary_statistics: Dict[str, float]
+    image_info: Dict[str, Any]
+
+class HealthResponse(BaseModel):
+    status: str
+    models_loaded: Dict[str, bool]
+    available_conditions: int
+    hf_token_configured: bool
+    model_source: str
+
+class ErrorResponse(BaseModel):
+    success: bool = False
+    error: str
+    detail: Optional[str] = None
+
+
+# Model wrapper class
+class DermFoundationNeuralNetwork:
+    def __init__(self):
+        self.model = None
+        self.mlb = None
+        self.embedding_scaler = None
+        self.confidence_scaler = None
+        self.weighted_scaler = None
+    
+    def load_model(self, filepath):
+        try:
+            with open(filepath, 'rb') as f:
+                model_data = pickle.load(f)
+            
+            self.mlb = model_data['mlb']
+            self.embedding_scaler = model_data['embedding_scaler']
+            self.confidence_scaler = model_data['confidence_scaler']
+            self.weighted_scaler = model_data['weighted_scaler']
+            
+            keras_model_path = model_data['keras_model_path']
+            if os.path.exists(keras_model_path):
+                self.model = tf.keras.models.load_model(keras_model_path)
+                return True
+            else:
+                return False
+        except Exception as e:
+            print(f"Error loading model: {e}")
+            return False
+    
+    def predict(self, embedding):
+        if self.model is None:
+            return None
+        
+        if len(embedding.shape) == 1:
+            embedding = embedding.reshape(1, -1)
+        
+        embedding_scaled = self.embedding_scaler.transform(embedding)
+        predictions = self.model.predict(embedding_scaled, verbose=0)
+        
+        condition_probs = predictions['conditions'][0]
+        individual_confidences = predictions['individual_confidences'][0]
+        individual_weights = predictions['individual_weights'][0]
+        
+        condition_threshold = 0.3
+        predicted_condition_indices = np.where(condition_probs > condition_threshold)[0]
+        
+        predicted_conditions = []
+        predicted_confidences = []
+        predicted_weights_dict = {}
+        
+        for idx in predicted_condition_indices:
+            condition_name = self.mlb.classes_[idx]
+            condition_prob = float(condition_probs[idx])
+            
+            if individual_confidences[idx] > 0:
+                confidence_orig = self.confidence_scaler.inverse_transform([[individual_confidences[idx]]])[0, 0]
+            else:
+                confidence_orig = 0.0
+                
+            if individual_weights[idx] > 0:
+                weight_orig = self.weighted_scaler.inverse_transform([[individual_weights[idx]]])[0, 0]
+            else:
+                weight_orig = 0.0
+            
+            predicted_conditions.append(condition_name)
+            predicted_confidences.append(max(0, confidence_orig))
+            predicted_weights_dict[condition_name] = max(0, weight_orig)
+        
+        all_condition_probs = {}
+        all_confidences = {}
+        all_weights = {}
+        
+        for i, class_name in enumerate(self.mlb.classes_):
+            all_condition_probs[class_name] = float(condition_probs[i])
+            
+            if individual_confidences[i] > 0:
+                conf_orig = self.confidence_scaler.inverse_transform([[individual_confidences[i]]])[0, 0]
+                all_confidences[class_name] = max(0, conf_orig)
+            else:
+                all_confidences[class_name] = 0.0
+                
+            if individual_weights[i] > 0:
+                weight_orig = self.weighted_scaler.inverse_transform([[individual_weights[i]]])[0, 0]
+                all_weights[class_name] = max(0, weight_orig)
+            else:
+                all_weights[class_name] = 0.0
+        
+        return {
+            'dermatologist_skin_condition_on_label_name': predicted_conditions,
+            'dermatologist_skin_condition_confidence': predicted_confidences,
+            'weighted_skin_condition_label': predicted_weights_dict,
+            'all_condition_probabilities': all_condition_probs,
+            'all_individual_confidences': all_confidences,
+            'all_individual_weights': all_weights,
+            'condition_threshold': condition_threshold
+        }
+
+
+# Helper function to download from Cloudflare R2 with chunked streaming
+def download_derm_foundation_from_r2(output_dir):
+    """Download Derm Foundation model from Cloudflare R2 using memory-efficient streaming"""
+    try:
+        print(f"Downloading Derm Foundation model from R2 ({R2_BASE_URL})...")
+        os.makedirs(output_dir, exist_ok=True)
+        
+        # Files to download
+        files_to_download = [
+            "saved_model.pb",
+            "variables/variables.index",
+            "variables/variables.data-00000-of-00001"
+        ]
+        
+        for file_path in files_to_download:
+            print(f"Downloading {file_path}...")
+            url = f"{R2_BASE_URL}/{file_path}"
+            local_path = os.path.join(output_dir, file_path)
+            
+            # Create subdirectories if needed
+            os.makedirs(os.path.dirname(local_path), exist_ok=True)
+            
+            # Download file with streaming (ULTRA MEMORY EFFICIENT)
+            # Use tiny chunk size and aggressive garbage collection
+            import gc
+            
+            with requests.get(url, stream=True, timeout=900) as response:
+                response.raise_for_status()
+                
+                total_size = int(response.headers.get('content-length', 0))
+                downloaded = 0
+                chunk_count = 0
+                
+                # Write directly to disk in tiny chunks (256KB to minimize memory)
+                with open(local_path, 'wb') as f:
+                    for chunk in response.iter_content(chunk_size=256*1024):  # 256KB chunks
+                        if chunk:
+                            f.write(chunk)
+                            f.flush()  # Force write to disk
+                            downloaded += len(chunk)
+                            chunk_count += 1
+                            
+                            # Aggressive garbage collection every 10 chunks (~2.5MB)
+                            if chunk_count % 10 == 0:
+                                gc.collect()
+                            
+                            # Less frequent progress updates to reduce print overhead
+                            if total_size > 0 and chunk_count % 20 == 0:
+                                progress = (downloaded / total_size) * 100
+                                mb_downloaded = downloaded / (1024*1024)
+                                mb_total = total_size / (1024*1024)
+                                print(f"  Progress: {progress:.1f}% ({mb_downloaded:.1f}/{mb_total:.1f} MB)")
+                
+                print()  # New line after progress
+                gc.collect()  # Final cleanup
+            
+            print(f"✓ Downloaded: {file_path}")
+        
+        print(f"✓ Derm Foundation model downloaded successfully from R2")
+        return True
+    except Exception as e:
+        print(f"✗ Error downloading from R2: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+
+# Helper function to download from Hugging Face (Fallback) with memory-efficient streaming
+def download_derm_foundation_from_hf(output_dir):
+    """Download Derm Foundation model from Hugging Face using memory-efficient streaming"""
+    try:
+        # Login to Hugging Face if token is available
+        if HF_TOKEN:
+            print("Authenticating with Hugging Face...")
+            login(token=HF_TOKEN)
+        else:
+            print("WARNING: No HF token found. Attempting download without authentication...")
+        
+        print(f"Downloading Derm Foundation model from Hugging Face...")
+        os.makedirs(output_dir, exist_ok=True)
+        
+        # Files to download
+        files_to_download = [
+            "saved_model.pb",
+            "variables/variables.data-00000-of-00001",
+            "variables/variables.index"
+        ]
+        
+        for file_path in files_to_download:
+            print(f"Downloading {file_path}...")
+            local_path = os.path.join(output_dir, file_path)
+            
+            # Create subdirectories if needed
+            os.makedirs(os.path.dirname(local_path), exist_ok=True)
+            
+            # Download file with token if available
+            # hf_hub_download handles streaming internally
+            downloaded_path = hf_hub_download(
+                repo_id=HF_REPO_ID,
+                filename=file_path,
+                token=HF_TOKEN,
+                cache_dir=None,
+                local_dir=output_dir,
+                local_dir_use_symlinks=False,
+                resume_download=True  # Resume if interrupted
+            )
+            print(f"✓ Downloaded: {file_path}")
+        
+        print(f"✓ Derm Foundation model downloaded successfully from HuggingFace")
+        return True
+    except Exception as e:
+        print(f"✗ Error downloading from Hugging Face: {e}")
+        print(f"Make sure HUGGINGFACE_TOKEN is set in Render environment variables")
+        import traceback
+        traceback.print_exc()
+        return False
+
+
+# EASI calculation functions
+def calculate_easi_scores(predictions):
+    easi_categories = {
+        'erythema': {
+            'name': 'Erythema (Redness)',
+            'conditions': [
+                'Post-Inflammatory hyperpigmentation', 'Erythema ab igne', 'Erythema annulare centrifugum',
+                'Erythema elevatum diutinum', 'Erythema gyratum repens', 'Erythema multiforme',
+                'Erythema nodosum', 'Flagellate erythema', 'Annular erythema', 'Drug Rash',
+                'Allergic Contact Dermatitis', 'Irritant Contact Dermatitis', 'Contact dermatitis',
+                'Acute dermatitis', 'Chronic dermatitis', 'Acute and chronic dermatitis',
+                'Sunburn', 'Photodermatitis', 'Phytophotodermatitis', 'Rosacea',
+                'Seborrheic Dermatitis', 'Stasis Dermatitis', 'Perioral Dermatitis',
+                'Burn erythema of abdominal wall', 'Burn erythema of back of hand',
+                'Burn erythema of lower leg', 'Cellulitis', 'Infection of skin',
+                'Viral Exanthem', 'Infected eczema', 'Crusted eczematous dermatitis',
+                'Inflammatory dermatosis', 'Vasculitis of the skin', 'Leukocytoclastic Vasculitis',
+                'Cutaneous lupus', 'CD - Contact dermatitis', 'Acute dermatitis, NOS',
+                'Herpes Simplex', 'Hypersensitivity', 'Impetigo', 'Pigmented purpuric eruption',
+                'Pityriasis rosea', 'Tinea', 'Tinea Versicolor'
+            ]
+        },
+        'induration': {
+            'name': 'Induration/Papulation (Swelling/Bumps)',
+            'conditions': [
+                'Prurigo nodularis', 'Urticaria', 'Granuloma annulare', 'Morphea',
+                'Scleroderma', 'Lichen Simplex Chronicus', 'Lichen planus', 'lichenoid eruption',
+                'Lichen nitidus', 'Lichen spinulosus', 'Lichen striatus', 'Keratosis pilaris',
+                'Molluscum Contagiosum', 'Verruca vulgaris', 'Folliculitis', 'Acne',
+                'Hidradenitis', 'Nodular vasculitis', 'Sweet syndrome', 'Necrobiosis lipoidica',
+                'Basal Cell Carcinoma', 'SCC', 'SCCIS', 'SK', 'ISK',
+                'Cutaneous T Cell Lymphoma', 'Skin cancer', 'Adnexal neoplasm',
+                'Insect Bite', 'Milia', 'Miliaria', 'Xanthoma', 'Psoriasis',
+                'Lichen planus/lichenoid eruption'
+            ]
+        },
+        'excoriation': {
+            'name': 'Excoriation (Scratching Damage)',
+            'conditions': [
+                'Inflicted skin lesions', 'Scabies', 'Abrasion', 'Abrasion of wrist',
+                'Superficial wound of body region', 'Scrape', 'Animal bite - wound',
+                'Pruritic dermatitis', 'Prurigo', 'Atopic dermatitis', 'Scab'
+            ]
+        },
+        'lichenification': {
+            'name': 'Lichenification (Skin Thickening)',
+            'conditions': [
+                'Lichenified eczematous dermatitis', 'Acanthosis nigricans',
+                'Hyperkeratosis of skin', 'HK - Hyperkeratosis', 'Keratoderma',
+                'Ichthyosis', 'Ichthyosiform dermatosis', 'Chronic eczema',
+                'Psoriasis', 'Xerosis'
+            ]
+        }
+    }
+    
+    def probability_to_score(prob):
+        if prob < 0.171:
+            return 0
+        elif prob < 0.238:
+            return 1
+        elif prob < 0.421:
+            return 2
+        elif prob < 0.614:
+            return 3
+        else:
+            return 3
+    
+    easi_results = {}
+    all_condition_probs = predictions['all_condition_probabilities']
+    
+    for component, category_info in easi_categories.items():
+        category_conditions = []
+        
+        for condition_name, probability in all_condition_probs.items():
+            if condition_name.lower() == 'eczema':
+                continue
+                
+            if condition_name in category_info['conditions']:
+                category_conditions.append({
+                    'condition': condition_name,
+                    'probability': probability,
+                    'individual_score': probability_to_score(probability)
+                })
+        
+        category_conditions = [c for c in category_conditions if c['individual_score'] > 0]
+        category_conditions.sort(key=lambda x: x['probability'], reverse=True)
+        
+        component_score = sum(c['individual_score'] for c in category_conditions)
+        component_score = min(component_score, 3)
+        
+        easi_results[component] = {
+            'name': category_info['name'],
+            'score': component_score,
+            'contributing_conditions': category_conditions
+        }
+    
+    total_easi = sum(result['score'] for result in easi_results.values())
+    
+    return easi_results, total_easi
+
+
+def get_severity_interpretation(total_easi):
+    if total_easi == 0:
+        return "No significant EASI features detected"
+    elif total_easi <= 3:
+        return "Mild EASI severity"
+    elif total_easi <= 6:
+        return "Moderate EASI severity"
+    elif total_easi <= 9:
+        return "Severe EASI severity"
+    else:
+        return "Very Severe EASI severity"
+
+
+# Image processing functions
+def smart_crop_to_square(image):
+    width, height = image.size
+    if width == height:
+        return image
+    
+    size = min(width, height)
+    left = (width - size) // 2
+    top = (height - size) // 2
+    right = left + size
+    bottom = top + size
+    
+    return image.crop((left, top, right, bottom))
+
+
+def generate_derm_foundation_embedding(model, image):
+    try:
+        if image.mode != 'RGB':
+            image = image.convert('RGB')
+        
+        buf = BytesIO()
+        image.save(buf, format='JPEG')
+        image_bytes = buf.getvalue()
+        
+        input_tensor = tf.train.Example(features=tf.train.Features(
+            feature={'image/encoded': tf.train.Feature(
+                bytes_list=tf.train.BytesList(value=[image_bytes]))
+            })).SerializeToString()
+        
+        infer = model.signatures["serving_default"]
+        output = infer(inputs=tf.constant([input_tensor]))
+        
+        if 'embedding' in output:
+            embedding_vector = output['embedding'].numpy().flatten()
+        else:
+            key = list(output.keys())[0]
+            embedding_vector = output[key].numpy().flatten()
+        
+        return embedding_vector
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error generating embedding: {str(e)}")
+
+
+# Global model instances
+derm_model = None
+easi_model = None
+model_source = "not_loaded"
+
+
+@app.on_event("startup")
+async def load_models():
+    """Load models on startup"""
+    global derm_model, easi_model, model_source
+    
+    # Force garbage collection before starting
+    import gc
+    gc.collect()
+    
+    # Check if model exists (should be pre-downloaded in Docker or already cached)
+    if not os.path.exists(DERM_FOUNDATION_PATH) or not os.path.exists(os.path.join(DERM_FOUNDATION_PATH, "saved_model.pb")):
+        print("=" * 60)
+        print("Derm Foundation model not found locally.")
+        print("=" * 60)
+        
+        # Try R2 first (fast)
+        print("\n[1/2] Attempting download from Cloudflare R2...")
+        success = download_derm_foundation_from_r2(DERM_FOUNDATION_PATH)
+        
+        if success:
+            model_source = "cloudflare_r2"
+        else:
+            # Fallback to HuggingFace
+            print("\n[2/2] R2 failed, trying HuggingFace as fallback...")
+            
+            if not HF_TOKEN:
+                print("=" * 60)
+                print("WARNING: HUGGINGFACE_TOKEN environment variable not set!")
+                print("Set it in Render Dashboard > Environment > Environment Variables")
+                print("Variable name: HUGGINGFACE_TOKEN")
+                print("Variable value: <your-hf-token>")
+                print("=" * 60)
+            
+            success = download_derm_foundation_from_hf(DERM_FOUNDATION_PATH)
+            if success:
+                model_source = "huggingface"
+            else:
+                print("=" * 60)
+                print("ERROR: Failed to download model from both R2 and HuggingFace!")
+                print("=" * 60)
+                model_source = "failed"
+    else:
+        print("✓ Derm Foundation model found locally (pre-downloaded or cached)")
+        model_source = "local_cache"
+    
+    # Load Derm Foundation model
+    if os.path.exists(os.path.join(DERM_FOUNDATION_PATH, "saved_model.pb")):
+        try:
+            print(f"Loading Derm-Foundation model from: {DERM_FOUNDATION_PATH}")
+            # Force garbage collection before loading large model
+            gc.collect()
+            
+            derm_model = tf.saved_model.load(DERM_FOUNDATION_PATH)
+            print(f"✓ Derm-Foundation model loaded successfully (source: {model_source})")
+            
+            # Cleanup after loading
+            gc.collect()
+        except Exception as e:
+            print(f"✗ Failed to load Derm Foundation model: {str(e)}")
+    
+    # Load EASI model (keep this local in your repo)
+    model_path = './trained_model/easi_severity_model_derm_foundation_individual.pkl'
+    if os.path.exists(model_path):
+        easi_model = DermFoundationNeuralNetwork()
+        success = easi_model.load_model(model_path)
+        if success:
+            print(f"✓ EASI model loaded from: {model_path}")
+        else:
+            print(f"✗ Failed to load EASI model")
+            easi_model = None
+    else:
+        print(f"✗ EASI model not found at: {model_path}")
+    
+    if derm_model is None or easi_model is None:
+        print("=" * 60)
+        print("WARNING: Some models failed to load!")
+        print(f"Derm Foundation: {'✓' if derm_model else '✗'}")
+        print(f"EASI Model: {'✓' if easi_model else '✗'}")
+        print("=" * 60)
+    else:
+        print("=" * 60)
+        print("✓ All models loaded successfully!")
+        print(f"Model source: {model_source}")
+        print("=" * 60)
+
+
+# API Endpoints
+
+@app.get("/")
+async def root():
+    """Root endpoint"""
+    return {
+        "message": "EASI Severity Prediction API",
+        "version": "1.0.0",
+        "model_source": model_source,
+        "docs": "/docs",
+        "health": "/health",
+        "predict": "/predict",
+        "conditions": "/conditions"
+    }
+
+
+@app.get("/health", response_model=HealthResponse)
+async def health_check():
+    """Health check endpoint"""
+    return {
+        "status": "ok" if (derm_model is not None and easi_model is not None) else "degraded",
+        "models_loaded": {
+            "derm_foundation": derm_model is not None,
+            "easi_model": easi_model is not None
+        },
+        "available_conditions": len(easi_model.mlb.classes_) if easi_model else 0,
+        "hf_token_configured": HF_TOKEN is not None,
+        "model_source": model_source
+    }
+
+
+@app.get("/conditions", response_model=Dict[str, List[str]])
+async def get_conditions():
+    """Get list of available conditions"""
+    if easi_model is None:
+        raise HTTPException(status_code=503, detail="EASI model not loaded")
+    
+    return {
+        "conditions": easi_model.mlb.classes_.tolist()
+    }
+
+
+@app.post("/predict", response_model=PredictionResponse)
+async def predict_easi(
+    file: UploadFile = File(..., description="Skin image file (JPG, JPEG, PNG)")
+):
+    """
+    Predict EASI scores from uploaded skin image.
+    
+    - **file**: Image file (JPG, JPEG, PNG)
+    - Returns: EASI scores, component breakdown, and condition predictions
+    """
+    
+    # Validate models loaded
+    if derm_model is None or easi_model is None:
+        raise HTTPException(
+            status_code=503,
+            detail="Models not loaded. Check server logs."
+        )
+    
+    # Validate file type
+    if not file.content_type.startswith('image/'):
+        raise HTTPException(
+            status_code=400,
+            detail="File must be an image (JPG, JPEG, PNG)"
+        )
+    
+    try:
+        # Read and process image
+        image_bytes = await file.read()
+        original_image = Image.open(BytesIO(image_bytes)).convert('RGB')
+        original_size = original_image.size
+        
+        # Process to 448x448
+        cropped_img = smart_crop_to_square(original_image)
+        processed_img = cropped_img.resize((448, 448), Image.Resampling.LANCZOS)
+        
+        # Generate embedding
+        embedding = generate_derm_foundation_embedding(derm_model, processed_img)
+        
+        # Make prediction
+        predictions = easi_model.predict(embedding)
+        
+        if predictions is None:
+            raise HTTPException(status_code=500, detail="Prediction failed")
+        
+        # Calculate EASI scores
+        easi_results, total_easi = calculate_easi_scores(predictions)
+        severity = get_severity_interpretation(total_easi)
+        
+        # Format predicted conditions
+        predicted_conditions = []
+        for i, condition in enumerate(predictions['dermatologist_skin_condition_on_label_name']):
+            prob = predictions['all_condition_probabilities'][condition]
+            conf = predictions['dermatologist_skin_condition_confidence'][i]
+            weight = predictions['weighted_skin_condition_label'][condition]
+            
+            # Find EASI category
+            easi_category = None
+            easi_contribution = 0
+            for cat_key, cat_info in easi_results.items():
+                for contrib in cat_info['contributing_conditions']:
+                    if contrib['condition'] == condition:
+                        easi_category = cat_info['name']
+                        easi_contribution = contrib['individual_score']
+                        break
+            
+            predicted_conditions.append(ConditionPrediction(
+                condition=condition,
+                probability=float(prob),
+                confidence=float(conf),
+                weight=float(weight),
+                easi_category=easi_category,
+                easi_contribution=easi_contribution
+            ))
+        
+        # Summary statistics
+        summary_stats = {
+            "total_conditions": len(predicted_conditions),
+            "average_confidence": float(np.mean(predictions['dermatologist_skin_condition_confidence'])) if predicted_conditions else 0.0,
+            "average_weight": float(np.mean(list(predictions['weighted_skin_condition_label'].values()))) if predicted_conditions else 0.0,
+            "total_weight": float(sum(predictions['weighted_skin_condition_label'].values()))
+        }
+        
+        # Format EASI components
+        easi_components_formatted = {
+            component: EASIComponent(
+                name=result['name'],
+                score=result['score'],
+                contributing_conditions=result['contributing_conditions']
+            )
+            for component, result in easi_results.items()
+        }
+        
+        return PredictionResponse(
+            success=True,
+            total_easi_score=total_easi,
+            severity_interpretation=severity,
+            easi_components=easi_components_formatted,
+            predicted_conditions=predicted_conditions,
+            summary_statistics=summary_stats,
+            image_info={
+                "original_size": f"{original_size[0]}x{original_size[1]}",
+                "processed_size": "448x448",
+                "filename": file.filename
+            }
+        )
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"Error processing image: {str(e)}"
+        )
+
+
+@app.exception_handler(HTTPException)
+async def http_exception_handler(request, exc):
+    return JSONResponse(
+        status_code=exc.status_code,
+        content=ErrorResponse(
+            error=exc.detail,
+            detail=str(exc)
+        ).dict()
+    )
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)

api_diagnostics.py

@@ -0,0 +1,321 @@
+"""
+API Diagnostic Script
+=====================
+Comprehensive diagnostics for EASI Severity Prediction API
+Checks dependencies, models, file paths, and numpy compatibility issues
+"""
+
+import sys
+import os
+from pathlib import Path
+import importlib.util
+
+def print_section(title):
+    """Print a formatted section header"""
+    print("\n" + "=" * 70)
+    print(f" {title}")
+    print("=" * 70)
+
+
+def check_python_environment():
+    """Check Python version and environment"""
+    print_section("Python Environment")
+    print(f"Python Version: {sys.version}")
+    print(f"Python Executable: {sys.executable}")
+    print(f"Platform: {sys.platform}")
+    print(f"Current Working Directory: {os.getcwd()}")
+
+
+def check_package_versions():
+    """Check installed package versions"""
+    print_section("Package Versions")
+    
+    packages = [
+        'numpy',
+        'tensorflow',
+        'fastapi',
+        'uvicorn',
+        'pillow',
+        'pandas',
+        'sklearn',
+        'pydantic',
+    ]
+    
+    for package in packages:
+        try:
+            if package == 'pillow':
+                import PIL
+                print(f"✓ PIL (Pillow): {PIL.__version__}")
+            elif package == 'sklearn':
+                import sklearn
+                print(f"✓ scikit-learn: {sklearn.__version__}")
+            else:
+                module = __import__(package)
+                version = getattr(module, '__version__', 'Unknown')
+                print(f"✓ {package}: {version}")
+        except ImportError as e:
+            print(f"✗ {package}: NOT INSTALLED - {e}")
+        except Exception as e:
+            print(f"✗ {package}: ERROR - {e}")
+
+
+def check_numpy_detailed():
+    """Detailed numpy diagnostics"""
+    print_section("NumPy Detailed Diagnostics")
+    
+    try:
+        import numpy as np
+        print(f"✓ NumPy Version: {np.__version__}")
+        print(f"✓ NumPy Location: {np.__file__}")
+        
+        # Check for numpy._core
+        try:
+            import numpy._core
+            print(f"✓ numpy._core exists: {numpy._core.__file__}")
+        except ImportError:
+            print("✗ numpy._core NOT FOUND (NumPy < 2.0)")
+            print("  This is the main issue! NumPy 2.0+ required for numpy._core")
+        
+        # Check for numpy.core (old path)
+        try:
+            import numpy.core
+            print(f"✓ numpy.core exists: {numpy.core.__file__}")
+        except ImportError:
+            print("✗ numpy.core NOT FOUND")
+        
+        # Check numpy configuration
+        print(f"\nNumPy Configuration:")
+        try:
+            np.show_config()
+        except:
+            print("  Could not show numpy config")
+            
+    except ImportError as e:
+        print(f"✗ NumPy NOT INSTALLED: {e}")
+    except Exception as e:
+        print(f"✗ NumPy ERROR: {e}")
+
+
+def check_tensorflow():
+    """Check TensorFlow installation and GPU support"""
+    print_section("TensorFlow Diagnostics")
+    
+    try:
+        import tensorflow as tf
+        print(f"✓ TensorFlow Version: {tf.__version__}")
+        print(f"✓ TensorFlow Location: {tf.__file__}")
+        print(f"✓ Built with CUDA: {tf.test.is_built_with_cuda()}")
+        print(f"✓ GPU Available: {len(tf.config.list_physical_devices('GPU')) > 0}")
+        
+        # List devices
+        devices = tf.config.list_physical_devices()
+        print(f"\nAvailable Devices:")
+        for device in devices:
+            print(f"  - {device}")
+            
+    except ImportError as e:
+        print(f"✗ TensorFlow NOT INSTALLED: {e}")
+    except Exception as e:
+        print(f"✗ TensorFlow ERROR: {e}")
+
+
+def check_model_files():
+    """Check for required model files"""
+    print_section("Model Files Check")
+    
+    # Check Derm Foundation model paths
+    print("\n1. Derm Foundation Model:")
+    derm_paths = [
+        "./derm_foundation/",
+        "./",
+        "./saved_model/",
+        "./model/",
+        "./derm-foundation/"
+    ]
+    
+    found_derm = False
+    for path in derm_paths:
+        saved_model_pb = os.path.join(path, "saved_model.pb")
+        if os.path.exists(saved_model_pb):
+            print(f"  ✓ Found: {saved_model_pb}")
+            print(f"    Size: {os.path.getsize(saved_model_pb)} bytes")
+            found_derm = True
+            
+            # Check for variables folder
+            variables_path = os.path.join(path, "variables")
+            if os.path.exists(variables_path):
+                print(f"    Variables folder: {variables_path}")
+                var_files = os.listdir(variables_path)
+                print(f"    Variable files: {len(var_files)}")
+        else:
+            print(f"  ✗ Not found: {saved_model_pb}")
+    
+    if not found_derm:
+        print("\n  ⚠ WARNING: No Derm Foundation model found!")
+    
+    # Check EASI model
+    print("\n2. EASI Model:")
+    easi_path = './trained_model/easi_severity_model_derm_foundation_individual.pkl'
+    if os.path.exists(easi_path):
+        print(f"  ✓ Found: {easi_path}")
+        print(f"    Size: {os.path.getsize(easi_path)} bytes")
+        
+        # Try to peek at pickle contents
+        try:
+            import pickle
+            with open(easi_path, 'rb') as f:
+                try:
+                    model_data = pickle.load(f)
+                    print(f"    Keys in model: {list(model_data.keys())}")
+                    if 'keras_model_path' in model_data:
+                        keras_path = model_data['keras_model_path']
+                        print(f"    Keras model path: {keras_path}")
+                        if os.path.exists(keras_path):
+                            print(f"    ✓ Keras model exists: {keras_path}")
+                        else:
+                            print(f"    ✗ Keras model NOT FOUND: {keras_path}")
+                except Exception as e:
+                    print(f"    ✗ Error loading pickle: {e}")
+        except ImportError:
+            print("    ✗ pickle module not available")
+    else:
+        print(f"  ✗ Not found: {easi_path}")
+        print(f"    Current directory: {os.getcwd()}")
+        
+        # Check if trained_model directory exists
+        if os.path.exists('./trained_model/'):
+            print(f"    trained_model/ exists. Contents:")
+            for item in os.listdir('./trained_model/'):
+                print(f"      - {item}")
+
+
+def check_directory_structure():
+    """Check directory structure"""
+    print_section("Directory Structure")
+    
+    current_dir = os.getcwd()
+    print(f"Current Directory: {current_dir}\n")
+    
+    # List all items in current directory
+    items = os.listdir('.')
+    print("Contents:")
+    for item in sorted(items):
+        path = os.path.join('.', item)
+        if os.path.isdir(path):
+            print(f"  📁 {item}/")
+        else:
+            size = os.path.getsize(path)
+            print(f"  📄 {item} ({size} bytes)")
+
+
+def test_pickle_load():
+    """Test if pickle can load with current numpy"""
+    print_section("Pickle Load Test")
+    
+    easi_path = './trained_model/easi_severity_model_derm_foundation_individual.pkl'
+    
+    if not os.path.exists(easi_path):
+        print(f"✗ Model file not found: {easi_path}")
+        return
+    
+    try:
+        import pickle
+        import numpy as np
+        
+        print(f"Attempting to load: {easi_path}")
+        print(f"NumPy version: {np.__version__}")
+        
+        with open(easi_path, 'rb') as f:
+            model_data = pickle.load(f)
+        
+        print("✓ Successfully loaded pickle file!")
+        print(f"Model data keys: {list(model_data.keys())}")
+        
+    except ModuleNotFoundError as e:
+        print(f"✗ Module not found: {e}")
+        print("\n  DIAGNOSIS: The pickle file was saved with a newer NumPy version.")
+        print("  SOLUTION: Upgrade numpy to version 2.0 or higher")
+        print("  Command: pip install --upgrade numpy>=2.0")
+        
+    except Exception as e:
+        print(f"✗ Error loading pickle: {e}")
+        print(f"  Error type: {type(e).__name__}")
+
+
+def check_sklearn():
+    """Check scikit-learn and its compatibility"""
+    print_section("Scikit-learn Diagnostics")
+    
+    try:
+        import sklearn
+        print(f"✓ scikit-learn Version: {sklearn.__version__}")
+        
+        # Check for common sklearn modules used in the model
+        try:
+            from sklearn.preprocessing import MultiLabelBinarizer, StandardScaler
+            print("✓ MultiLabelBinarizer available")
+            print("✓ StandardScaler available")
+        except ImportError as e:
+            print(f"✗ Import error: {e}")
+            
+    except ImportError:
+        print("✗ scikit-learn NOT INSTALLED")
+
+
+def provide_solutions():
+    """Provide solutions based on diagnostics"""
+    print_section("Recommended Solutions")
+    
+    print("""
+Based on the error "No module named 'numpy._core'", here are the solutions:
+
+1. UPGRADE NUMPY (Recommended):
+   pip install --upgrade numpy>=2.0.0
+   
+   This is the cleanest solution as newer packages expect NumPy 2.0+
+
+2. If NumPy 2.0 causes compatibility issues, RECREATE THE PICKLE:
+   - Load the original model with the old NumPy version
+   - Save it again with protocol 4 for better compatibility
+   - Or rebuild the model from scratch
+
+3. CHECK ALL DEPENDENCIES:
+   pip install --upgrade tensorflow numpy pandas scikit-learn pillow fastapi uvicorn
+
+4. CREATE FRESH VIRTUAL ENVIRONMENT:
+   python -m venv fresh_env
+   source fresh_env/bin/activate  # On Windows: fresh_env\\Scripts\\activate
+   pip install -r requirements.txt
+
+5. VERIFY PACKAGE COMPATIBILITY:
+   pip list --outdated
+   pip check
+
+After upgrading, restart your API server.
+""")
+
+
+def main():
+    """Run all diagnostics"""
+    print("=" * 70)
+    print(" EASI API DIAGNOSTIC TOOL")
+    print(" Analyzing system configuration and dependencies...")
+    print("=" * 70)
+    
+    check_python_environment()
+    check_package_versions()
+    check_numpy_detailed()
+    check_tensorflow()
+    check_sklearn()
+    check_directory_structure()
+    check_model_files()
+    test_pickle_load()
+    provide_solutions()
+    
+    print("\n" + "=" * 70)
+    print(" Diagnostics Complete!")
+    print("=" * 70)
+
+
+if __name__ == "__main__":
+    main()

download_model.py

@@ -0,0 +1,67 @@
+"""
+Download model during Docker build on Hugging Face Spaces
+"""
+import os
+import requests
+import gc
+
+R2_BASE_URL = "https://r2-worker.eczemanage.workers.dev"
+OUTPUT_DIR = "./derm_foundation/"
+
+def download_model():
+    print("=" * 70)
+    print("DOWNLOADING DERM FOUNDATION MODEL (Hugging Face Spaces Build)")
+    print("=" * 70)
+    
+    os.makedirs(OUTPUT_DIR, exist_ok=True)
+    
+    files = [
+        "saved_model.pb",
+        "variables/variables.index",
+        "variables/variables.data-00000-of-00001"
+    ]
+    
+    for file_path in files:
+        print(f"\n📥 Downloading {file_path}...")
+        url = f"{R2_BASE_URL}/{file_path}"
+        local_path = os.path.join(OUTPUT_DIR, file_path)
+        os.makedirs(os.path.dirname(local_path), exist_ok=True)
+        
+        try:
+            with requests.get(url, stream=True, timeout=1800) as r:
+                r.raise_for_status()
+                total_size = int(r.headers.get('content-length', 0))
+                downloaded = 0
+                chunk_count = 0
+                
+                with open(local_path, 'wb') as f:
+                    for chunk in r.iter_content(chunk_size=2*1024*1024):  # 2MB chunks (HF has RAM)
+                        if chunk:
+                            f.write(chunk)
+                            f.flush()
+                            downloaded += len(chunk)
+                            chunk_count += 1
+                            
+                            if chunk_count % 5 == 0:
+                                gc.collect()
+                            
+                            if total_size > 0 and chunk_count % 10 == 0:
+                                progress = (downloaded / total_size) * 100
+                                mb_downloaded = downloaded / (1024*1024)
+                                mb_total = total_size / (1024*1024)
+                                print(f"  Progress: {progress:.1f}% ({mb_downloaded:.1f}/{mb_total:.1f} MB)")
+                
+                gc.collect()
+            
+            print(f"✅ Successfully downloaded: {file_path}")
+            
+        except Exception as e:
+            print(f"❌ Error downloading {file_path}: {e}")
+            raise
+    
+    print("\n" + "=" * 70)
+    print("✅ MODEL DOWNLOAD COMPLETE! Ready to serve predictions.")
+    print("=" * 70)
+
+if __name__ == "__main__":
+    download_model()

easi_calculator.py

@@ -0,0 +1,198 @@
+import numpy as np
+from typing import Dict, Tuple, List
+
+
+# EASI component categorization
+EASI_CATEGORIES = {
+    'erythema': {
+        'name': 'Erythema (Redness)',
+        'conditions': [
+            'Post-Inflammatory hyperpigmentation',
+            'Erythema ab igne', 'Erythema annulare centrifugum',
+            'Erythema elevatum diutinum', 'Erythema gyratum repens',
+            'Erythema multiforme', 'Erythema nodosum',
+            'Flagellate erythema', 'Annular erythema',
+            'Drug Rash', 'Allergic Contact Dermatitis',
+            'Irritant Contact Dermatitis', 'Contact dermatitis',
+            'Acute dermatitis', 'Chronic dermatitis',
+            'Acute and chronic dermatitis',
+            'Sunburn', 'Photodermatitis', 'Phytophotodermatitis',
+            'Rosacea', 'Seborrheic Dermatitis', 'Stasis Dermatitis',
+            'Perioral Dermatitis',
+            'Burn erythema of abdominal wall',
+            'Burn erythema of back of hand',
+            'Burn erythema of lower leg',
+            'Cellulitis', 'Infection of skin', 'Viral Exanthem',
+            'Infected eczema', 'Crusted eczematous dermatitis',
+            'Inflammatory dermatosis',
+            'Vasculitis of the skin', 'Leukocytoclastic Vasculitis',
+            'Cutaneous lupus',
+            'CD - Contact dermatitis',
+            'Acute dermatitis, NOS',
+            'Herpes Simplex',
+            'Hypersensitivity',
+            'Impetigo',
+            'Pigmented purpuric eruption',
+            'Pityriasis rosea',
+            'Tinea',
+            'Tinea Versicolor'
+        ]
+    },
+    'induration': {
+        'name': 'Induration/Papulation (Swelling/Bumps)',
+        'conditions': [
+            'Prurigo nodularis', 'Urticaria', 'Granuloma annulare', 'Morphea',
+            'Scleroderma', 'Lichen Simplex Chronicus',
+            'Lichen planus', 'lichenoid eruption',
+            'Lichen nitidus', 'Lichen spinulosus', 'Lichen striatus',
+            'Keratosis pilaris', 'Molluscum Contagiosum',
+            'Verruca vulgaris', 'Folliculitis', 'Acne',
+            'Hidradenitis', 'Nodular vasculitis', 'Sweet syndrome',
+            'Necrobiosis lipoidica', 'Basal Cell Carcinoma',
+            'SCC', 'SCCIS', 'SK', 'ISK',
+            'Cutaneous T Cell Lymphoma', 'Skin cancer',
+            'Adnexal neoplasm', 'Insect Bite', 'Milia',
+            'Miliaria', 'Xanthoma', 'Psoriasis',
+            'Lichen planus/lichenoid eruption'
+        ]
+    },
+    'excoriation': {
+        'name': 'Excoriation (Scratching Damage)',
+        'conditions': [
+            'Inflicted skin lesions',
+            'Scabies', 'Abrasion', 'Abrasion of wrist',
+            'Superficial wound of body region', 'Scrape',
+            'Animal bite - wound', 'Pruritic dermatitis',
+            'Prurigo', 'Atopic dermatitis',
+            'Scab'
+        ]
+    },
+    'lichenification': {
+        'name': 'Lichenification (Skin Thickening)',
+        'conditions': [
+            'Lichenified eczematous dermatitis',
+            'Acanthosis nigricans', 'Hyperkeratosis of skin',
+            'HK - Hyperkeratosis', 'Keratoderma',
+            'Ichthyosis', 'Ichthyosiform dermatosis',
+            'Chronic eczema', 'Psoriasis',
+            'Xerosis'
+        ]
+    }
+}
+
+
+def probability_to_score(prob: float) -> int:
+    """Convert probability to EASI score (0-3)"""
+    if prob < 0.171:
+        return 0
+    elif prob < 0.238:
+        return 1
+    elif prob < 0.421:
+        return 2
+    elif prob < 0.614:
+        return 3
+    else:
+        return 3
+
+
+def calculate_easi_scores(predictions: Dict) -> Tuple[Dict, int]:
+    """
+    Calculate EASI component scores based on condition probabilities
+    
+    Args:
+        predictions: Dictionary containing prediction results
+    
+    Returns:
+        Tuple of (easi_results dict, total_easi_score int)
+    """
+    easi_results = {}
+    all_condition_probs = predictions['all_condition_probabilities']
+    
+    for component, category_info in EASI_CATEGORIES.items():
+        # Find all conditions in this category
+        category_conditions = []
+        
+        for condition_name, probability in all_condition_probs.items():
+            # Skip "Eczema" as it should not be included
+            if condition_name.lower() == 'eczema':
+                continue
+            
+            # Check if condition is in category
+            if condition_name in category_info['conditions']:
+                individual_score = probability_to_score(probability)
+                if individual_score > 0:
+                    category_conditions.append({
+                        'condition': condition_name,
+                        'probability': probability,
+                        'individual_score': individual_score
+                    })
+        
+        # Sort by probability
+        category_conditions.sort(key=lambda x: x['probability'], reverse=True)
+        
+        # Calculate component score (sum, capped at 3)
+        component_score = sum(c['individual_score'] for c in category_conditions)
+        component_score = min(component_score, 3)
+        
+        easi_results[component] = {
+            'name': category_info['name'],
+            'score': component_score,
+            'contributing_conditions': category_conditions
+        }
+    
+    # Calculate total EASI score
+    total_easi = sum(result['score'] for result in easi_results.values())
+    
+    return easi_results, total_easi
+
+
+def format_easi_response(easi_results: Dict, total_easi: int) -> Dict:
+    """
+    Format EASI results for API response
+    
+    Args:
+        easi_results: EASI calculation results
+        total_easi: Total EASI score
+    
+    Returns:
+        Formatted dictionary for JSON response
+    """
+    return {
+        'total_score': total_easi,
+        'components': {
+            'erythema': easi_results['erythema']['score'],
+            'induration': easi_results['induration']['score'],
+            'excoriation': easi_results['excoriation']['score'],
+            'lichenification': easi_results['lichenification']['score']
+        },
+        'severity': get_severity_level(total_easi),
+        'component_details': {
+            component: {
+                'name': data['name'],
+                'score': data['score'],
+                'contributing_conditions': [
+                    {
+                        'condition': c['condition'],
+                        'probability': round(c['probability'], 4),
+                        'contribution': c['individual_score']
+                    }
+                    for c in data['contributing_conditions']
+                ]
+            }
+            for component, data in easi_results.items()
+        }
+    }
+
+
+def get_severity_level(total_easi: int) -> str:
+    """Get severity level description from EASI score"""
+    if total_easi == 0:
+        return "No significant EASI features detected"
+    elif total_easi <= 3:
+        return "Mild EASI severity"
+    elif total_easi <= 6:
+        return "Moderate EASI severity"
+    elif total_easi <= 9:
+        return "Severe EASI severity"
+    else:
+        return "Very Severe EASI severity"

image_processing.py

@@ -0,0 +1,125 @@
+from PIL import Image
+import tensorflow as tf
+import numpy as np
+from io import BytesIO
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+def smart_crop_to_square(image: Image.Image) -> Image.Image:
+    """Crop image to square focusing on center"""
+    width, height = image.size
+    
+    if width == height:
+        return image
+    
+    # Crop to square using center
+    size = min(width, height)
+    left = (width - size) // 2
+    top = (height - size) // 2
+    right = left + size
+    bottom = top + size
+    
+    return image.crop((left, top, right, bottom))
+
+
+def preprocess_image(image: Image.Image, target_size: int = 448) -> Image.Image:
+    """
+    Preprocess image for model input
+    
+    Args:
+        image: PIL Image
+        target_size: Target size for square image (default 448)
+    
+    Returns:
+        Preprocessed PIL Image
+    """
+    try:
+        # Ensure RGB
+        if image.mode != 'RGB':
+            image = image.convert('RGB')
+        
+        # Smart crop to square
+        image = smart_crop_to_square(image)
+        
+        # Resize to target size
+        image = image.resize((target_size, target_size), Image.Resampling.LANCZOS)
+        
+        logger.info(f"Image preprocessed to {target_size}x{target_size}")
+        return image
+        
+    except Exception as e:
+        logger.error(f"Error preprocessing image: {e}")
+        raise
+
+
+def generate_embedding(model, image: Image.Image) -> np.ndarray:
+    """
+    Generate embedding from Derm Foundation model
+    
+    Args:
+        model: Loaded Derm Foundation model
+        image: Preprocessed PIL Image (448x448)
+    
+    Returns:
+        Embedding vector as numpy array
+    """
+    try:
+        # Save image to bytes
+        buf = BytesIO()
+        image.save(buf, format='JPEG')
+        image_bytes = buf.getvalue()
+        
+        # Format input as TensorFlow Example
+        input_tensor = tf.train.Example(features=tf.train.Features(
+            feature={'image/encoded': tf.train.Feature(
+                bytes_list=tf.train.BytesList(value=[image_bytes]))
+            })).SerializeToString()
+        
+        # Call inference
+        infer = model.get_inference_function()
+        output = infer(inputs=tf.constant([input_tensor]))
+        
+        # Extract embedding
+        if 'embedding' in output:
+            embedding_vector = output['embedding'].numpy().flatten()
+        else:
+            # Use first available output
+            key = list(output.keys())[0]
+            embedding_vector = output[key].numpy().flatten()
+        
+        logger.info(f"Generated embedding of shape {embedding_vector.shape}")
+        return embedding_vector
+        
+    except Exception as e:
+        logger.error(f"Error generating embedding: {e}")
+        raise
+
+
+def validate_image(file_content: bytes, max_size_mb: int = 10) -> bool:
+    """
+    Validate uploaded image
+    
+    Args:
+        file_content: Raw image bytes
+        max_size_mb: Maximum allowed file size in MB
+    
+    Returns:
+        True if valid, False otherwise
+    """
+    # Check file size
+    size_mb = len(file_content) / (1024 * 1024)
+    if size_mb > max_size_mb:
+        logger.warning(f"Image too large: {size_mb:.2f}MB > {max_size_mb}MB")
+        return False
+    
+    # Try to open as image
+    try:
+        image = Image.open(BytesIO(file_content))
+        # Check if it's a valid image format
+        image.verify()
+        return True
+    except Exception as e:
+        logger.warning(f"Invalid image: {e}")
+        return False

model_loader.py

@@ -0,0 +1,216 @@
+import os
+import pickle
+import tensorflow as tf
+import logging
+from typing import Optional
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class DermFoundationModel:
+    """Wrapper for Google's Derm Foundation model"""
+    
+    def __init__(self, model_path: str):
+        self.model_path = model_path
+        self.model = None
+    
+    def load(self) -> bool:
+        """Load the Derm Foundation SavedModel"""
+        try:
+            saved_model_pb = os.path.join(self.model_path, "saved_model.pb")
+            
+            if not os.path.exists(saved_model_pb):
+                logger.error(f"Model file not found at {saved_model_pb}")
+                return False
+            
+            self.model = tf.saved_model.load(self.model_path)
+            logger.info(f"Derm Foundation model loaded from {self.model_path}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Error loading Derm Foundation model: {e}")
+            return False
+    
+    def get_inference_function(self):
+        """Get the model's inference signature"""
+        if self.model is None:
+            raise RuntimeError("Model not loaded")
+        return self.model.signatures["serving_default"]
+
+
+class EASIModel:
+    """Wrapper for EASI severity prediction model"""
+    
+    def __init__(self, model_path: str):
+        self.model_path = model_path
+        self.model = None
+        self.mlb = None
+        self.embedding_scaler = None
+        self.confidence_scaler = None
+        self.weighted_scaler = None
+    
+    def load(self) -> bool:
+        """Load the EASI model and preprocessors"""
+        try:
+            if not os.path.exists(self.model_path):
+                logger.error(f"EASI model not found at {self.model_path}")
+                return False
+            
+            logger.info(f"Loading pickle from {self.model_path}")
+            with open(self.model_path, 'rb') as f:
+                model_data = pickle.load(f)
+            
+            logger.info("Pickle loaded successfully")
+            
+            # Load preprocessing components
+            self.mlb = model_data['mlb']
+            self.embedding_scaler = model_data['embedding_scaler']
+            self.confidence_scaler = model_data['confidence_scaler']
+            self.weighted_scaler = model_data['weighted_scaler']
+            
+            logger.info("Preprocessors loaded")
+            
+            # Load Keras model
+            keras_model_path = model_data['keras_model_path']
+            logger.info(f"Keras model path: {keras_model_path}")
+            
+            if not os.path.exists(keras_model_path):
+                logger.error(f"Keras model not found at {keras_model_path}")
+                logger.error(f"Current working directory: {os.getcwd()}")
+                logger.error(f"Files in models/trained_model/: {os.listdir('./models/trained_model/')}")
+                return False
+            
+            logger.info(f"Loading Keras model from {keras_model_path}")
+            self.model = tf.keras.models.load_model(keras_model_path)
+            
+            logger.info(f"EASI model loaded successfully from {self.model_path}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Error loading EASI model: {e}", exc_info=True)
+            return False
+    
+    def predict(self, embedding):
+        """Make predictions on a single embedding"""
+        if self.model is None:
+            raise RuntimeError("Model not loaded")
+        
+        import numpy as np
+        
+        if len(embedding.shape) == 1:
+            embedding = embedding.reshape(1, -1)
+        
+        # Scale embedding
+        embedding_scaled = self.embedding_scaler.transform(embedding)
+        
+        # Make predictions
+        predictions = self.model.predict(embedding_scaled, verbose=0)
+        
+        # Process outputs
+        condition_probs = predictions['conditions'][0]
+        individual_confidences = predictions['individual_confidences'][0]
+        individual_weights = predictions['individual_weights'][0]
+        
+        # Threshold for predictions
+        condition_threshold = 0.3
+        predicted_indices = np.where(condition_probs > condition_threshold)[0]
+        
+        # Build results
+        predicted_conditions = []
+        predicted_confidences = []
+        predicted_weights_dict = {}
+        
+        for idx in predicted_indices:
+            condition_name = self.mlb.classes_[idx]
+            condition_prob = float(condition_probs[idx])
+            
+            # Inverse transform individual outputs
+            if individual_confidences[idx] > 0:
+                confidence_orig = self.confidence_scaler.inverse_transform(
+                    [[individual_confidences[idx]]]
+                )[0, 0]
+            else:
+                confidence_orig = 0.0
+            
+            if individual_weights[idx] > 0:
+                weight_orig = self.weighted_scaler.inverse_transform(
+                    [[individual_weights[idx]]]
+                )[0, 0]
+            else:
+                weight_orig = 0.0
+            
+            predicted_conditions.append(condition_name)
+            predicted_confidences.append(max(0, confidence_orig))
+            predicted_weights_dict[condition_name] = max(0, weight_orig)
+        
+        # All condition probabilities
+        all_condition_probs = {}
+        all_confidences = {}
+        all_weights = {}
+        
+        for i, class_name in enumerate(self.mlb.classes_):
+            all_condition_probs[class_name] = float(condition_probs[i])
+            
+            if individual_confidences[i] > 0:
+                conf_orig = self.confidence_scaler.inverse_transform(
+                    [[individual_confidences[i]]]
+                )[0, 0]
+                all_confidences[class_name] = max(0, conf_orig)
+            else:
+                all_confidences[class_name] = 0.0
+            
+            if individual_weights[i] > 0:
+                weight_orig = self.weighted_scaler.inverse_transform(
+                    [[individual_weights[i]]]
+                )[0, 0]
+                all_weights[class_name] = max(0, weight_orig)
+            else:
+                all_weights[class_name] = 0.0
+        
+        return {
+            'dermatologist_skin_condition_on_label_name': predicted_conditions,
+            'dermatologist_skin_condition_confidence': predicted_confidences,
+            'weighted_skin_condition_label': predicted_weights_dict,
+            'all_condition_probabilities': all_condition_probs,
+            'all_individual_confidences': all_confidences,
+            'all_individual_weights': all_weights,
+            'condition_threshold': condition_threshold
+        }
+
+
+class ModelManager:
+    """Singleton manager for all models"""
+    
+    _instance = None
+    
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super(ModelManager, cls).__new__(cls)
+            cls._instance.derm_model = None
+            cls._instance.easi_model = None
+        return cls._instance
+    
+    def load_models(self, derm_path: str, easi_path: str) -> bool:
+        """Load both models"""
+        logger.info("Loading models...")
+        
+        # Load Derm Foundation model
+        self.derm_model = DermFoundationModel(derm_path)
+        if not self.derm_model.load():
+            return False
+        
+        # Load EASI model
+        self.easi_model = EASIModel(easi_path)
+        if not self.easi_model.load():
+            return False
+        
+        logger.info("All models loaded successfully")
+        return True
+    
+    def is_ready(self) -> bool:
+        """Check if both models are loaded"""
+        return (self.derm_model is not None and 
+                self.derm_model.model is not None and
+                self.easi_model is not None and 
+                self.easi_model.model is not None)

render.yaml

@@ -0,0 +1,17 @@
+services:
+  - type: web
+    name: easi-prediction-api
+    env: python
+    region: oregon
+    plan: free
+    branch: main
+    buildCommand: pip install -r requirements.txt
+    startCommand: uvicorn api:app --host 0.0.0.0 --port $PORT
+    healthCheckPath: /health
+    envVars:
+      - key: PYTHON_VERSION
+        value: 3.11.0
+      - key: TF_CPP_MIN_LOG_LEVEL
+        value: 2
+      - key: TF_ENABLE_ONEDNN_OPTS
+        value: 0

requirements.txt

@@ -0,0 +1,11 @@
+fastapi==0.104.1
+uvicorn[standard]==0.24.0
+python-multipart==0.0.6
+pillow==10.1.0
+tensorflow>=2.13.0
+numpy==1.26.4
+scikit-learn==1.3.2
+pandas==2.1.3
+python-dotenv==1.0.0
+huggingface-hub==0.35.3
+requests==2.31.0