Roboflow Supervision: Python 컴퓨터 비전 주석 도구 모음

# supervision import
from supervision import *

# 기존 주석 로드
annotations = load_annotations("annotations/coco_format.json")

# 주석 형식 간 변환
coco_to_yolo(
    input_path="annotations/coco_format.json",
    output_path="annotations/yolo_format.txt",
    class_map={"person": 0, "car": 1, "dog": 2}
)

# 주석 통계 검토
stats = get_annotation_stats(annotations)
print(f"Total objects: {stats.total_objects}")
print(f"Classes: {stats.classes}")
print(f"Images: {stats.total_images}")

import supervision as sv
import cv2

# 탐지 모델 로드 (YOLO, Detectron 등 작동)
detections = sv.Detections.from_yolo_output(
    prediction,  # 모델 출력 텐서
    original_image_size,  # 이미지 크기
    confidence_threshold=0.5,
    class_id=0  # 클래스별 필터링
)

# 비최대값 억제 적용
detections = sv.NMS(detections, iou_threshold=0.45)

# 신뢰도로 필터링
detections = detections[detections.confidence > 0.6]

# 그리기용 annotation context 생성
annotation_context = sv.BoxAnnotator(
    thickness=2,
    color_lookup=sv.ColorLookup.INDEX
)

# 이미지 로드
image = cv2.imread("scene.jpg")

# bounding box 그리기
annotated_image = annotation_context.annotate(
    scene=image,
    detections=detections
)

# segmentation mask 그리기
mask_annotator = sv.MaskAnnotator(
    opacity=0.5,
    color_lookup=sv.ColorLookup.INDEX
)
annotated_image = mask_annotator.annotate(
    scene=annotated_image,
    detections=detections
)

# 신뢰도 있는 class label 그리기
label_annotator = sv.LabelAnnotator(
    text_scale=0.5,
    text_thickness=1,
    color_lookup=sv.ColorLookup.INDEX
)
annotated_image = label_annotator.annotate(
    scene=annotated_image,
    detections=detections
)

# 결과 저장
cv2.imwrite("annotated_scene.jpg", annotated_image)

# tracker 초기화
tracker = sv.Tracker(
    tracker_type="ocsort",  # 또는 "bytetrack"
    max_age=30,
    min_hits=3,
    iou_threshold=0.3
)

# 비디오 프레임 전체에서 object 추적
video_path = "traffic_camera.mp4"
for frame_number, frame in enumerate(
    sv.VideoInfo.from_video_path(video_path).iter_frames()
):
    detections = detect_objects(frame)  # 사용자의 탐지 모델
    detections = tracker.update_with_detections(detections)
    
    # tracking ID가 있는 주석이 달린 프레임
    annotated_frame = draw_tracking_ids(frame, detections)

# confusion matrix 계산
confusion_matrix = sv.ConfusionMatrix(
    num_classes=10,
    task="multiclass"
)
confusion_matrix.compute(
    predictions=predicted_labels,
    targets=ground_truth_labels
)

# confusion matrix 표시
confusion_matrix.plot(title="Model Performance")

# 클래스별 precision, recall 및 F1 가져오기
for class_name, metrics in confusion_matrix.class_metrics().items():
    print(f"{class_name}: precision={metrics.precision:.3f}, recall={metrics.recall:.3f}, f1={metrics.f1:.3f}")

from supervision import Detections

# 처음부터 detection 생성
detections = Detections(
    xyxy=np.array([  # bounding box [x1, y1, x2, y2]
        [100, 50, 300, 250],
        [400, 100, 600, 300]
    ]),
    confidence=np.array([0.95, 0.87]),
    class_id=np.array([0, 2]),
    mask=np.array([mask_1, mask_2]),  # 선택적 segmentation mask
    keypoints=np.array([keypoints_1, keypoints_2])  # 선택적 keypoint
)

# detection 필터링
person_detections = detections[detections.class_id == 0]
high_confidence = detections[detections.confidence > 0.8]

# 두 detection set 간 IoU 계산
ious = sv.match_iou(detections_a, detections_b, iou_threshold=0.5)

# 탐지 파이프라인 빌드
pipeline = [
    {"operation": "filter_confidence", "threshold": 0.5},
    {"operation": "non_max_suppression", "iou_threshold": 0.45},
    {"operation": "filter_class", "class_ids": [0, 1, 2]},
    {"operation": "compute_metrics", "metric": "ap50"}
]

# 파이프라인 실행
results = apply_pipeline(original_detections, pipeline)

# pip로 설치
pip install supervision

# 설치 검증
python -c "import supervision as sv; print(sv.__version__)"

# 최대 호환성을 위해 모든 선택적 의존성과 함께 설치
pip install supervision[all]

# PyTorch로 설치 (CPU)
pip install supervision torch torchvision

# PyTorch로 설치 (CUDA 12.x)
pip install supervision torch torchvision --index-url https://download.pytorch.org/whl/cu121

# 대화형 Colab 데모 열기
# https://colab.research.google.com/github/roboflow/supervision/blob/main/demo.ipynb

# 또는 로컬에서 실행:
# 데모 노트북에 접근하기 위해 repository clone
git clone https://github.com/roboflow/supervision.git
cd supervision
jupyter notebook demo.ipynb

# YOLOv8 (Ultralytics) 통합
from ultralytics import YOLO
import supervision as sv

# YOLOv8 모델 로드
model = YOLO("yolov8n.pt")

# 추론 실행
results = model.predict("image.jpg", conf=0.25)

# YOLO 결과를 Supervision detection으로 변환
detections = sv.Detections.from_ultralytics(results[0])

# 시각화
annotator = sv.BoxAnnotator()
annotated_frame = annotator.annotate(
    scene=results[0].plot(),
    detections=detections
)

import supervision as sv
from mediapipe import solutions

# MediaPipe pose 모델 로드
pose = solutions.pose.Pose(static_image_mode=True)

# pose detection 실행
results = pose.process(image)

# Supervision keypoint 형식으로 변환
if results.pose_landmarks:
    keypoints = sv.KeyPoints.from_mediapipe(results.pose_landmarks)

import supervision as sv
from onnxruntime import InferenceSession

# ONNX 모델 로드
session = InferenceSession("model.onnx")

# 추론 실행 및 Supervision 형식으로 변환
outputs = session.run(None, {session.get_inputs()[0].name: input_tensor})
detections = sv.Detections.from_onnx(outputs)

# 배치 평가 스크립트
import supervision as sv
from tqdm import tqdm

def evaluate_model(model, dataset):
    all_predictions = []
    all_targets = []
    
    for images, labels in tqdm(dataset, desc="Evaluating"):
        preds = model.predict(images)
        all_predictions.extend(preds)
        all_targets.extend(labels)
    
    # Supervision으로 메트릭 계산
    confusion = sv.ConfusionMatrix(
        num_classes=len(dataset.classes),
        task="multiclass"
    )
    confusion.compute(
        predictions=all_predictions,
        targets=all_targets
    )
    
    metrics = confusion.metrics()
    print(f"mAP@0.5: {metrics.map_50:.4f}")
    print(f"mAP@0.5:0.95: {metrics.map_50_95:.4f}")
    return metrics

import supervision as sv
import cv2
import numpy as np

class ArrowAnnotator(sv.Annotator):
    """방향 화살표 그리기 위한 사용자 정의 annotator."""
    
    def __init__(self, color=None, thickness=2):
        super().__init__()
        self.color = color or sv.Color.WHITE
        self.thickness = thickness
    
    def annotate(self, scene, detections, direction="right"):
        for i, detection in enumerate(detections):
            center_x = int((detection.xyxy[0] + detection.xyxy[2]) / 2)
            center_y = int((detection.xyxy[1] + detection.xyxy[3]) / 2)
            
            if direction == "right":
                end_x = center_x + 50
                end_y = center_y
            elif direction == "left":
                end_x = center_x - 50
                end_y = center_y
            elif direction == "up":
                end_x = center_x
                end_y = center_y - 50
            else:
                end_x = center_x
                end_y = center_y + 50
            
            cv2.arrowedLine(
                scene,
                (center_x, center_y),
                (end_x, end_y),
                (self.color.r, self.color.g, self.color.b),
                self.thickness
            )
        
        return scene

# 사용자 정의 annotator 사용
arrow_annotator = ArrowAnnotator(
    color=sv.Color.GREEN,
    thickness=3
)

import supervision as sv

class VideoAnalyticsPipeline:
    def __init__(self, video_path, model):
        self.video_path = video_path
        self.model = model
        self.counter = sv.ObjectCounter()
        self.line_annotator = sv.LineAnnotator()
        self.label_annotator = sv.LabelAnnotator()
        
        # 카운팅 zone 정의
        self.counting_line = sv.Line(
            start=(100, 400),
            end=(1200, 400)
        )
    
    def process_frame(self, frame):
        # 탐지 실행
        detections = self.model.predict(frame)
        
        # line crossing로 counter 업데이트
        self.counter.trigger(detections, self.counting_line)
        
        # 주석 달기
        annotated = self.line_annotator.annotate(scene=frame.copy())
        annotated = self.label_annotator.annotate(
            scene=annotated,
            detections=detections
        )
        
        # counter label 그리기
        cv2.putText(
            annotated,
            f"Entry: {self.counter.entries}",
            (10, 30),
            cv2.FONT_HERSHEY_SIMPLEX,
            1, (0, 255, 0), 2
        )
        
        return annotated

# 파이프라인 실행
pipeline = VideoAnalyticsPipeline("camera_feed.mp4", model)
pipeline.run()

import supervision as sv

# ROC curve
roc = sv.ROCCurve(
    num_classes=5,
    labels=["cat", "dog", "car", "person", "bird"]
)
roc.compute(predictions, targets)
roc.plot(save_path="roc_curve.png")

# Precision-Recall curve
pr = sv.PrecisionRecallCurve(
    num_classes=5
)
pr.compute(predictions, targets)
pr.plot(save_path="pr_curve.png")