| """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 = [] |
|
|
| |
| 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)]) |
|
|
| |
| 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}") |
|
|
