Deploy to Hugging Face Spaces - clean commit

.dockerignore

@@ -0,0 +1,6 @@
+__pycache__/
+*.pyc
+*.pyo
+*.pkl
+*.h5
+.env

.gitignore

@@ -0,0 +1,36 @@
+# Python cache
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Virtual environments
+.venv/
+venv/
+env/
+
+# Environment variables files
+.env
+*.env
+
+# VSCode settings
+.vscode/
+
+# MacOS files
+.DS_Store
+
+# Logs
+*.log
+
+# Model files
+app/model/efficientnetv2s.h5
+
+# Jupyter Notebook checkpoints
+.ipynb_checkpoints/
+
+# Build / distribution folders
+build/
+dist/
+*.egg-info/
+
+# Pytest cache
+.pytest_cache/

Dockerfile

@@ -0,0 +1,10 @@
+FROM tensorflow/tensorflow:2.10.0-gpu
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY app/ ./app/
+
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Miguel Plana
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,134 @@
+---
+title: SkinAI Diagnostics
+emoji: 🔬
+colorFrom: blue
+colorTo: purple
+sdk: docker
+app_port: 7860
+pinned: false
+---
+
+# Skin Cancer Classifier API
+
+SkinAI Diagnostics — a FastAPI-powered web application for skin cancer image classification using deep learning.
+
+---
+
+## Overview
+
+This project delivers a professional web interface for classifying dermatoscopic images. It enables users to upload a skin lesion image and obtain a prediction with calibrated confidence scores, alongside links to technical details of the underlying model.
+
+---
+
+## Repository Structure
+
+```
+skin-cancer-api/
+├── app/
+│   ├── main.py                # FastAPI application entry point
+│   ├── predict.py             # Image preprocessing and prediction logic
+│   ├── model_loader.py        # Loads the trained EfficientNetV2S model
+│   ├── model/                 # Local model storage (auto-downloaded if missing)
+│   │   └── efficientnetv2s.h5 # Pretrained model file
+├── test_images/               # Sample images for testing the app
+│    └── ...
+├── requirements.txt           # Python dependencies
+├── Dockerfile                 # Docker setup for deployment
+├── .dockerignore              # Docker ignore rules
+└── README.md                  # Project documentation (this file)
+```
+
+---
+
+## Features
+
+- Seven-class classification of dermatoscopic images:
+  - Actinic Keratoses and Intraepithelial Carcinoma (AKIEC)
+  - Basal Cell Carcinoma (BCC)
+  - Benign Keratosis-like Lesions (BKL)
+  - Dermatofibroma (DF)
+  - Melanoma (MEL)
+  - Melanocytic Nevi (NV)
+  - Vascular Lesions (VASC)
+- Professional web interface built with FastAPI and Jinja2
+- Temperature Scaling (T-scaling) for calibrated probabilities
+- Technical transparency: model architecture, training setup, and metrics
+- Confidence visualization with a probability chart
+- Sample images available in `test_images/`
+
+---
+
+## Model Details
+
+- Base Model: EfficientNetV2S (20.5 million parameters)
+- Dataset: [HAM10000](https://dataverse.harvard.edu/dataset.xhtml?persistentId=doi:10.7910/DVN/DBW86T)
+- Calibration: Temperature Scaling (optimal T=2.77)
+- Performance:
+  - Accuracy: 0.88
+  - Macro F1-score: 0.80
+  - Expected Calibration Error (ECE): 0.022 (after T-scaling)
+
+For full technical details, see the Model Technical Information section in the app.
+
+---
+
+## Model Download from Hugging Face
+
+The model file `efficientnetv2s.h5` is hosted on [Hugging Face Hub](https://huggingface.co/Miguel764/efficientnetv2s-skin-cancer-classifier) and is automatically downloaded the first time the app runs.
+
+How it works:
+
+- Expected local path: `app/model/efficientnetv2s.h5`
+- On startup, `app/model_loader.py` checks for the file
+- If missing, it is downloaded via `huggingface_hub` and saved to `app/model/`
+- Subsequent runs load the local copy
+
+Note for Docker users: When running inside a container, the downloaded model is stored inside the container’s filesystem. Mount a volume if you need to persist it on the host.
+
+Manual download link (optional): https://huggingface.co/Miguel764/efficientnetv2s-skin-cancer-classifier
+
+---
+
+## Installation & Usage
+
+### 1) Clone the repository
+
+```sh
+git clone https://github.com/yourusername/skin-cancer-api.git
+cd skin-cancer-api
+```
+
+### 2) Install dependencies
+
+```sh
+pip install -r requirements.txt
+```
+
+Note: Requires Python 3.8+ and TensorFlow 2.10.0 (GPU recommended).
+
+### 3) Run the application
+
+```sh
+uvicorn app.main:app --reload
+```
+
+The app will be available at http://localhost:8000
+
+Access the API docs at http://127.0.0.1:8000/docs
+
+### 4) Try with sample images
+
+Use the images in the `test_images/` folder to test the classifier.
+
+---
+
+## Docker Deployment
+
+Build and run the app in a container:
+
+```sh
+docker build -t skin-cancer-api .
+docker run -p 8000:8000 skin-cancer-api
+```
+
+---

app/main.py

@@ -0,0 +1,55 @@
+# app/main.py
+
+import shutil
+import os
+import uuid
+from fastapi import FastAPI, Request, File, UploadFile, Form
+from fastapi.responses import HTMLResponse
+from fastapi.templating import Jinja2Templates
+from fastapi.staticfiles import StaticFiles
+from app.predict import predict_image
+
+app = FastAPI()
+
+templates = Jinja2Templates(directory="app/templates")
+app.mount("/static", StaticFiles(directory="app/static"), name="static")
+
+os.makedirs("app/uploads", exist_ok=True)
+app.mount("/uploads", StaticFiles(directory="app/uploads"), name="uploads")
+
+
+@app.get("/", response_class=HTMLResponse)
+async def index(request: Request):
+    return templates.TemplateResponse("main.html", {"request": request})
+
+@app.get("/model-info", response_class=HTMLResponse)
+async def model_info(request: Request):
+    return templates.TemplateResponse("model_info.html", {"request": request})
+
+@app.post("/upload-image", response_class=HTMLResponse)
+async def upload_image(request: Request, file: UploadFile = File(...)):
+
+    unique_filename = f"{uuid.uuid4().hex}_{file.filename}"
+    file_path = f"app/uploads/{unique_filename}"
+
+    with open(file_path, "wb") as buffer:
+        shutil.copyfileobj(file.file, buffer)
+
+    return templates.TemplateResponse("main.html", {
+        "request": request,
+        "image_path": f"/uploads/{unique_filename}"
+    })
+
+
+@app.post("/predict", response_class=HTMLResponse)
+async def predict(request: Request, image_path: str = Form(...)):
+    label, confidence, all_predictions = predict_image(f"app{image_path}")
+    confidence_percent = f"{confidence * 100:.2f}%"
+
+    return templates.TemplateResponse("main.html", {
+        "request": request,
+        "image_path": image_path,
+        "label": label,
+        "confidence": confidence_percent,
+        "predictions": all_predictions
+    })

app/model_loader.py

@@ -0,0 +1,22 @@
+# app/model_loader.py
+import os
+import tensorflow as tf
+from huggingface_hub import hf_hub_download
+
+MODEL_PATH = "app/model/efficientnetv2s.h5"
+REPO_ID = "Miguel764/efficientnetv2s-skin-cancer-classifier"
+FILENAME = "efficientnetv2s.h5"
+
+def load_model():
+    if not os.path.exists(MODEL_PATH):
+        print("Model not found locally. Downloading from Hugging Face...")
+        os.makedirs(os.path.dirname(MODEL_PATH), exist_ok=True)
+        hf_hub_download(
+            repo_id=REPO_ID,
+            filename=FILENAME,
+            local_dir="app/model"
+        )
+    else:
+        print("Model already exists locally.")
+
+    return tf.keras.models.load_model(MODEL_PATH)

app/predict.py

@@ -0,0 +1,62 @@
+# app/predict.py
+from tensorflow.keras.preprocessing import image
+import numpy as np
+import tensorflow as tf
+from app.model_loader import load_model
+
+model = load_model()
+
+# Pre-calculated optimal temperature value
+TEMPERATURE = 2.77
+
+class_names_mapping = {
+    0: "AKIEC",
+    1: "BCC",
+    2: "BKL",
+    3: "DF",
+    4: "MEL",
+    5: "NV",
+    6: "VASC"
+}
+
+full_names = {
+    "AKIEC": "Actinic Keratoses and Intraepithelial Carcinoma (AKIEC)",
+    "BCC": "Basal Cell Carcinoma (BCC)",
+    "BKL": "Benign Keratosis-like Lesions (BKL)",
+    "DF": "Dermatofibroma (DF)",
+    "MEL": "Melanoma (MEL)",
+    "NV": "Melanocytic Nevi (NV)",
+    "VASC": "Vascular Lesions (VASC)"
+}
+
+def preprocess_image(file):
+    img = image.load_img(file, target_size=(224, 224))
+    img_array = image.img_to_array(img) / 255.0
+    img_array = (img_array - 0.5) * 2
+    return np.expand_dims(img_array, axis=0)
+
+def predict_image(file):
+    processed = preprocess_image(file)
+
+    # Obtaining logits by disabling the final softmax
+    logits_model = tf.keras.Model(inputs=model.input, outputs=model.layers[-2].output)
+    logits = logits_model(processed)
+
+    # Apply final layer without softmax (if the last layer is Dense with softmax)
+    final_dense = model.layers[-1]
+    logits = final_dense(logits)
+
+    # Apply T-scaling: logits / T, then softmax
+    scaled_logits = logits / TEMPERATURE
+    scaled_probs = tf.nn.softmax(scaled_logits).numpy()[0]
+
+    class_idx = int(np.argmax(scaled_probs))
+    top_label = full_names[class_names_mapping[class_idx]]
+    top_confidence = float(scaled_probs[class_idx])
+
+    all_predictions = [
+        {"label": class_names_mapping[i], "confidence": float(pred)}
+        for i, pred in enumerate(scaled_probs)
+    ]
+
+    return top_label, top_confidence, all_predictions

requirements.txt

@@ -0,0 +1,7 @@
+fastapi
+uvicorn[standard]
+numpy
+pillow
+jinja2
+python-multipart
+huggingface_hub