File size: 4,817 Bytes
693bf28 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 | """Test Sliced Patch Inference (SAHI) on a sample of images to verify detection recall across classes."""
import os
from pathlib import Path
import torch
import torchvision
from torchvision.ops import nms
import numpy as np
from PIL import Image
cache_dir = Path("data/cache").resolve()
cache_dir.mkdir(parents=True, exist_ok=True)
os.environ["TORCH_HOME"] = str(cache_dir)
os.environ["HF_HOME"] = str(cache_dir)
from ultralytics import YOLOWorld
CLASS_NAMES = [
"cpu_socket",
"gold_finger",
"ic_chip",
"tantalum_capacitor",
"forcibly_desoldered_pad",
"factory_unpopulated_pad",
"occluded_region",
]
CLASS_PROMPTS = [
"CPU socket",
"gold finger edge connector",
"microchip",
"tantalum capacitor",
"desoldered solder pad",
"unpopulated solder pad",
"heatsink shield",
]
def apply_nms(boxes_list: list, iou_threshold: float = 0.45) -> list:
if not boxes_list:
return []
boxes_t = torch.tensor([b[:4] for b in boxes_list], dtype=torch.float32)
scores_t = torch.tensor([b[4] for b in boxes_list], dtype=torch.float32)
cls_t = torch.tensor([b[5] for b in boxes_list], dtype=torch.int64)
keep_indices = []
unique_classes = torch.unique(cls_t)
for c in unique_classes:
c_mask = (cls_t == c)
c_idxs = torch.where(c_mask)[0]
c_boxes = boxes_t[c_idxs]
c_scores = scores_t[c_idxs]
c_keep = nms(c_boxes, c_scores, iou_threshold)
keep_indices.extend(c_idxs[c_keep].tolist())
return [boxes_list[i] for i in keep_indices]
def predict_sliced(model, img_path: Path, conf_threshold: float = 0.02, slice_size: int = 640, overlap: float = 0.2, iou_threshold: float = 0.45):
with Image.open(img_path) as img:
img_w, img_h = img.size
np_img = np.array(img.convert("RGB"))
all_boxes = []
# 1. Full Image Pass
res_full = model.predict(np_img, conf=conf_threshold, verbose=False)
if res_full and len(res_full) > 0 and res_full[0].boxes is not None and len(res_full[0].boxes) > 0:
boxes_xyxy = res_full[0].boxes.xyxy.cpu().numpy()
confs = res_full[0].boxes.conf.cpu().numpy()
cls_ids = res_full[0].boxes.cls.cpu().numpy().astype(int)
for (x1, y1, x2, y2), c, cls_id in zip(boxes_xyxy, confs, cls_ids):
all_boxes.append([float(x1), float(y1), float(x2), float(y2), float(c), int(cls_id)])
# 2. Sliced Grid Pass
if img_w > slice_size or img_h > slice_size:
step_x = int(slice_size * (1 - overlap))
step_y = int(slice_size * (1 - overlap))
x_offsets = list(range(0, max(1, img_w - slice_size + step_x), step_x))
y_offsets = list(range(0, max(1, img_h - slice_size + step_y), step_y))
if x_offsets[-1] + slice_size < img_w:
x_offsets.append(img_w - slice_size)
if y_offsets[-1] + slice_size < img_h:
y_offsets.append(img_h - slice_size)
for y0 in y_offsets:
for x0 in x_offsets:
x1_crop = min(x0 + slice_size, img_w)
y1_crop = min(y0 + slice_size, img_h)
patch = np_img[y0:y1_crop, x0:x1_crop]
if patch.shape[0] < 100 or patch.shape[1] < 100:
continue
res_patch = model.predict(patch, conf=conf_threshold, verbose=False)
if res_patch and len(res_patch) > 0 and res_patch[0].boxes is not None and len(res_patch[0].boxes) > 0:
p_boxes = res_patch[0].boxes.xyxy.cpu().numpy()
p_confs = res_patch[0].boxes.conf.cpu().numpy()
p_cls = res_patch[0].boxes.cls.cpu().numpy().astype(int)
for (px1, py1, px2, py2), c, cls_id in zip(p_boxes, p_confs, p_cls):
gx1 = x0 + px1
gy1 = y0 + py1
gx2 = x0 + px2
gy2 = y0 + py2
all_boxes.append([float(gx1), float(gy1), float(gx2), float(gy2), float(c), int(cls_id)])
final_boxes = apply_nms(all_boxes, iou_threshold=iou_threshold)
return final_boxes, img_w, img_h
if __name__ == "__main__":
images = sorted(list(Path("data/images").glob("*.jpg")))[:50]
print(f"Testing Sliced Inference on {len(images)} images...")
model = YOLOWorld("yolov8s-worldv2.pt")
model.set_classes(CLASS_PROMPTS)
counts = {name: 0 for name in CLASS_NAMES}
total_boxes = 0
for img_p in images:
boxes, w, h = predict_sliced(model, img_p, conf_threshold=0.02)
for b in boxes:
cls_name = CLASS_NAMES[b[5]]
counts[cls_name] += 1
total_boxes += 1
print("Sample Results across 50 images:")
print("Total boxes:", total_boxes)
for k, v in counts.items():
print(f" {k:25s}: {v}")
|