init

Dockerfile

@@ -0,0 +1,17 @@
+# Read the doc: https://huggingface.co/docs/hub/spaces-sdks-docker
+# you will also find guides on how best to write your Dockerfile
+
+
+FROM python:3.10
+RUN apt-get update && apt-get install -y libgl1-mesa-glx
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+COPY --chown=user . /app
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

app.py

@@ -0,0 +1,67 @@
+from fastapi import FastAPI, UploadFile
+from ultralytics import YOLO
+import io
+from PIL import Image
+import numpy as np
+import os
+from huggingface_hub import hf_hub_download
+from ultralytics import YOLO
+import requests
+import supervision as sv
+
+
+def init_model(model_id: str):
+    # Define models
+    MODEL_OPTIONS = {
+        "YOLOv11-Nano": "medieval-yolov11n.pt",
+        "YOLOv11-Small": "medieval-yolov11s.pt",
+        "YOLOv11-Medium": "medieval-yolov11m.pt",
+        "YOLOv11-Large": "medieval-yolov11l.pt",
+        "YOLOv11-XLarge": "medieval-yolov11x.pt"
+    }
+    if model_id in MODEL_OPTIONS:
+        model_path = hf_hub_download(
+            repo_id="biglam/medieval-manuscript-yolov11",
+            filename=MODEL_OPTIONS[model_id]
+        )
+        return YOLO(model_path)
+    else:
+        raise ValueError(f"Model {model_id} not found")
+
+app = FastAPI()
+
+
+@app.post("/predict")
+async def predict(image: UploadFile,
+                  model_id: str = "YOLOv11-XLarge",
+                  conf: float = 0.25,
+                  iou: float = 0.7
+                  ):
+    # Initialize model at startup
+    model = init_model(model_id)
+    
+    # Download and open image from URL
+    image = Image.open(image.file)
+    
+    # Run inference with the PIL Image
+    results = model.predict(source=image, conf=conf, iou=iou)
+    
+    # Extract detection results
+    result = results[0]
+    # print(result)
+    detections = []
+    
+    for box in result.boxes:
+        detection = {
+            "class": result.names[int(box.cls[0])],
+            "confidence": float(box.conf[0]),
+            "bbox": box.xyxy[0].tolist()  # Convert bbox tensor to list
+        }
+        detections.append(detection)
+    print(detections)
+
+    return {"detections": detections}
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)

gradio-app.py

@@ -0,0 +1,145 @@
+from typing import Tuple, Dict
+import gradio as gr
+import supervision as sv
+import numpy as np
+from PIL import Image
+from huggingface_hub import hf_hub_download
+from ultralytics import YOLO
+
+# Define models
+MODEL_OPTIONS = {
+    "YOLOv11-Nano": "medieval-yolov11n.pt",
+    "YOLOv11-Small": "medieval-yolov11s.pt",
+    "YOLOv11-Medium": "medieval-yolov11m.pt",
+    "YOLOv11-Large": "medieval-yolov11l.pt",
+    "YOLOv11-XLarge": "medieval-yolov11x.pt"
+}
+
+# Dictionary to store loaded models
+models: Dict[str, YOLO] = {}
+
+# Load all models
+for name, model_file in MODEL_OPTIONS.items():
+    model_path = hf_hub_download(
+        repo_id="biglam/medieval-manuscript-yolov11",
+        filename=model_file
+    )
+    models[name] = YOLO(model_path)
+
+# Create annotators
+LABEL_ANNOTATOR = sv.LabelAnnotator(text_color=sv.Color.BLACK)
+BOX_ANNOTATOR = sv.BoxAnnotator()
+
+def detect_and_annotate(
+    image: np.ndarray,
+    model_name: str,
+    conf_threshold: float,
+    iou_threshold: float
+) -> np.ndarray:
+    # Get the selected model
+    model = models[model_name]
+    
+    # Perform inference
+    results = model.predict(
+        image,
+        conf=conf_threshold,
+        iou=iou_threshold
+    )[0]
+    
+    # Convert results to supervision Detections
+    boxes = results.boxes.xyxy.cpu().numpy()
+    confidence = results.boxes.conf.cpu().numpy()
+    class_ids = results.boxes.cls.cpu().numpy().astype(int)
+    
+    # Create Detections object
+    detections = sv.Detections(
+        xyxy=boxes,
+        confidence=confidence,
+        class_id=class_ids
+    )
+    
+    # Create labels with confidence scores
+    labels = [
+        f"{results.names[class_id]} ({conf:.2f})"
+        for class_id, conf
+        in zip(class_ids, confidence)
+    ]
+
+    # Annotate image
+    annotated_image = image.copy()
+    annotated_image = BOX_ANNOTATOR.annotate(scene=annotated_image, detections=detections)
+    annotated_image = LABEL_ANNOTATOR.annotate(scene=annotated_image, detections=detections, labels=labels)
+    
+    return annotated_image
+
+# Create Gradio interface
+with gr.Blocks() as demo:
+    gr.Markdown("# Medieval Manuscript Detection with YOLO")
+    
+    with gr.Row():
+        with gr.Column():
+            input_image = gr.Image(
+                label="Input Image",
+                type='numpy'
+            )
+            with gr.Accordion("Detection Settings", open=True):
+                model_selector = gr.Dropdown(
+                    choices=list(MODEL_OPTIONS.keys()),
+                    value=list(MODEL_OPTIONS.keys())[0],
+                    label="Model",
+                    info="Select YOLO model variant"
+                )
+                with gr.Row():
+                    conf_threshold = gr.Slider(
+                        label="Confidence Threshold",
+                        minimum=0.0,
+                        maximum=1.0,
+                        step=0.05,
+                        value=0.25,
+                    )
+                    iou_threshold = gr.Slider(
+                        label="IoU Threshold",
+                        minimum=0.0,
+                        maximum=1.0,
+                        step=0.05,
+                        value=0.45,
+                        info="Decrease for stricter detection, increase for more overlapping boxes"
+                    )
+            with gr.Row():
+                clear_btn = gr.Button("Clear")
+                detect_btn = gr.Button("Detect", variant="primary")
+                
+        with gr.Column():
+            output_image = gr.Image(
+                label="Detection Result",
+                type='numpy'
+            )
+
+    def process_image(
+        image: np.ndarray,
+        model_name: str,
+        conf_threshold: float,
+        iou_threshold: float
+    ) -> Tuple[np.ndarray, np.ndarray]:
+        if image is None:
+            return None, None
+        annotated_image = detect_and_annotate(image, model_name, conf_threshold, iou_threshold)
+        return image, annotated_image
+
+    def clear():
+        return None, None
+
+    # Connect buttons to functions
+    detect_btn.click(
+        process_image,
+        inputs=[input_image, model_selector, conf_threshold, iou_threshold],
+        outputs=[input_image, output_image]
+    )
+    clear_btn.click(
+        clear,
+        inputs=None,
+        outputs=[input_image, output_image]
+    )
+
+if __name__ == "__main__":
+    demo.launch(debug=True, show_error=True)

requirements.txt

@@ -0,0 +1,5 @@
+ultralytics
+huggingface-hub
+supervision
+requests
+fastapi

test.py

@@ -0,0 +1,24 @@
+import requests
+
+# Path to your image
+image_path = "/Users/wjm55/yale/weaviate-test/yolov11_output/valid/images/Paris_BnF_Velins_611_00003.jpg"
+
+# Open the image file
+with open(image_path, 'rb') as f:
+    # Create the files parameter for the POST request
+    files = {'image': f}
+    
+    # Optional parameters (using defaults from the API)
+    params = {
+        'model_id': 'YOLOv11-XLarge',  # default model
+        'conf': 0.25,                   # confidence threshold
+        'iou': 0.7                      # IoU threshold
+    }
+
+    # Send POST request to the endpoint
+    response = requests.post('http://localhost:7860/predict', 
+                           files=files,
+                           params=params)
+
+# Print the results
+print(response.json())