सामग्री पर जाएं

सरल उपयोगिताएँ

परिप्रेक्ष्य के साथ कोड

वही ultralytics पैकेज उपयोगिताओं के असंख्य के साथ आता है जो आपके वर्कफ़्लोज़ का समर्थन, वृद्धि और गति कर सकते हैं। कई और उपलब्ध हैं, लेकिन यहां कुछ ऐसे हैं जो अधिकांश डेवलपर्स के लिए उपयोगी होंगे। वे प्रोग्राम सीखते समय उपयोग करने के लिए एक महान संदर्भ बिंदु भी हैं।



सतर्कता: Ultralytics उपयोगिताएँ | ऑटो एनोटेशन, एक्सप्लोरर एपीआई और डेटासेट रूपांतरण

डाटा

YOLO डेटा एक्सप्लोरर

YOLO खोजयात्री में जोड़ा गया था 8.1.0 वर्षगांठ अद्यतन और एक शक्तिशाली उपकरण है जिसका उपयोग आप अपने डेटासेट को बेहतर ढंग से समझने के लिए कर सकते हैं। प्रमुख कार्यों में से एक जो YOLO एक्सप्लोरर प्रदान करता है, आपके डेटासेट में ऑब्जेक्ट इंस्टेंस खोजने के लिए टेक्स्ट क्वेरी का उपयोग करने की क्षमता है।

ऑटो लेबलिंग/एनोटेशन

डेटासेट एनोटेशन एक बहुत ही संसाधन गहन और समय लेने वाली प्रक्रिया है। यदि आपके पास एक YOLO ऑब्जेक्ट डिटेक्शन मॉडल को उचित मात्रा में डेटा पर प्रशिक्षित किया गया है, आप इसका उपयोग कर सकते हैं और SAM अतिरिक्त डेटा (विभाजन प्रारूप) को ऑटो-एनोटेट करने के लिए।

from ultralytics.data.annotator import auto_annotate

auto_annotate(  # (1)!
    data="path/to/new/data",
    det_model="yolov8n.pt",
    sam_model="mobile_sam.pt",
    device="cuda",
    output_dir="path/to/save_labels",
)
  1. इस फ़ंक्शन से कुछ भी वापस नहीं आता है

  2. के लिए संदर्भ अनुभाग देखें annotator.auto_annotate फ़ंक्शन कैसे संचालित होता है, इस बारे में अधिक जानकारी के लिए।

  3. के साथ संयोजन में उपयोग करें फलन segments2boxes ऑब्जेक्ट डिटेक्शन बाउंडिंग बॉक्स भी उत्पन्न करने के लिए

COCO को में बदलें YOLO प्रारूप

COCO JSON एनोटेशन को उचित में बदलने के लिए उपयोग करें YOLO प्रारूप। ऑब्जेक्ट डिटेक्शन (बाउंडिंग बॉक्स) डेटासेट के लिए, use_segments और use_keypoints दोनों होना चाहिए False

from ultralytics.data.converter import convert_coco

convert_coco(  # (1)!
    "../datasets/coco/annotations/",
    use_segments=False,
    use_keypoints=False,
    cls91to80=True,
)
  1. इस फ़ंक्शन से कुछ भी वापस नहीं आता है

के बारे में अतिरिक्त जानकारी के लिए convert_coco फलन संदर्भ पृष्ठ पर जाएं

बाउंडिंग बॉक्स आयाम प्राप्त करें

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

model = YOLO('yolov8n.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("Bounding Box Width {}, Height {}, Area {}".format(
        width.item(), height.item(), 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(  # (1)!
    im_dir="path/to/images",
    save_dir=None,  # saved to "labels-segment" in images directory
    sam_model="sam_b.pt",
)
  1. इस फ़ंक्शन से कुछ भी वापस नहीं आता है

भेंट 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)  # (1)!
  1. इस फ़ंक्शन से कुछ भी वापस नहीं आता है

ऑटो-स्प्लिट डेटासेट

डेटासेट को स्वचालित रूप से विभाजित करें train/val/test विभाजन और परिणामी विभाजन को autosplit_*.txt फ़ाइलें। यह फ़ंक्शन यादृच्छिक नमूनाकरण का उपयोग करेगा, जिसका उपयोग करते समय शामिल नहीं है fraction प्रशिक्षण के लिए तर्क.

from ultralytics.data.utils import autosplit

autosplit(  # (1)!
    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
)
  1. इस फ़ंक्शन से कुछ भी वापस नहीं आता है

इस फ़ंक्शन पर अतिरिक्त विवरण के लिए संदर्भ पृष्ठ देखें।

सेगमेंट-पॉलीगॉन टू बाइनरी मास्क

एक एकल बहुभुज (सूची के रूप में) को निर्दिष्ट छवि आकार के बाइनरी मास्क में कनवर्ट करें। बहुभुज के रूप में [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)  # (1)!
# >>> 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]]
# )
  1. नए छवि आकार के लिए बाउंडिंग बॉक्स स्केल किए गए

बाउंडिंग बॉक्स स्वरूप रूपांतरण

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

प्रत्येक फ़ंक्शन के लिए docstring देखें या ultralytics.utils.ops संदर्भ पृष्ठ प्रत्येक फ़ंक्शन के बारे में अधिक पढ़ने के लिए।

प्लॉटिंग

ड्राइंग एनोटेशन

Ultralytics एक एनोटेटर वर्ग शामिल है जिसका उपयोग किसी भी प्रकार के डेटा को एनोटेट करने के लिए किया जा सकता है। ऑब्जेक्ट डिटेक्शन बाउंडिंग बॉक्स, पोज़ की पॉइंट्स और ओरिएंटेड बाउंडिंग बॉक्स के साथ उपयोग करना सबसे आसान है।

क्षैतिज बाउंडिंग बॉक्स

import cv2 as cv
import numpy as np

from ultralytics.utils.plotting import Annotator, colors

names = {  # (1)!
    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()
  1. नामों का उपयोग किया जा सकता है 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()

बाउंडिंग बॉक्स सर्कल एनोटेशन (सर्कल लेबल)

import cv2

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

model = YOLO("yolov8s.pt")
cap = cv2.VideoCapture("path/to/video/file.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 = Annotator(im0, line_width=2)

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

    for box, cls in zip(boxes, clss):
        x1, y1 = int((box[0] + box[2]) // 2), int((box[1] + box[3]) // 2)
        annotator.circle_label(box, label=model.names[int(cls)], color=colors(int(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.utils.plotting import Annotator, colors

model = YOLO("yolov8s.pt")
cap = cv2.VideoCapture("path/to/video/file.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 = Annotator(im0, line_width=2)

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

    for box, cls in zip(boxes, clss):
        x1, y1 = int((box[0] + box[2]) // 2), int((box[1] + box[3]) // 2)
        annotator.text_label(box, label=model.names[int(cls)], color=colors(int(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 पैकेज में मशीन लर्निंग वर्कफ़्लोज़ को सुव्यवस्थित और अनुकूलित करने के लिए डिज़ाइन की गई विभिन्न उपयोगिताओं शामिल हैं। प्रमुख उपयोगिताओं में डेटासेट लेबलिंग के लिए ऑटो-एनोटेशन शामिल हैं, COCO को YOLO convert_coco के साथ प्रारूपित करें, छवियों को संपीड़ित करें, और डेटासेट ऑटो-स्प्लिटिंग। इन उपकरणों का उद्देश्य मैन्युअल प्रयास को कम करना, स्थिरता सुनिश्चित करना और डेटा प्रोसेसिंग दक्षता को बढ़ाना है।

मैं कैसे उपयोग कर सकता हूं Ultralytics मेरे डेटासेट को ऑटो-लेबल करने के लिए?

यदि आपके पास पूर्व-प्रशिक्षित है Ultralytics YOLO ऑब्जेक्ट डिटेक्शन मॉडल, आप इसे SAM अपने डेटासेट को विभाजन प्रारूप में ऑटो-एनोटेट करने के लिए मॉडल। यहाँ एक उदाहरण है:

from ultralytics.data.annotator import auto_annotate

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

अधिक जानकारी के लिए, auto_annotate संदर्भ अनुभाग देखें।

मैं COCO डेटासेट एनोटेशन को कैसे परिवर्तित करूं YOLO में format Ultralytics?

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 संदर्भ पृष्ठ पर जाएँ।

का उद्देश्य क्या है YOLO डेटा एक्सप्लोरर में Ultralytics पैकेज?

वही YOLO खोजयात्री में पेश किया गया एक शक्तिशाली उपकरण है 8.1.0 डेटासेट समझ बढ़ाने के लिए अपडेट करें। यह आपको अपने डेटासेट में ऑब्जेक्ट इंस्टेंस खोजने के लिए टेक्स्ट क्वेरी का उपयोग करने की अनुमति देता है, जिससे आपके डेटा का विश्लेषण और प्रबंधन करना आसान हो जाता है। यह उपकरण डेटासेट संरचना और वितरण में मूल्यवान अंतर्दृष्टि प्रदान करता है, जिससे मॉडल प्रशिक्षण और प्रदर्शन को बेहतर बनाने में मदद मिलती है।

मैं बाउंडिंग बॉक्स को सेगमेंट में कैसे बदल सकता हूं Ultralytics?

मौजूदा बाउंडिंग बॉक्स डेटा को कनवर्ट करने के लिए (में x y w h format) में जोड़ें, तो आप 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 संदर्भ पृष्ठ



बनाया गया 2024-02-20, अपडेट किया गया 2024-07-04
लेखक: ग्लेन-जोचर (9), महत्वाकांक्षी-ऑक्टोपस (1), इवोरझू331 (1), रिजवान मुनव्वर (1), बुरहान-क्यू (2)

टिप्पणियाँ