Deploy VCE backend with Docker

Dockerfile

@@ -0,0 +1,29 @@
+FROM python:3.10-slim
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements and install Python dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application files
+COPY . .
+
+# Create uploads directory
+RUN mkdir -p uploads
+
+# Expose port
+EXPOSE 7860
+
+# Set environment variable for Hugging Face
+ENV GRADIO_SERVER_NAME="0.0.0.0"
+ENV GRADIO_SERVER_PORT=7860
+
+# Run the application
+CMD ["gunicorn", "app:app", "--bind", "0.0.0.0:7860", "--timeout", "300", "--workers", "1", "--threads", "2"]

README.md

@@ -1,10 +1,12 @@
 ---
-title: VCE
-emoji: 🐢
-colorFrom: gray
+title: VCE Medical Diagnosis Backend
+emoji: 🏥
+colorFrom: green
 colorTo: blue
 sdk: docker
 pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# VCE Medical Diagnosis Backend
+
+AI-powered medical image analysis backend using TensorFlow and LinkNet model for video capsule endoscopy image segmentation.

app.py

@@ -0,0 +1,62 @@
+from flask import Flask, request, jsonify, send_from_directory
+from werkzeug.utils import secure_filename
+from flask_cors import CORS  # Import Flask-CORS
+import os
+import sys
+
+print("Starting Flask app...", file=sys.stderr)
+print("Loading model...", file=sys.stderr)
+
+from modddel import model
+from predict import read_image_
+from predict import display_segmentation
+from PIL import Image
+from modddel import np
+
+print("Model loaded successfully!", file=sys.stderr)
+
+app = Flask(__name__)
+CORS(app)  # Enable CORS for your Flask app
+
+# Define the upload folder
+UPLOAD_FOLDER = 'uploads'
+app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
+
+# Ensure the upload folder exists
+if not os.path.exists(UPLOAD_FOLDER):
+    os.makedirs(UPLOAD_FOLDER)
+
+@app.route('/', methods=['GET'])
+def health_check():
+    return jsonify({'status': 'healthy', 'message': 'VCE Backend API is running'}), 200
+
+@app.route('/upload', methods=['POST'])
+def upload_file():
+    try:
+        # Check if the 'image' file is in the request
+        if 'image' not in request.files:
+            return jsonify({'error': 'No file part'})
+
+        # Access the uploaded file from the request
+        image_file = request.files['image']
+
+        # Save the uploaded file to the upload folder
+        filename = secure_filename(image_file.filename)
+        file_path = os.path.join(app.config['UPLOAD_FOLDER'], filename)
+        image_file.save(file_path)
+        img=display_segmentation(file_path,model)
+        img_clipped = np.clip(img, 0, 1)
+        Image.fromarray((img_clipped * 255).astype(np.uint8)).save(file_path)
+        # Return the relative path to the saved file
+        return jsonify({'file_name': filename}), 200
+
+    except Exception as e:
+        return jsonify({'error': str(e)}), 400
+
+@app.route('/uploads/<filename>')
+def uploaded_file(filename):
+    return send_from_directory(app.config['UPLOAD_FOLDER'], filename)
+
+if __name__ == '__main__':
+    port = int(os.environ.get('PORT', 5000))
+    app.run(host='0.0.0.0', port=port, debug=False)

linknet_test.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2cd5dc70486097b7f67ac4576c811fb22b9a40adece95a135482762716c24b63
+size 30012056

main.py

@@ -0,0 +1,6 @@
+def main():
+    print("Hello from backend!")
+
+
+if __name__ == "__main__":
+    main()

modddel.py

@@ -0,0 +1,105 @@
+import numpy as np  # still fine if you use it elsewhere
+import tensorflow as tf
+from tensorflow import keras
+from tensorflow.keras.layers import (
+    Activation,
+    Add,
+    BatchNormalization,
+    Concatenate,
+    Conv2D,
+    Input,
+    MaxPooling2D,
+    UpSampling2D,
+)
+from tensorflow.keras.models import Model
+
+
+def conv_block(inputs, filters, kernel_size=3, strides=1):
+    x = Conv2D(filters, kernel_size, strides=strides, padding="same")(inputs)
+    x = BatchNormalization()(x)
+    x = Activation("relu")(x)
+    return x
+
+
+def encoder_block(inputs, filters, kernel_size=3, strides=1):
+    x = conv_block(inputs, filters, kernel_size, strides)
+    x = conv_block(x, filters, kernel_size, 1)
+    shortcut = Conv2D(filters, kernel_size=1, strides=strides, padding="same")(inputs)
+    shortcut = BatchNormalization()(shortcut)
+    x = Add()([x, shortcut])
+    x = Activation("relu")(x)
+    return x
+
+
+def decoder_block(inputs, filters, kernel_size=3, strides=1):
+    x = UpSampling2D(size=(2, 2))(inputs)
+    x = conv_block(x, filters, kernel_size, 1)
+    x = conv_block(x, filters, kernel_size, 1)
+    shortcut = UpSampling2D(size=(2, 2))(inputs)
+    shortcut = Conv2D(filters, kernel_size=1, strides=1, padding="same")(shortcut)
+    shortcut = BatchNormalization()(shortcut)
+    x = Add()([x, shortcut])
+    x = Activation("relu")(x)
+    return x
+
+
+def linknet(input_shape=(224, 224, 3), num_classes=1):
+    inputs = Input(shape=input_shape)
+
+    # Encoder
+    enc1 = encoder_block(inputs, 64, strides=2)
+    enc2 = encoder_block(enc1, 128, strides=2)
+    enc3 = encoder_block(enc2, 256, strides=2)
+    enc4 = encoder_block(enc3, 512, strides=2)
+
+    # Decoder
+    dec4 = decoder_block(enc4, 256, strides=2)
+    dec3 = decoder_block(dec4, 128, strides=2)
+    dec2 = decoder_block(dec3, 64, strides=2)
+    dec1 = decoder_block(dec2, 64, strides=2)
+
+    outputs = Conv2D(num_classes, (1, 1), activation="sigmoid")(dec1)
+
+    model = Model(inputs, outputs)
+    return model
+
+
+@keras.utils.register_keras_serializable()
+def iou(y_true, y_pred):
+    # ensure predictions are in [0, 1]; clamp if needed
+    y_pred = tf.clip_by_value(y_pred, 0.0, 1.0)
+
+    # intersection and union
+    intersection = tf.reduce_sum(y_true * y_pred)
+    union = tf.reduce_sum(y_true) + tf.reduce_sum(y_pred) - intersection
+
+    return (intersection + 1e-15) / (union + 1e-15)
+
+
+@keras.utils.register_keras_serializable()
+def dice_coefficient(y_true, y_pred, smooth=1.0):
+    y_pred = tf.clip_by_value(y_pred, 0.0, 1.0)
+    intersection = tf.reduce_sum(y_true * y_pred)
+    union = tf.reduce_sum(y_true) + tf.reduce_sum(y_pred)
+    dice = (2.0 * intersection + smooth) / (union + smooth)
+    return dice
+
+
+@keras.utils.register_keras_serializable()
+def dice_coefficient_loss(y_true, y_pred):
+    return 1.0 - dice_coefficient(y_true, y_pred)
+
+
+lr = 1e-4
+model = linknet()
+opt = tf.keras.optimizers.Adam(learning_rate=lr)
+metrics = [
+    "acc",
+    tf.keras.metrics.Recall(),
+    tf.keras.metrics.Precision(),
+    iou,
+    dice_coefficient,
+]
+model.compile(loss="binary_crossentropy", optimizer=opt, metrics=metrics)
+
+model.load_weights("linknet_test.h5")

model_infer.py

@@ -0,0 +1,33 @@
+import pickle
+from predict import cv2
+from predict import read_image_
+from predict import plt
+from modddel import np
+with open('model.pkl', 'rb') as f:
+    model = pickle.load(f)
+
+def display_segmentation(image_path, model):
+    # Read image
+    x = read_image_(image_path)
+
+    # Predict mask
+    y_pred = model.predict(np.expand_dims(x, axis=0))[0] > 0.5
+    y_pred = cv2.resize(y_pred.astype(np.uint8), (x.shape[1], x.shape[0]))
+
+    # Create overlay with original image
+    overlay = x.copy()
+
+    # Highlight the boundary of the affected area
+    contours, _ = cv2.findContours(y_pred, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    cv2.drawContours(overlay, contours, -1, (255, 255, 255), thickness=1)  # Change color to white and reduce thickness
+
+    return overlay
+
+# Example usage:
+image_path = "img- (1).png"
+segmentation_overlay = display_segmentation(image_path, model)
+
+# Display the resulting image with segmentation overlay
+plt.imshow(segmentation_overlay)
+plt.title("Segmentation Overlay")
+plt.show()

predict.py

@@ -0,0 +1,39 @@
+from modddel import model
+
+import numpy as np
+import cv2
+
+
+def read_image_(path):
+     #path=path.decode()
+     x = cv2.imread(path)
+     #print(x)
+     x = cv2.cvtColor(x, cv2.COLOR_BGR2RGB)
+     x = cv2.resize(x, (224, 224))
+     x = x/255.0
+     return x
+
+def display_segmentation(image_path, model):
+    # Read image
+    x = read_image_(image_path)
+
+    # Predict mask
+    y_pred = model.predict(np.expand_dims(x, axis=0))[0] > 0.5
+    y_pred = cv2.resize(y_pred.astype(np.uint8), (x.shape[1], x.shape[0]))
+
+    # Create overlay with original image
+    overlay = x.copy()
+
+    # Highlight the boundary of the affected area
+    contours, _ = cv2.findContours(y_pred, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    cv2.drawContours(overlay, contours, -1, (255, 255, 255), thickness=1)  # Change color to white and reduce thickness
+
+    # Blend the overlay with original image using alpha value for a whitish shade
+    alpha = 0.3  # Set the alpha value for transparency (adjust as needed)
+    cv2.addWeighted(overlay, alpha, x, 1 - alpha, 0, x)
+
+    # Display the image with segmentation overlay
+    return x
+
+
+

pyproject.toml

@@ -0,0 +1,14 @@
+[project]
+name = "backend"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "flask>=3.1.2",
+    "flask-cors>=6.0.1",
+    "numpy==1.21.3",
+    "opencv-python>=4.6.0.66",
+    "pillow>=12.0.0",
+    "tensorflow==2.10.1",
+]

render.yaml

@@ -0,0 +1,13 @@
+services:
+  - type: web
+    name: ai-vce-backend
+    env: python
+    buildCommand: "pip install -r requirements.txt"
+    startCommand: "gunicorn app:app --bind 0.0.0.0:$PORT --timeout 180 --workers 1 --preload"
+    envVars:
+      - key: PYTHON_VERSION
+        value: 3.10.15
+    disk:
+      name: uploads-disk
+      mountPath: /opt/render/project/src/uploads
+      sizeGB: 1

requirements.txt

@@ -0,0 +1,23 @@
+
+# Core ML stack
+tensorflow==2.10.1
+keras==2.10.0
+numpy==1.23.5
+h5py==3.7.0
+
+# Computer Vision
+opencv-python-headless==4.10.0.84
+Pillow==10.4.0
+
+# Scientific utilities
+matplotlib==3.7.4
+scipy==1.10.1
+
+# Flask Backend
+Flask==3.0.0
+flask-cors==4.0.0
+Werkzeug==3.0.1
+gunicorn==21.2.0
+
+# Image handling
+scikit-image==0.22.0

uploads/.gitkeep

@@ -0,0 +1 @@
+# Keep this directory in git but ignore its contents