Upload 4 files

Dockerfile

@@ -40,9 +40,12 @@ RUN mkdir -p /tmp/huggingface/hub && mkdir -p /tmp/huggingface/transformers && c
 
 RUN python -m pip install gradio>=4.0.0
 RUN python -m pip install supervision
+RUN python -m pip install timm
+
 # Your app
 WORKDIR /app
-COPY app.py /app/
+#COPY app.py /app/
+COPY . . 
 
 EXPOSE 7860
 ENV PORT=7860

README.md

@@ -1,5 +1,5 @@
 ---
-title: BAT102
+title: Cure
 emoji: 🔥
 colorFrom: green
 colorTo: green

app.py

@@ -1,7 +1,7 @@
-import io, os, sys
+import io, os, sys                
 from typing import List, Tuple
 from PIL import Image, ImageDraw, ImageFont
-#from transformers import pipeline 
+from transformers import pipeline 
 from huggingface_hub import snapshot_download
 #import transformers
 import pprint
@@ -19,131 +19,37 @@ import supervision as sv
 #import mmcv
 from mmdet.apis import inference_detector
 import numpy as np
-from supervision import Detections 
-from typing import List, Dict, Union, Optional
+from supervision import Detections
+from typing import List, Dict, Union, Optional                 
+from transformers import (
+    AutoConfig, AutoModelForObjectDetection, AutoImageProcessor, pipeline
+)
 
-CONFIDENCE_THRESHOLD = 0.5
+CONFIDENCE_THRESHOLD = 0.5   
 NMS_IOU_THRESHOLD = 0.5
 
-# 1) build model from config
-repo_dir = snapshot_download(repo_id="haiquanua/weed_swin")
 
-cfg = Config.fromfile(f"{repo_dir}/configs/mmdet_swin_config.py", lazy_import=False)
-register_all_modules()
-detector = MODELS.build(cfg.model) #this does not work in mmcv v2
-
-# 2) load safetensors weights
-state_dict = load_file(f"{repo_dir}/model.safetensors")  # strictly tensors only
-missing, unexpected = detector.load_state_dict(state_dict, strict=False)
-print("missing:", len(missing), "unexpected:", len(unexpected))
-detector.eval()
-detector.cfg = cfg
-
-repo_dir = os.path.join(os.path.dirname(__file__), "../weed_swin")
-sys.path.insert(0, repo_dir)
-#import pipeline
-# Load an object-detection pipeline (pick any model you like)
 #detector = pipeline("object-detection", model="facebook/detr-resnet-50")
-#detector = pipeline("object-detection", model="haiquanua/weed_detectron2")
 #detector = pipeline("object-detection", model="haiquanua/weed_detr")
-#repo_dir = snapshot_download("haiquanua/weed_swin")
-pprint.pp(sorted(PIPELINE_REGISTRY.get_supported_tasks()))
-#detector = pipeline(task="mmdet-detection", model="weed_swin", trust_remote_code=True)
-class_names={0:"weed", 1:"letuce", 2:"spinach"}
-
-def _to_hf_items_from_sv(
-    det: "Detections",
-    class_names: List[str],
-    score_threshold: Optional[float] = None,
-    top_k: Optional[int] = None,
-    clip_shape: Optional[tuple] = None,  # (H, W)
-) -> List[Dict]:
-    """
-    Convert a single `supervision.Detections` to HF object-detection items.
-    Parameters
-    ----------
-    det : supervision.Detections
-        Expected fields: det.xyxy (N, 4), det.class_id (N,), optional det.confidence (N,)
-    class_names : list[str]
-        Maps numeric class_id -> human-readable label.
-    score_threshold : float, optional
-        Keep only detections with confidence >= threshold. If det.confidence is None, ignored.
-    top_k : int, optional
-        Keep only the top_k by confidence (if available), else by input order.
-    clip_shape : (H, W), optional
-        If provided, clip boxes to [0, W] x [0, H].
-    """
-    xyxy = np.asarray(det.xyxy, dtype=float) if hasattr(det, "xyxy") else None
-    class_id = np.asarray(det.class_id, dtype=int) if hasattr(det, "class_id") else None
-    conf = getattr(det, "confidence", None)
-    conf = np.asarray(conf, dtype=float) if conf is not None else None
-
-    if xyxy is None or class_id is None:
-        raise ValueError("Detections must have 'xyxy' and 'class_id' fields.")
-
-    n = xyxy.shape[0]
-    idx = np.arange(n)
-
-    # Threshold by confidence if available
-    if conf is not None and score_threshold is not None:
-        idx = idx[(conf[idx] >= score_threshold)]
-
-    # Top-k (sort by confidence if present)
-    if top_k is not None:
-        if conf is not None:
-            order = np.argsort(-conf[idx])
-            idx = idx[order][:top_k]
-        else:
-            idx = idx[:top_k]
-
-    # Clip boxes if requested
-    if clip_shape is not None:
-        H, W = clip_shape
-        xyxy_clipped = xyxy.copy()
-        xyxy_clipped[:, 0] = np.clip(xyxy_clipped[:, 0], 0, W)  # xmin
-        xyxy_clipped[:, 2] = np.clip(xyxy_clipped[:, 2], 0, W)  # xmax
-        xyxy_clipped[:, 1] = np.clip(xyxy_clipped[:, 1], 0, H)  # ymin
-        xyxy_clipped[:, 3] = np.clip(xyxy_clipped[:, 3], 0, H)  # ymax
-        xyxy = xyxy_clipped
-
-    out = []
-    for i in idx:
-        cid = int(class_id[i])
-        lbl = class_names[cid] if 0 <= cid < len(class_names) else str(cid)
-        score = float(conf[i]) if conf is not None else 1.0
-        x1, y1, x2, y2 = [float(v) for v in xyxy[i]]
-        out.append(
-            {
-                "score": score,
-                "label": lbl,
-                "box": {"xmin": x1, "ymin": y1, "xmax": x2, "ymax": y2},
-            }
-        )
-    return out
-
-
-def supervision_to_hf(
-    results: Union["Detections", List["Detections"]],
-    class_names: List[str],
-    score_threshold: Optional[float] = None,
-    top_k: Optional[int] = None,
-    clip_shape: Optional[tuple] = None,  # (H, W)
-):
-    """
-    Convert supervision results (single or list) to HF object-detection format.
-    Returns
-    -------
-    list[dict] for a single Detections input,
-    list[list[dict]] for a list (batch) input.
-    """
-    if isinstance(results, list):
-        batch_out = [
-            _to_hf_items_from_sv(d, class_names, score_threshold, top_k, clip_shape)
-            for d in results
-        ]
-        return batch_out
-    else:
-        return _to_hf_items_from_sv(results, class_names, score_threshold, top_k, clip_shape)
+
+repo_path="haiquanua/weed_swin"
+
+model = AutoModelForObjectDetection.from_pretrained(
+    repo_path, trust_remote_code=True
+)
+#print("Model class:", type(model).__name__)  # expect: MmdetBridge
+
+ip = AutoImageProcessor.from_pretrained(
+    repo_path, trust_remote_code=True
+)
+#print("Processor class:", type(ip).__name__)  # expect: MmdetImageProcessor
+
+#detector = pipeline(task="mmdet-detection", model=repo_path, trust_remote_code=True)
+detector = pipeline(task="object-detection", model=model, image_processor=ip, trust_remote_code=True)
+
+num_head_params = sum(p.numel() for n,p in detector.model.named_parameters() if 'roi_head' in n or 'rpn_head' in n)
+print("roi/rpn params after pipeline setup:", num_head_params)
+
     
 def draw_boxes(im: Image.Image, preds, threshold: float = 0.25, class_map={"LABEL_0":"Weed", "LABEL_1":"lettuce","LABEL_2":"Spinach"}) -> Image.Image:
     """Draw bounding boxes + labels on a PIL image."""
@@ -190,20 +96,13 @@ def detect_multiple(images: List[Image.Image], threshold: float = 0.25) -> List[
     suitable for gr.Gallery. Each image is annotated with boxes.
     """
     outputs = []
-    # Batch through the HF pipeline (it accepts lists)
-    #results = detector(images)  # list of lists of predictions
-   
-    #print(images)
-    results = inference_detector(detector, np.array(images)[:, :, ::-1])
-
-    print("\nRaw Predictions (pred_instances):")
-    #print(result)
-
-    results = sv.Detections.from_mmdetection(results)
-    results = results[results.confidence > CONFIDENCE_THRESHOLD].with_nms(threshold=NMS_IOU_THRESHOLD)
-    #print(results)
-    results = supervision_to_hf(results, class_names, score_threshold=CONFIDENCE_THRESHOLD, top_k=100, clip_shape=None)
+    if detector is None:
+        gr.Error("detector is empty")
+    #else:
+    #    gr.Info(f"dector is {type(detector).__name__}")
+    results = detector(images, threshold=threshold)  # list of lists of predictions
     #print(results)
+    #gr.Info("get results")
     if not isinstance(images, list):
         annotated = draw_boxes(images.copy(), results, threshold)
         outputs.append(annotated)
@@ -236,7 +135,12 @@ with gr.Blocks(title="Multi-Image Object Detection") as demo:
 
     gr.Markdown("Tip: You can drag-select multiple files in the picker or paste from clipboard.")
 
-print("finished blocks setting")
+gr.Info(detector.__dict__)
+gr.Info("finished blocks setting")
 
+#image=Image.open(Path(__file__).resolve().parent / "test.jpg")
+#print(image.size)
+#results = detector(image, padding=True, threshold=0.0)
+#print("final results", results)
 demo.queue(max_size=16).launch(server_name="0.0.0.0",server_port=7860, share=False, show_error=True)
 

gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+test.jpg filter=lfs diff=lfs merge=lfs -text