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

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

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

वही 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 प्रारूप) इस फ़ंक्शन के साथ।

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 कक्षा बॉक्स समन्वय स्वरूपण, स्केल बॉक्स आयाम, क्षेत्रों की गणना, ऑफसेट शामिल करने, और बहुत कुछ के बीच परिवर्तित करने में मदद करेगी!

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")
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,
)

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)

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 xywh2xyxy
from ultralytics.utils.ops import xywhn2xyxy # normalized → pixel
from ultralytics.utils.ops import xyxy2xywhn # pixel → normalized
from ultralytics.utils.ops import xywh2ltwh  # xywh → top-left corner, w, h
from ultralytics.utils.ops import xyxy2ltwh  # xyxy → top-left corner, w, h
from ultralytics.utils.ops import ltwh2xywh
from ultralytics.utils.ops import ltwh2xyxy

प्रत्येक फ़ंक्शन के लिए 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"{names.get(int(c_idx))}"
    ann.box_label(
        obb,
        label,
        color=colors(c_idx, True),
        rotated=True,
    )

image_with_obb = ann.result()

देखें Annotator संदर्भ पृष्ठ अतिरिक्त जानकारी के लिए।

फुटकर

कोड प्रोफाइलिंग

या तो उपयोग करके कोड को चलाने/संसाधित करने के लिए अवधि की जाँच करें with या एक डेकोरेटर के रूप में।

from ultralytics.utils.ops import Profile

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

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

Ultralytics समर्थित प्रारूप

द्वारा समर्थित छवियों या वीडियो प्रकारों के प्रारूपों का उपयोग करना चाहते हैं या करना चाहते हैं Ultralytics प्रोग्राम? यदि आपको आवश्यकता हो तो इन स्थिरांकों का उपयोग करें।

from ultralytics.data.utils import IMG_FORMATS
from ultralytics.data.utils import VID_FORMATS

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

विभाज्य बनाओ

निकटतम पूर्ण संख्या की गणना करता है x द्वारा विभाजित होने पर समान रूप से विभाज्य बनाने के लिए y.

from ultralytics.utils.ops import make_divisible

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


2024-02-20 बनाया गया, अपडेट किया गया 2024-04-05
लेखक: रिज़वानमुनव्वर (1), बुरहान-क्यू (2), ग्लेन-जोचर (1)

टिप्पणियाँ