Upload 10 files

.gitattributes

@@ -0,0 +1 @@
+best.pt filter=lfs diff=lfs merge=lfs -text

.gitattributes.txt

@@ -0,0 +1,4 @@
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text

README.md.md

@@ -0,0 +1,65 @@
+# YOLOv9 Card Detector
+
+This model is a fine-tuned version of YOLOv9c trained to detect playing cards in images. It has been trained on the Set Cards dataset from Roboflow.
+
+## Model Details
+
+- **Base Model**: YOLOv9c
+- **Task**: Object Detection
+- **Target Class**: Cards
+- **Training Dataset**: [Set Cards Dataset](https://universe.roboflow.com/tel-aviv/set_cards/dataset/1)
+- **Image Size**: 512x512
+- **Accuracy Metrics**: Evaluated at confidence threshold of 0.5
+
+## Usage
+
+```python
+from transformers import AutoImageProcessor, AutoModelForObjectDetection
+import torch
+from PIL import Image
+import requests
+
+# Load model and processor
+processor = AutoImageProcessor.from_pretrained("YOUR_USERNAME/yolov9-card-detector")
+model = AutoModelForObjectDetection.from_pretrained("YOUR_USERNAME/yolov9-card-detector")
+
+# Load image
+image_url = "https://example.com/path/to/card_image.jpg"
+image = Image.open(requests.get(image_url, stream=True).raw)
+
+# Prepare image for the model
+inputs = processor(images=image, return_tensors="pt")
+
+# Make prediction
+with torch.no_grad():
+    outputs = model(**inputs)
+
+# Process results
+results = processor.post_process_object_detection(
+    outputs,
+    threshold=0.5,
+    target_sizes=[(image.height, image.width)]
+)[0]
+
+# Display results
+for score, label, box in zip(results["scores"], results["labels"], results["boxes"]):
+    box = [round(i, 2) for i in box.tolist()]
+    print(
+        f"Detected {model.config.id2label[label.item()]} with confidence "
+        f"{round(score.item(), 3)} at location {box}"
+    )
+```
+
+## Training
+
+This model was fine-tuned from YOLOv9c using the Ultralytics framework. It was trained for 30 epochs with an image size of 512x512.
+
+## License
+
+This model is licensed under CC BY 4.0, following the dataset's licensing terms.
+
+## Limitations
+
+- The model is specifically trained to detect playing cards and may not perform well on other objects
+- Performance may vary based on lighting conditions, card orientation, and image quality
+- Best results are achieved with images similar to those in the training dataset

app.py

@@ -0,0 +1,94 @@
+import io
+import torch
+import cv2
+import base64
+import numpy as np
+from PIL import Image
+from ultralytics import YOLO
+from transformers import AutoImageProcessor
+from datasets import Image as HFImage
+
+def overlay_boxes(image, boxes, scores, labels, class_names, conf_threshold=0.5):
+    """Draw bounding boxes on the image with labels and scores"""
+    img = np.array(image.copy())
+    colors = {0: (0, 255, 0)}  # Green for card class
+    
+    for box, score, label in zip(boxes, scores, labels):
+        if score >= conf_threshold:
+            x1, y1, x2, y2 = map(int, box)
+            label_text = f"{class_names[int(label)]}: {score:.2f}"
+            color = colors.get(int(label), (255, 0, 0))
+            cv2_image = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
+            cv2.rectangle(cv2_image, (x1, y1), (x2, y2), color, 2)
+            cv2.putText(cv2_image, label_text, (x1, y1 - 10), 
+                        cv2.FONT_HERSHEY_SIMPLEX, 0.9, color, 2)
+            img = cv2.cvtColor(cv2_image, cv2.COLOR_BGR2RGB)
+    
+    return Image.fromarray(img)
+
+class YOLOv9CardDetector:
+    def __init__(self):
+        self.model = YOLO("best.pt")
+        self.config = {
+            "class_names": ["card"],
+            "conf_threshold": 0.5
+        }
+        self.image_processor = AutoImageProcessor.from_pretrained(".")
+        
+    def __call__(self, inputs):
+        """Process input for the Hugging Face inference API"""
+        if isinstance(inputs, HFImage):
+            image = inputs.convert("RGB")
+        else:
+            if isinstance(inputs, dict) and "image" in inputs:
+                # Handle API input format
+                image = inputs["image"]
+                if isinstance(image, str):
+                    image = Image.open(io.BytesIO(base64.b64decode(image)))
+            else:
+                image = inputs
+        
+        # Get predictions from YOLOv9 model
+        with torch.no_grad():
+            results = self.model(image)
+        
+        # Process results
+        result = results[0]
+        boxes = result.boxes.xyxy.cpu().numpy()
+        scores = result.boxes.conf.cpu().numpy()
+        labels = result.boxes.cls.cpu().numpy()
+        
+        # Format the output for Hugging Face inference API
+        output = {
+            "boxes": boxes.tolist(),
+            "scores": scores.tolist(),
+            "labels": labels.tolist(),
+            "class_names": self.config["class_names"]
+        }
+        
+        # If image is provided, also return an annotated image
+        try:
+            import cv2
+            annotated_image = overlay_boxes(
+                image, 
+                boxes, 
+                scores, 
+                labels, 
+                self.config["class_names"], 
+                self.config["conf_threshold"]
+            )
+            buffered = io.BytesIO()
+            annotated_image.save(buffered, format="JPEG")
+            output["annotated_image"] = buffered.getvalue()
+        except ImportError:
+            # If cv2 is not available, skip image annotation
+            pass
+        
+        return output
+
+# Initialize the model at module level for faster inference
+detector = YOLOv9CardDetector()
+
+def run_inference(inputs):
+    """Entry point for the model"""
+    return detector(inputs)

best.pt

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

config.json.json

@@ -0,0 +1,18 @@
+{
+  "architectures": ["YOLOv9"],
+  "model_type": "yolov9",
+  "backbone": "yolov9c",
+  "num_classes": 1,
+  "class_names": ["card"],
+  "image_size": [512, 512],
+  "threshold": 0.5,
+  "version": "YOLOv9c",
+  "training": {
+    "epochs": 30,
+    "batch_size": 16,
+    "optimizer": "SGD"
+  },
+  "source": "fine-tuned from ultralytics/yolov9c",
+  "license": "CC BY 4.0",
+  "dataset": "https://universe.roboflow.com/tel-aviv/set_cards/dataset/1"
+}

data.yaml

@@ -0,0 +1,12 @@
+names:
+- 'card'
+nc: 1
+roboflow:
+  license: CC BY 4.0
+  project: set_cards
+  url: https://universe.roboflow.com/tel-aviv/set_cards/dataset/1
+  version: 1
+  workspace: tel-aviv
+test: ../test/images
+train: /content/SETCARDSBATCH-3/train/images
+val: /content/SETCARDSBATCH-3/valid/images

inference.py

@@ -0,0 +1,89 @@
+from ultralytics import YOLO
+import numpy as np
+from PIL import Image
+import io
+import base64
+import torch
+
+def hf_predict(image_bytes):
+    """
+    Inference function for Hugging Face Inference API
+    
+    Args:
+        image_bytes: Image file bytes from a POST request
+        
+    Returns:
+        dict: Detection results in a format compatible with the Inference API
+    """
+    # Load image
+    image = Image.open(io.BytesIO(image_bytes)).convert('RGB')
+    
+    # Load model
+    model = YOLO('best.pt')
+    
+    # Run inference
+    results = model(image)
+    
+    # Process results
+    result = results[0]
+    boxes = result.boxes.xyxy.cpu().numpy()
+    scores = result.boxes.conf.cpu().numpy()
+    class_ids = result.boxes.cls.cpu().numpy()
+    
+    # Map class IDs to names
+    class_names = ["card"]
+    labels = [class_names[int(i)] for i in class_ids]
+    
+    # Format results
+    detections = []
+    for box, score, label in zip(boxes, scores, labels):
+        x1, y1, x2, y2 = box
+        detections.append({
+            "box": {
+                "xmin": int(x1),
+                "ymin": int(y1),
+                "xmax": int(x2),
+                "ymax": int(y2)
+            },
+            "score": float(score),
+            "label": label
+        })
+    
+    return {"detections": detections}
+
+def visualize(image_bytes, detections):
+    """
+    Visualize the detections on the image
+    
+    Args:
+        image_bytes: Image file bytes
+        detections: Detection results
+        
+    Returns:
+        str: Base64 encoded image with visualizations
+    """
+    try:
+        import cv2
+        
+        # Load image
+        nparr = np.frombuffer(image_bytes, np.uint8)
+        image = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
+        
+        # Draw boxes
+        for det in detections["detections"]:
+            box = det["box"]
+            score = det["score"]
+            label = det["label"]
+            
+            x1, y1 = box["xmin"], box["ymin"]
+            x2, y2 = box["xmax"], box["ymax"]
+            
+            cv2.rectangle(image, (x1, y1), (x2, y2), (0, 255, 0), 2)
+            cv2.putText(image, f"{label}: {score:.2f}", (x1, y1 - 10),
+                        cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
+        
+        # Convert to base64
+        _, buffer = cv2.imencode('.jpg', image)
+        return base64.b64encode(buffer).decode('utf-8')
+    except:
+        return None

model-card.yaml.txt

@@ -0,0 +1,22 @@
+---
+license: cc-by-4.0
+base_model: ultralytics/yolov9c
+tags:
+  - object-detection
+  - yolo
+  - yolov9
+  - computer-vision
+  - cards
+  - image-classification
+  - pytorch
+  - ultralytics
+datasets:
+  - tel-aviv/set_cards
+widgets:
+  - task: object-detection
+    inputs:
+      - type: image
+        name: image
+        placeholder: Upload an image of playing cards
+        required: true
+---

preprocessor_config.json.json

@@ -0,0 +1,15 @@
+{
+  "image_processor_type": "YoloImageProcessor",
+  "size": {
+    "height": 512,
+    "width": 512
+  },
+  "do_normalize": true,
+  "do_resize": true,
+  "do_rescale": true,
+  "rescale_factor": 0.00392156862745098,
+  "do_pad": true,
+  "padding_value": 114,
+  "format": "pytorch",
+  "do_convert_rgb": true
+}

requirements.txt.txt

@@ -0,0 +1,7 @@
+torch>=2.0.0
+torchvision>=0.15.0
+numpy>=1.24.0
+opencv-python>=4.7.0
+ultralytics>=8.1.0
+transformers>=4.35.0
+pillow>=9.5.0