콘텐츠로 건너뛰기

간단한 유틸리티

관점이 있는 코드

그리고 ultralytics 패키지는 워크플로를 지원, 개선 및 가속화하기 위한 다양한 유틸리티를 제공합니다. 더 많은 유틸리티가 있지만, 이 가이드에서는 개발자에게 가장 유용한 몇 가지를 중점적으로 소개하여 Ultralytics 도구로 프로그래밍하는 데 실질적인 참고 자료로 활용할 수 있습니다.



Watch: Ultralytics 유틸리티 > 자동 주석, 탐색기 API 및 데이터 세트 변환

데이터

자동 라벨링/주석

데이터 세트 주석은 리소스 집약적이고 시간이 많이 소요되는 프로세스입니다. 적절한 양의 데이터로 훈련된 Ultralytics YOLO 개체 감지 모델이 있는 경우, 다음과 함께 사용할 수 있습니다. SAM 과 함께 사용하여 세분화 형식으로 추가 데이터를 자동 주석으로 추가할 수 있습니다.

from ultralytics.data.annotator import auto_annotate

auto_annotate(
    data="path/to/new/data",
    det_model="yolo11n.pt",
    sam_model="mobile_sam.pt",
    device="cuda",
    output_dir="path/to/save_labels",
)

이 함수는 값을 반환하지 않습니다. 자세한 내용은 여기를 참조하세요:

데이터 집합 주석 시각화

이 기능은 훈련 전에 이미지의 YOLO 주석을 시각화하여 잘못된 탐지 결과를 초래할 수 있는 잘못된 주석을 식별하고 수정하는 데 도움을 줍니다. 경계 상자를 그리고, 클래스 이름으로 개체에 레이블을 지정하고, 배경의 휘도에 따라 텍스트 색상을 조정하여 가독성을 높입니다.

from ultralytics.data.utils import visualize_image_annotations

label_map = {  # Define the label map with all annotated class labels.
    0: "person",
    1: "car",
}

# Visualize
visualize_image_annotations(
    "path/to/image.jpg",  # Input image path.
    "path/to/annotations.txt",  # Annotation file path for the image.
    label_map,
)

세분화 마스크를 YOLO 형식으로 변환

세분화 마스크를 YOLO 형식으로 변환

이를 사용하여 세분화 마스크 이미지의 데이터 세트를 Ultralytics YOLO 세분화 형식으로 변환합니다. 이 함수는 바이너리 형식의 마스크 이미지가 포함된 디렉터리를 가져와서 YOLO 세그멘테이션 형식으로 변환합니다.

변환된 마스크는 지정된 출력 디렉터리에 저장됩니다.

from ultralytics.data.converter import convert_segment_masks_to_yolo_seg

# The classes here is the total classes in the dataset.
# for COCO dataset we have 80 classes.
convert_segment_masks_to_yolo_seg(masks_dir="path/to/masks_dir", output_dir="path/to/output_dir", classes=80)

COCO를 YOLO 형식으로 변환

변환하려면 다음을 사용하세요. COCO JSON 주석을 YOLO 형식으로 변환합니다. 개체 감지(바운딩 박스) 데이터 세트의 경우, 두 가지 모두 use_segments 그리고 use_keypoints 에 False.

from ultralytics.data.converter import convert_coco

convert_coco(
    "../datasets/coco/annotations/",
    use_segments=False,
    use_keypoints=False,
    cls91to80=True,
)

에 대한 자세한 내용은 convert_coco 함수입니다, 참조 페이지 방문.

바운딩 박스 치수 가져오기

import cv2

from ultralytics import YOLO
from ultralytics.utils.plotting import Annotator

model = YOLO("yolo11n.pt")  # Load pretrain or fine-tune model

# Process the image
source = cv2.imread("path/to/image.jpg")
results = model(source)

# Extract results
annotator = Annotator(source, example=model.names)

for box in results[0].boxes.xyxy.cpu():
    width, height, area = annotator.get_bbox_dimension(box)
    print(f"Bounding Box Width {width.item()}, Height {height.item()}, Area {area.item()}")

바운딩 박스를 세그먼트로 변환하기

기존 x y w h 바운딩 박스 데이터를 사용하여 세그먼트로 변환합니다. yolo_bbox2segment 함수를 사용하세요. 이미지 및 주석 파일을 다음과 같이 정리합니다:

data
|__ images
    ├─ 001.jpg
    ├─ 002.jpg
    ├─ ..
    └─ NNN.jpg
|__ labels
    ├─ 001.txt
    ├─ 002.txt
    ├─ ..
    └─ NNN.txt

from ultralytics.data.converter import yolo_bbox2segment

yolo_bbox2segment(
    im_dir="path/to/images",
    save_dir=None,  # saved to "labels-segment" in images directory
    sam_model="sam_b.pt",
)

방문하기 yolo_bbox2segment 참조 페이지 기능에 대한 자세한 내용을 확인하세요.

세그먼트를 바운딩 박스로 변환하기

를 사용하는 데이터 집합이 있는 경우 세분화 데이터 세트 형식를 사용하면 이를 수직(또는 수평) 바운딩 박스로 쉽게 변환할 수 있습니다(x y w h 형식)을 사용하여 이 함수를 사용할 수 있습니다.

import numpy as np

from ultralytics.utils.ops import segments2boxes

segments = np.array(
    [
        [805, 392, 797, 400, ..., 808, 714, 808, 392],
        [115, 398, 113, 400, ..., 150, 400, 149, 298],
        [267, 412, 265, 413, ..., 300, 413, 299, 412],
    ]
)

segments2boxes([s.reshape(-1, 2) for s in segments])
# >>> array([[ 741.66, 631.12, 133.31, 479.25],
#           [ 146.81, 649.69, 185.62, 502.88],
#           [ 281.81, 636.19, 118.12, 448.88]],
#           dtype=float32) # xywh bounding boxes

이 기능의 작동 방식을 이해하려면 참조 페이지를 방문하세요.

유틸리티

이미지 압축

가로 세로 비율과 품질을 유지하면서 단일 이미지 파일을 축소된 크기로 압축합니다. 입력 이미지가 최대 크기보다 작으면 크기가 조정되지 않습니다.

from pathlib import Path

from ultralytics.data.utils import compress_one_image

for f in Path("path/to/dataset").rglob("*.jpg"):
    compress_one_image(f)

데이터 세트 자동 분할

데이터 집합을 다음과 같이 자동으로 분할합니다. train/val/test 분할하고 결과 분할을 autosplit_*.txt 파일을 사용합니다. 이 함수는 무작위 샘플링을 사용하며, 이 함수는 fraction 교육용 인수.

from ultralytics.data.utils import autosplit

autosplit(
    path="path/to/images",
    weights=(0.9, 0.1, 0.0),  # (train, validation, test) fractional splits
    annotated_only=False,  # split only images with annotation file when True
)

이 기능에 대한 자세한 내용은 참조 페이지를 참조하세요.

세그먼트 다각형을 바이너리 마스크로 변환하기

단일 다각형(목록)을 지정된 이미지 크기의 바이너리 마스크로 변환합니다. 다각형은 다음과 같은 형식이어야 합니다. [N, 2]에서 N 는 (x, y) 다각형 윤곽을 정의하는 점입니다.

경고

N 항상 균등해야 합니다.

import numpy as np

from ultralytics.data.utils import polygon2mask

imgsz = (1080, 810)
polygon = np.array([805, 392, 797, 400, ..., 808, 714, 808, 392])  # (238, 2)

mask = polygon2mask(
    imgsz,  # tuple
    [polygon],  # input as list
    color=255,  # 8-bit binary
    downsample_ratio=1,
)

바운딩 박스

바운딩 박스(가로) 인스턴스

바운딩 박스 데이터를 관리하려면 Bboxes 클래스는 상자 좌표 형식 간 변환, 상자 치수 크기 조정, 면적 계산, 오프셋 포함 등을 지원합니다.

import numpy as np

from ultralytics.utils.instance import Bboxes

boxes = Bboxes(
    bboxes=np.array(
        [
            [22.878, 231.27, 804.98, 756.83],
            [48.552, 398.56, 245.35, 902.71],
            [669.47, 392.19, 809.72, 877.04],
            [221.52, 405.8, 344.98, 857.54],
            [0, 550.53, 63.01, 873.44],
            [0.0584, 254.46, 32.561, 324.87],
        ]
    ),
    format="xyxy",
)

boxes.areas()
# >>> array([ 4.1104e+05,       99216,       68000,       55772,       20347,      2288.5])

boxes.convert("xywh")
print(boxes.bboxes)
# >>> array(
#     [[ 413.93, 494.05,  782.1, 525.56],
#      [ 146.95, 650.63,  196.8, 504.15],
#      [  739.6, 634.62, 140.25, 484.85],
#      [ 283.25, 631.67, 123.46, 451.74],
#      [ 31.505, 711.99,  63.01, 322.91],
#      [  16.31, 289.67, 32.503,  70.41]]
# )

참조 Bboxes 참조 섹션 를 클릭해 더 많은 속성과 메소드를 확인하세요.

팁

다음 기능(및 그 이상)은 다음을 사용하여 액세스할 수 있습니다. Bboxes 클래스를 사용하지만 함수를 직접 사용하려면 다음 하위 섹션에서 함수를 독립적으로 가져오는 방법을 참조하세요.

스케일링 박스

이미지의 크기를 늘리거나 줄일 때 다음을 사용하여 해당 경계 상자 좌표의 크기를 적절히 조정할 수 있습니다. ultralytics.utils.ops.scale_boxes.

import cv2 as cv
import numpy as np

from ultralytics.utils.ops import scale_boxes

image = cv.imread("ultralytics/assets/bus.jpg")
h, w, c = image.shape
resized = cv.resize(image, None, (), fx=1.2, fy=1.2)
new_h, new_w, _ = resized.shape

xyxy_boxes = np.array(
    [
        [22.878, 231.27, 804.98, 756.83],
        [48.552, 398.56, 245.35, 902.71],
        [669.47, 392.19, 809.72, 877.04],
        [221.52, 405.8, 344.98, 857.54],
        [0, 550.53, 63.01, 873.44],
        [0.0584, 254.46, 32.561, 324.87],
    ]
)

new_boxes = scale_boxes(
    img1_shape=(h, w),  # original image dimensions
    boxes=xyxy_boxes,  # boxes from original image
    img0_shape=(new_h, new_w),  # resized image dimensions (scale to)
    ratio_pad=None,
    padding=False,
    xywh=False,
)

print(new_boxes)
# >>> array(
#     [[  27.454,  277.52,  965.98,   908.2],
#     [   58.262,  478.27,  294.42,  1083.3],
#     [   803.36,  470.63,  971.66,  1052.4],
#     [   265.82,  486.96,  413.98,    1029],
#     [        0,  660.64,  75.612,  1048.1],
#     [   0.0701,  305.35,  39.073,  389.84]]
# )

바운딩 박스 형식 변환

XYXY → XYWH

바운딩 박스 좌표를 (x1, y1, x2, y2) 형식에서 (x, y, 폭, 높이) 형식으로 변환합니다. 여기서 (x1, y1)은 왼쪽 상단 모서리, (x2, y2)는 오른쪽 하단 모서리입니다.

import numpy as np

from ultralytics.utils.ops import xyxy2xywh

xyxy_boxes = np.array(
    [
        [22.878, 231.27, 804.98, 756.83],
        [48.552, 398.56, 245.35, 902.71],
        [669.47, 392.19, 809.72, 877.04],
        [221.52, 405.8, 344.98, 857.54],
        [0, 550.53, 63.01, 873.44],
        [0.0584, 254.46, 32.561, 324.87],
    ]
)
xywh = xyxy2xywh(xyxy_boxes)

print(xywh)
# >>> array(
#     [[ 413.93,  494.05,   782.1, 525.56],
#     [  146.95,  650.63,   196.8, 504.15],
#     [   739.6,  634.62,  140.25, 484.85],
#     [  283.25,  631.67,  123.46, 451.74],
#     [  31.505,  711.99,   63.01, 322.91],
#     [   16.31,  289.67,  32.503,  70.41]]
# )

모든 바운딩 박스 변환

from ultralytics.utils.ops import (
    ltwh2xywh,
    ltwh2xyxy,
    xywh2ltwh,  # xywh → top-left corner, w, h
    xywh2xyxy,
    xywhn2xyxy,  # normalized → pixel
    xyxy2ltwh,  # xyxy → top-left corner, w, h
    xyxy2xywhn,  # pixel → normalized
)

for func in (ltwh2xywh, ltwh2xyxy, xywh2ltwh, xywh2xyxy, xywhn2xyxy, xyxy2ltwh, xyxy2xywhn):
    print(help(func))  # print function docstrings

각 기능에 대한 문서 문자열을 참조하거나 ultralytics.utils.ops 참조 페이지 를 클릭해 자세히 알아보세요.

플로팅

드로잉 주석

Ultralytics Annotator 클래스를 사용하여 다양한 데이터 유형에 주석을 달 수 있습니다. 다음과 함께 사용하는 것이 가장 좋습니다. 객체 감지 경계 상자, 포즈 키포인트및 방향성 경계 상자.

Ultralytics 스윕 주석

Ultralytics YOLO 🚀를 사용한 Python 예제

import cv2

from ultralytics import YOLO
from ultralytics.engine.results import Results
from ultralytics.solutions.solutions import SolutionAnnotator

# User defined video path and model file
cap = cv2.VideoCapture("path/to/video.mp4")
model = YOLO(model="yolo11s-seg.pt")  # Model file i.e. yolo11s.pt or yolo11m-seg.pt

if not cap.isOpened():
    print("Error: Could not open video.")
    exit()

# Initialize the video writer object.
w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))
video_writer = cv2.VideoWriter("ultralytics.avi", cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))

masks = None  # Initialize variable to store masks data
f = 0  # Initialize frame count variable for enabling mouse event.
line_x = w  # Store width of line.
dragging = False  # Initialize bool variable for line dragging.
classes = model.names  # Store model classes names for plotting.
window_name = "Ultralytics Sweep Annotator"


def drag_line(event, x, _, flags, param):
    """Mouse callback function to enable dragging a vertical sweep line across the video frame."""
    global line_x, dragging
    if event == cv2.EVENT_LBUTTONDOWN or (flags & cv2.EVENT_FLAG_LBUTTON):
        line_x = max(0, min(x, w))
        dragging = True


while cap.isOpened():  # Loop over the video capture object.
    ret, im0 = cap.read()
    if not ret:
        break
    f = f + 1  # Increment frame count.
    count = 0  # Re-initialize count variable on every frame for precise counts.
    results = model.track(im0, persist=True)[0]

    if f == 1:
        cv2.namedWindow(window_name)
        cv2.setMouseCallback(window_name, drag_line)

    if results.boxes.id is not None:
        if results.masks is not None:
            masks = results.masks
        boxes = results.boxes

        track_ids = results.boxes.id.int().cpu().tolist()
        clss = results.boxes.cls.cpu().tolist()

        for mask, box, cls, t_id in zip(masks or [None] * len(boxes), boxes, clss, track_ids):
            box_data = box.xyxy.cpu().tolist()[0][0]
            if box_data > line_x:
                count += 1
                results = Results(
                    im0, path=None, names=classes, boxes=box.data, masks=None if mask is None else mask.data
                )
                im0 = results.plot(
                    boxes=True,  # display bounding box
                    conf=False,  # hide confidence score
                    labels=True,  # display labels
                    color_mode="instance",
                )

    # Generate draggable sweep line
    annotator = SolutionAnnotator(im0)
    annotator.sweep_annotator(line_x=line_x, line_y=h, label=f"COUNT:{count}")

    cv2.imshow(window_name, im0)
    video_writer.write(im0)
    if cv2.waitKey(1) & 0xFF == ord("q"):
        break

# Release the resources
cap.release()
video_writer.release()
cv2.destroyAllWindows()

수평 바운딩 박스

import cv2 as cv
import numpy as np

from ultralytics.utils.plotting import Annotator, colors

names = {
    0: "person",
    5: "bus",
    11: "stop sign",
}

image = cv.imread("ultralytics/assets/bus.jpg")
ann = Annotator(
    image,
    line_width=None,  # default auto-size
    font_size=None,  # default auto-size
    font="Arial.ttf",  # must be ImageFont compatible
    pil=False,  # use PIL, otherwise uses OpenCV
)

xyxy_boxes = np.array(
    [
        [5, 22.878, 231.27, 804.98, 756.83],  # class-idx x1 y1 x2 y2
        [0, 48.552, 398.56, 245.35, 902.71],
        [0, 669.47, 392.19, 809.72, 877.04],
        [0, 221.52, 405.8, 344.98, 857.54],
        [0, 0, 550.53, 63.01, 873.44],
        [11, 0.0584, 254.46, 32.561, 324.87],
    ]
)

for nb, box in enumerate(xyxy_boxes):
    c_idx, *box = box
    label = f"{str(nb).zfill(2)}:{names.get(int(c_idx))}"
    ann.box_label(box, label, color=colors(c_idx, bgr=True))

image_with_bboxes = ann.result()

이름은 다음에서 사용할 수 있습니다. model.names 언제 탐지 결과 작업.

OBB(오리엔티드 바운딩 박스)

import cv2 as cv
import numpy as np

from ultralytics.utils.plotting import Annotator, colors

obb_names = {10: "small vehicle"}
obb_image = cv.imread("datasets/dota8/images/train/P1142__1024__0___824.jpg")
obb_boxes = np.array(
    [
        [0, 635, 560, 919, 719, 1087, 420, 803, 261],  # class-idx x1 y1 x2 y2 x3 y2 x4 y4
        [0, 331, 19, 493, 260, 776, 70, 613, -171],
        [9, 869, 161, 886, 147, 851, 101, 833, 115],
    ]
)
ann = Annotator(
    obb_image,
    line_width=None,  # default auto-size
    font_size=None,  # default auto-size
    font="Arial.ttf",  # must be ImageFont compatible
    pil=False,  # use PIL, otherwise uses OpenCV
)
for obb in obb_boxes:
    c_idx, *obb = obb
    obb = np.array(obb).reshape(-1, 4, 2).squeeze()
    label = f"{obb_names.get(int(c_idx))}"
    ann.box_label(
        obb,
        label,
        color=colors(c_idx, True),
        rotated=True,
    )

image_with_obb = ann.result()

바운딩 상자 원 주석 원 레이블



Watch: 텍스트 및 원 주석에 대한 심층 가이드( Python 라이브 데모 포함) | Ultralytics 주석 🚀 

import cv2

from ultralytics import YOLO
from ultralytics.solutions.solutions import SolutionAnnotator
from ultralytics.utils.plotting import colors

model = YOLO("yolo11s.pt")
names = model.names
cap = cv2.VideoCapture("path/to/video.mp4")

w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))
writer = cv2.VideoWriter("Ultralytics circle annotation.avi", cv2.VideoWriter_fourcc(*"MJPG"), fps, (w, h))

while True:
    ret, im0 = cap.read()
    if not ret:
        break

    annotator = SolutionAnnotator(im0)
    results = model.predict(im0)
    boxes = results[0].boxes.xyxy.cpu()
    clss = results[0].boxes.cls.cpu().tolist()

    for box, cls in zip(boxes, clss):
        annotator.circle_label(box, label=names[int(cls)], color=colors(cls, True))

    writer.write(im0)
    cv2.imshow("Ultralytics circle annotation", im0)

    if cv2.waitKey(1) & 0xFF == ord("q"):
        break

writer.release()
cap.release()
cv2.destroyAllWindows()

바운딩 박스 텍스트 주석 텍스트 레이블

import cv2

from ultralytics import YOLO
from ultralytics.solutions.solutions import SolutionAnnotator
from ultralytics.utils.plotting import colors

model = YOLO("yolo11s.pt")
names = model.names
cap = cv2.VideoCapture("path/to/video.mp4")

w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))
writer = cv2.VideoWriter("Ultralytics text annotation.avi", cv2.VideoWriter_fourcc(*"MJPG"), fps, (w, h))

while True:
    ret, im0 = cap.read()
    if not ret:
        break

    annotator = SolutionAnnotator(im0)
    results = model.predict(im0)
    boxes = results[0].boxes.xyxy.cpu()
    clss = results[0].boxes.cls.cpu().tolist()

    for box, cls in zip(boxes, clss):
        annotator.text_label(box, label=names[int(cls)], color=colors(cls, True))

    writer.write(im0)
    cv2.imshow("Ultralytics text annotation", im0)

    if cv2.waitKey(1) & 0xFF == ord("q"):
        break

writer.release()
cap.release()
cv2.destroyAllWindows()

참조 Annotator 참조 페이지 를 참조하세요.

기타

코드 프로파일링

다음을 사용하여 코드를 실행/처리할 기간을 확인합니다. with 또는 데코레이터로 사용할 수 있습니다.

from ultralytics.utils.ops import Profile

with Profile(device="cuda:0") as dt:
    pass  # operation to measure

print(dt)
# >>> "Elapsed time is 9.5367431640625e-07 s"

Ultralytics 지원되는 형식

Ultralytics 지원되는 이미지 또는 동영상 형식을 프로그래밍 방식으로 사용해야 하나요? 필요한 경우 이 상수를 사용하세요:

from ultralytics.data.utils import IMG_FORMATS, VID_FORMATS

print(IMG_FORMATS)
# {'tiff', 'pfm', 'bmp', 'mpo', 'dng', 'jpeg', 'png', 'webp', 'tif', 'jpg'}

print(VID_FORMATS)
# {'avi', 'mpg', 'wmv', 'mpeg', 'm4v', 'mov', 'mp4', 'asf', 'mkv', 'ts', 'gif', 'webm'}

분할 가능 만들기

에 가장 가까운 정수를 계산합니다. x 로 균등하게 나눌 수 있는 y.

from ultralytics.utils.ops import make_divisible

make_divisible(7, 3)
# >>> 9
make_divisible(7, 2)
# >>> 8

자주 묻는 질문

머신 러닝 워크플로우를 개선하기 위해 Ultralytics 패키지에 포함된 유틸리티에는 어떤 것이 있나요?

Ultralytics 패키지에는 머신 러닝 워크플로우를 간소화하고 최적화하도록 설계된 유틸리티가 포함되어 있습니다. 주요 유틸리티에는 데이터 세트에 라벨을 붙이기 위한 자동 주석, convert_coco를 사용해 COCO를 YOLO 형식으로 변환, 이미지 압축, 데이터 세트 자동 분할 등이 포함됩니다. 이러한 도구는 수작업을 줄이고, 일관성을 보장하며, 데이터 처리 효율성을 높여줍니다.

Ultralytics 을 사용하여 데이터 집합에 자동 레이블을 지정하려면 어떻게 해야 하나요?

사전 학습된 Ultralytics YOLO 객체 감지 모델이 있는 경우, 이를 세그먼트 형식의 SAM 모델과 함께 사용하여 데이터 세트에 세분화 형식으로 자동 주석을 달 수 있습니다. 다음은 예시입니다:

from ultralytics.data.annotator import auto_annotate

auto_annotate(
    data="path/to/new/data",
    det_model="yolo11n.pt",
    sam_model="mobile_sam.pt",
    device="cuda",
    output_dir="path/to/save_labels",
)

자세한 내용은 자동 주석 달기 참조 섹션을 확인하세요.

COCO 데이터 세트 주석을 Ultralytics 에서 YOLO 형식으로 변환하려면 어떻게 하나요?

COCO JSON 어노테이션을 개체 감지를 위해 YOLO 형식으로 변환하려면 convert_coco 유틸리티를 사용하세요. 다음은 샘플 코드 스니펫입니다:

from ultralytics.data.converter import convert_coco

convert_coco(
    "../datasets/coco/annotations/",
    use_segments=False,
    use_keypoints=False,
    cls91to80=True,
)

자세한 내용은 convert_coco 참조 페이지를 참조하세요.

Ultralytics 패키지의 YOLO 데이터 탐색기의 용도는 무엇인가요?

그리고 YOLO 탐색기 에 소개된 강력한 도구입니다. 8.1.0 데이터 세트 이해도를 높이기 위한 업데이트입니다. 텍스트 쿼리를 사용해 데이터 세트에서 개체 인스턴스를 찾을 수 있으므로 데이터를 더 쉽게 분석하고 관리할 수 있습니다. 이 도구는 데이터 세트 구성과 분포에 대한 귀중한 인사이트를 제공하여 모델 훈련과 성능을 개선하는 데 도움이 됩니다.

Ultralytics 에서 바운딩 박스를 세그먼트로 변환하려면 어떻게 해야 하나요?

기존 바운딩 박스 데이터를 변환하려면( x y w h 형식)을 세그먼트에 추가하려면 yolo_bbox2segment 기능을 사용하세요. 이미지와 라벨을 위한 별도의 디렉터리로 파일을 정리하세요.

from ultralytics.data.converter import yolo_bbox2segment

yolo_bbox2segment(
    im_dir="path/to/images",
    save_dir=None,  # saved to "labels-segment" in the images directory
    sam_model="sam_b.pt",
)

자세한 내용은 yolo_bbox2segment 참조 페이지를 참조하세요.

📅1 년 전 생성됨 ✏️ 1 일 전 업데이트됨
리즈완무나와르 leonnil 글렌-조처 울트라 애널리틱스 어시스턴트 야심 찬 문어 IvorZhu331 Burhan-Q

댓글