Prepare Image Classification for Hugging Face Spaces deployment

Dockerfile

@@ -1,10 +1,32 @@
-FROM tensorflow/tensorflow:2.10.0-gpu
+FROM python:3.9
 
-WORKDIR /app
+# Set working directory
+WORKDIR /code
 
-COPY requirements.txt .
-RUN pip install --no-cache-dir -r requirements.txt
+# Install system dependencies for OpenCV and TensorFlow
+RUN apt-get update && apt-get install -y \
+    libglib2.0-0 \
+    libsm6 \
+    libxext6 \
+    libxrender-dev \
+    libgomp1 \
+    libgl1-mesa-glx \
+    && rm -rf /var/lib/apt/lists/*
 
-COPY app/ ./app/
+# Copy requirements first for better caching
+COPY ./requirements.txt /code/requirements.txt
 
-CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]
+# Install Python dependencies
+RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
+
+# Copy application code
+COPY . /code
+
+# Expose port 7860 (required by Hugging Face Spaces)
+EXPOSE 7860
+
+# Set environment variables
+ENV PYTHONPATH=/code
+
+# Command to run the application
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,40 +1,39 @@
 ---
-title: SkinAI Diagnostics
+title: GP-Tea Skin Analysis
 emoji: 🔬
-colorFrom: blue
-colorTo: purple
+colorFrom: green
+colorTo: blue
 sdk: docker
 app_port: 7860
-pinned: false
 ---
 
-# Skin Cancer Classifier API
+# GP-Tea Skin Analysis API
 
-SkinAI Diagnostics — a FastAPI-powered web application for skin cancer image classification using deep learning.
+An AI-powered skin condition analysis service that provides medical insights from skin images using deep learning.
 
----
-
-## Overview
+## Features
 
-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.
+- **Image Classification**: Advanced skin condition detection using TensorFlow EfficientNetV2S
+- **Medical Analysis**: Comprehensive skin health assessment with confidence scoring
+- **Real-time Processing**: Fast inference with optimized model performance
+- **REST API**: Easy integration with mobile and web applications
 
 ---
 
 ## Repository Structure
 
 ```
-skin-cancer-api/
+api_image/
 ├── app/
-│   ├── main.py                # FastAPI application entry point
+│   ├── main.py                # FastAPI application with JSON endpoints
 │   ├── 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
-│    └── ...
+│   └── uploads/               # Temporary upload directory (auto-created)
+├── test_images/               # Sample images for testing the API
 ├── requirements.txt           # Python dependencies
 ├── Dockerfile                 # Docker setup for deployment
-├── .dockerignore              # Docker ignore rules
 └── README.md                  # Project documentation (this file)
 ```
 
@@ -42,19 +41,15 @@ skin-cancer-api/
 
 ## 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/`
+- **JSON API Endpoints**: Clean REST API for Flutter integration
+- **CORS Enabled**: Ready for mobile app cross-origin requests
+- **Multi-class Classification**: Supports medical image classification
+- **Confidence Scores**: Returns probability percentages for predictions
+- **File Upload Support**: Handles image file uploads with validation
+- **Error Handling**: Proper HTTP status codes and error messages
+- **Health Check**: Monitoring endpoint for service status
+- **Temperature Scaling**: Calibrated probabilities for reliable predictions
+- **Automatic Cleanup**: Temporary files are automatically removed
 
 ---
 
@@ -91,44 +86,126 @@ Manual download link (optional): https://huggingface.co/Miguel764/efficientnetv2
 
 ## Installation & Usage
 
-### 1) Clone the repository
+### 1) Install dependencies
 
 ```sh
-git clone https://github.com/yourusername/skin-cancer-api.git
-cd skin-cancer-api
+cd Image_classification/api_image
+pip install -r requirements.txt
 ```
 
-### 2) Install dependencies
+**Requirements**: Python 3.8 and TensorFlow 2.10.0 (GPU recommended). (very important!!!!! Must be Python 3.8)
+
+### 2) Run the API server
 
 ```sh
-pip install -r requirements.txt
+  uvicorn app.main:app --host 0.0.0.0 --port 8003 --reload
 ```
 
-Note: Requires Python 3.8+ and TensorFlow 2.10.0 (GPU recommended).
+The API will be available at http://localhost:8003
+
+Access the API documentation at http://localhost:8003/docs
+
+### 3) Test the API
+
+Use the sample images in `test_images/` folder to test the endpoints.
+
+---
+
+## API Endpoints
+
+### Health Check
+
+- **GET** `/health` - Service health status
+
+### Image Classification
 
-### 3) Run the application
+- **POST** `/api/classify` - Upload and classify medical image
+
+#### Example Request (cURL):
 
 ```sh
-uvicorn app.main:app --reload
+curl -X POST "http://localhost:8000/api/classify" \
+     -H "accept: application/json" \
+     -H "Content-Type: multipart/form-data" \
+     -F "file=@test_images/sample.jpg"
+```
+
+#### Example Response:
+
+```json
+{
+  "success": true,
+  "prediction": {
+    "top_prediction": {
+      "label": "Melanoma",
+      "confidence": 0.95,
+      "confidence_percent": "95.00%"
+    },
+    "all_predictions": [
+      {
+        "label": "Melanoma",
+        "confidence": 0.95,
+        "confidence_percent": "95.00%"
+      },
+      {
+        "label": "Benign Nevus",
+        "confidence": 0.03,
+        "confidence_percent": "3.00%"
+      }
+    ]
+  }
+}
 ```
 
-The app will be available at http://localhost:8000
+---
 
-Access the API docs at http://127.0.0.1:8000/docs
+## Flutter Integration
 
-### 4) Try with sample images
+### Base URL Configuration
 
-Use the images in the `test_images/` folder to test the classifier.
+```dart
+class ApiConfig {
+  static const String imageApiUrl = "http://localhost:8000";
+}
+```
 
 ---
 
 ## Docker Deployment
 
-Build and run the app in a container:
+Build and run the API in a container:
 
 ```sh
-docker build -t skin-cancer-api .
-docker run -p 8000:8000 skin-cancer-api
+docker build -t medical-image-api .
+docker run -p 8000:8000 medical-image-api
 ```
 
 ---
+
+## Error Handling
+
+The API returns consistent error responses:
+
+```json
+{
+  "detail": "File must be an image"
+}
+```
+
+Common HTTP status codes:
+
+- `200` - Success
+- `400` - Bad Request (invalid file, missing data)
+- `422` - Unprocessable Entity (validation error)
+- `500` - Internal Server Error (classification failed)
+
+---
+
+## Technical Notes
+
+- **Backend Only**: No web interface, pure JSON API
+- **CORS Enabled**: Ready for mobile app integration
+- **File Validation**: Checks file type and validity
+- **Temporary Storage**: Uploaded files are automatically cleaned up
+- **Model Auto-Download**: Model downloads from Hugging Face on first run
+- **Python 3.8 Compatible**: Uses TensorFlow 2.10.0 for compatibility

app.py

@@ -0,0 +1,12 @@
+# app.py - Alternative entry point for Hugging Face Spaces
+
+import uvicorn
+from app.main import app
+
+if __name__ == "__main__":
+    uvicorn.run(
+        "app.main:app",
+        host="0.0.0.0",
+        port=7860,
+        reload=False
+    )

app/main.py

@@ -1,55 +1,75 @@
-# app/main.py
+# 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 fastapi import FastAPI, File, UploadFile, HTTPException
+from fastapi.responses import JSONResponse
+from fastapi.middleware.cors import CORSMiddleware
 from app.predict import predict_image
 
-app = FastAPI()
+app = FastAPI(
+    title="GP-Tea Skin Analysis API",
+    description="AI-powered skin condition analysis service",
+    version="1.0.0"
+)
 
-templates = Jinja2Templates(directory="app/templates")
-app.mount("/static", StaticFiles(directory="app/static"), name="static")
+# Add CORS middleware for Flutter integration
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
 
+# Create uploads directory
 os.makedirs("app/uploads", exist_ok=True)
-app.mount("/uploads", StaticFiles(directory="app/uploads"), name="uploads")
 
+@app.get("/health")
+async def health_check():
+    return {"status": "healthy", "service": "gp-tea-skin-analysis"}
 
-@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.post("/analyze_image")
+async def analyze_image(file: UploadFile = File(...)):
+    """Analyze skin image for medical conditions"""
+    try:
+        if not file.content_type or not file.content_type.startswith('image/'):
+            raise HTTPException(status_code=400, detail="File must be an image")
+        
+        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)
+        
+        label, confidence, all_predictions = predict_image(file_path)
+        os.remove(file_path)
+        
+        formatted_predictions = []
+        for pred in all_predictions:
+            formatted_predictions.append({
+                "label": pred["label"],
+                "confidence": float(pred["confidence"]),
+                "confidence_percent": f"{pred['confidence'] * 100:.2f}%"
+            })
+        
+        return JSONResponse(
+            status_code=200,
+            content={
+                "success": True,
+                "prediction": {
+                    "top_prediction": {
+                        "label": label,
+                        "confidence": float(confidence),
+                        "confidence_percent": f"{confidence * 100:.2f}%"
+                    },
+                    "all_predictions": formatted_predictions
+                }
+            }
+        )
+        
+    except Exception as e:
+        if 'file_path' in locals() and os.path.exists(file_path):
+            os.remove(file_path)
+        raise HTTPException(status_code=500, detail=f"Classification failed: {str(e)}")

requirements.txt

@@ -1,7 +1,8 @@
-fastapi
-uvicorn[standard]
-numpy
-pillow
-jinja2
-python-multipart
-huggingface_hub
+fastapi==0.104.1
+uvicorn[standard]==0.24.0
+pydantic==2.5.0
+python-multipart==0.0.6
+numpy==1.26.0
+Pillow==10.0.0
+tensorflow==2.15.0
+opencv-python-headless==4.8.0.76