Zum Inhalt springen

Einfache Dienstprogramme

Code mit Perspektive

Die ultralytics Paket bietet eine Vielzahl von Dienstprogrammen zur Unterstützung, Verbesserung und Beschleunigung Ihrer Arbeitsabläufe. Es sind zwar noch viele weitere verfügbar, aber dieser Leitfaden hebt einige der nützlichsten für Entwickler hervor und dient als praktische Referenz für die Programmierung mit Ultralytics .



Beobachten: Ultralytics Dienstprogramme | Automatische Beschriftung, Explorer API und Datensatzkonvertierung

Daten

Automatische Beschriftung/Anmerkungen

Die Annotation von Datensätzen ist ein ressourcen- und zeitaufwändiger Prozess. Wenn Sie über ein Ultralytics YOLO-Objekterkennungsmodell verfügen, das auf eine angemessene Datenmenge trainiert wurde, können Sie es mit SAM verwenden, um zusätzliche Daten im Segmentierungsformat automatisch zu annotieren.

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

Diese Funktion gibt keinen Wert zurück. Für weitere Einzelheiten:

Datensatzanmerkungen visualisieren

Diese Funktion visualisiert YOLO Anmerkungen auf einem Bild vor dem Training und hilft dabei, falsche Anmerkungen zu identifizieren und zu korrigieren, die zu falschen Erkennungsergebnissen führen könnten. Sie zeichnet Begrenzungsrahmen (Bounding Boxes), beschriftet Objekte mit Klassennamen und passt die Textfarbe zur besseren Lesbarkeit an die Helligkeit des Hintergrunds an.

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

Konvertieren von Segmentierungsmasken in das Format YOLO

Segmentierungsmasken auf YOLO Format

Verwenden Sie dies, um einen Datensatz von Segmentierungsmaskenbildern in das Ultralytics YOLO Segmentierungsformat. Diese Funktion nimmt das Verzeichnis, das die Maskenbilder im Binärformat enthält, und konvertiert sie in das YOLO .

Die konvertierten Masken werden in dem angegebenen Ausgabeverzeichnis gespeichert.

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 in das Format YOLO umwandeln

Benutzen Sie dies zum Konvertieren COCO JSON-Anmerkungen in das YOLO . Für Objekterkennungsdatensätze (Bounding Box), setzen Sie beide use_segments und use_keypoints zu False.

from ultralytics.data.converter import convert_coco

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

Für weitere Informationen über die convert_coco Funktion, Besuchen Sie die Referenzseite.

Bounding Box Abmessungen erhalten

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()}")

Bounding Boxes in Segmente umwandeln

Mit bestehenden x y w h Bounding-Box-Daten, konvertieren in Segmente mit der yolo_bbox2segment Funktion. Organisieren Sie die Dateien für Bilder und Anmerkungen wie folgt:

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

Besuchen Sie die yolo_bbox2segment Referenzseite für weitere Informationen zu dieser Funktion.

Segmente in Bounding Boxes umwandeln

Wenn Sie einen Datensatz haben, der die Format des Segmentierungsdatensatzeskönnen Sie diese leicht in aufrechte (oder horizontale) Begrenzungsrahmen umwandeln (x y w h Format) mit dieser Funktion.

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

Um zu verstehen, wie diese Funktion funktioniert, besuchen Sie die Referenzseite.

Versorgungsunternehmen

Bildkomprimierung

Komprimiert eine einzelne Bilddatei auf eine geringere Größe, wobei das Seitenverhältnis und die Qualität erhalten bleiben. Wenn das Eingabebild kleiner als die maximale Größe ist, wird es nicht verkleinert.

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)

Automatisch geteilter Datensatz

Automatisches Aufteilen eines Datensatzes in train/val/test Splits und speichern die resultierenden Splits in autosplit_*.txt Dateien. Diese Funktion verwendet eine Zufallsstichprobe, die bei Verwendung der Funktion fraction Argument für die Ausbildung.

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
)

Weitere Einzelheiten zu dieser Funktion finden Sie auf der Seite Referenz.

Segment-Polygon zu Binärmaske

Konvertiert ein einzelnes Polygon (als Liste) in eine binäre Maske mit der angegebenen Bildgröße. Das Polygon sollte die folgende Form haben [N, 2], wobei N ist die Anzahl der (x, y) Punkte, die die Polygonkontur definieren.

Warnung

N muss immer ausgeglichen sein.

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

Bounding Boxes

Bounding Box (Horizontal) Instanzen

Um Bounding-Box-Daten zu verwalten, muss die Bboxes hilft bei der Konvertierung zwischen Box-Koordinatenformaten, bei der Skalierung von Box-Abmessungen, bei der Berechnung von Flächen, bei der Einbeziehung von Offsets und vielem mehr.

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]]
# )

Siehe die Bboxes Referenzteil für weitere Attribute und Methoden.

Tipp

Auf viele der folgenden Funktionen (und mehr) kann mit dem Befehl Bboxes KlasseWenn Sie es jedoch vorziehen, direkt mit den Funktionen zu arbeiten, lesen Sie in den nächsten Unterabschnitten, wie Sie sie unabhängig voneinander importieren können.

Skalierungsboxen

Wenn Sie ein Bild nach oben oder unten skalieren, können Sie die entsprechenden Bounding-Box-Koordinaten entsprechend skalieren, indem Sie 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]]
# )

Bounding Box Format Konvertierungen

XYXY → XYWH

Konvertiert Bounding-Box-Koordinaten vom Format (x1, y1, x2, y2) in das Format (x, y, Breite, Höhe), wobei (x1, y1) die obere linke Ecke und (x2, y2) die untere rechte Ecke ist.

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]]
# )

Alle Bounding Box-Konvertierungen

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

Siehe den Docstring für jede Funktion oder besuchen Sie die ultralytics.utils.ops Referenzseite um mehr zu lesen.

Plotten

Zeichnen von Kommentaren

Ultralytics umfasst eine Annotator Klasse zur Kommentierung verschiedener Datentypen. Sie wird am besten verwendet mit Objekterkennung Bounding Boxes, Keypoints aufstellenund orientierte Bounding Boxes.

Ultralytics Sweep-Anmerkung

Python mit Ultralytics YOLO 🚀

import cv2

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

# 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, y, flags, param):  # Mouse callback for dragging line.
    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.
    annotator = SolutionAnnotator(im0)
    results = model.track(im0, persist=True)  # Track objects using track method.
    if f == 1:
        cv2.namedWindow(window_name)
        cv2.setMouseCallback(window_name, drag_line)

    if results[0].boxes.id is not None:
        if results[0].masks is not None:
            masks = results[0].masks.xy
        track_ids = results[0].boxes.id.int().cpu().tolist()
        clss = results[0].boxes.cls.cpu().tolist()
        boxes = results[0].boxes.xyxy.cpu()

        for mask, box, cls, t_id in zip(masks or [None] * len(boxes), boxes, clss, track_ids):
            color = colors(t_id, True)  # Assign different color to each tracked object.
            if mask is not None and mask.size > 0:
                # If you want to overlay the masks
                # mask[:, 0] = np.clip(mask[:, 0], line_x, w)
                # mask_img = cv2.fillPoly(im0.copy(), [mask.astype(int)], color)
                # cv2.addWeighted(mask_img, 0.5, im0, 0.5, 0, im0)

                if box[0] > line_x:
                    count += 1
                    annotator.seg_bbox(mask=mask, mask_color=color, label=str(classes[cls]))
            else:
                if box[0] > line_x:
                    count += 1
                    annotator.box_label(box=box, color=color, label=str(classes[cls]))

    annotator.sweep_annotator(line_x=line_x, line_y=h, label=f"COUNT:{count}")  # Display the sweep
    cv2.imshow(window_name, im0)
    video_writer.write(im0)
    if cv2.waitKey(1) & 0xFF == ord("q"):
        break

cap.release()  # Release the video capture.
video_writer.release()  # Release the video writer.
cv2.destroyAllWindows()  # Destroy all opened windows.

Horizontale Bounding Boxes

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()

Namen können verwendet werden von model.names wenn Arbeit mit Detektionsergebnissen.

Orientierte Bounding Boxes (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()

Bounding Boxes Kreis Annotation Kreis Beschriftung



Beobachten: Ausführlicher Leitfaden für Text- und Kreisanmerkungen mit Python Live-Demos | Ultralytics Annotations 🚀 

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()

Bounding Boxes Text Anmerkung Text Beschriftung

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()

Siehe die Annotator Referenzseite für zusätzliche Einblicke.

Sonstiges

Code-Profiling

Prüfen Sie die Dauer für die Ausführung/Bearbeitung des Codes entweder mit with oder als Dekorateur.

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 Unterstützte Formate

Müssen Sie die unterstützten Bild- oder Videoformate in Ultralytics programmatisch verwenden? Verwenden Sie bei Bedarf diese Konstanten:

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'}

Teilbar machen

Berechnen Sie die nächstliegende ganze Zahl bis x die gleichmäßig teilbar ist durch y.

from ultralytics.utils.ops import make_divisible

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

FAQ

Welche Dienstprogramme sind im Paket Ultralytics enthalten, um Arbeitsabläufe des maschinellen Lernens zu verbessern?

Das Ultralytics enthält Dienstprogramme zur Rationalisierung und Optimierung von Arbeitsabläufen beim maschinellen Lernen. Zu den wichtigsten Dienstprogrammen gehören die automatische Beschriftung von Datensätzen, die Konvertierung von COCO in das YOLO mit convert_coco, die Komprimierung von Bildern und die automatische Aufteilung von Datensätzen. Diese Tools reduzieren den manuellen Aufwand, gewährleisten Konsistenz und verbessern die Effizienz der Datenverarbeitung.

Wie kann ich Ultralytics verwenden, um meinen Datensatz automatisch zu beschriften?

Wenn Sie über ein vorab trainiertes Ultralytics YOLO Objekterkennungsmodell verfügen, können Sie es mit dem SAM Modell verwenden, um Ihren Datensatz automatisch im Segmentierungsformat zu annotieren. Hier ist ein Beispiel:

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

Weitere Einzelheiten finden Sie im Abschnitt auto_annotate reference.

Wie konvertiere ich COCO-Datensatz-Anmerkungen in das Format YOLO in Ultralytics?

Um COCO-JSON-Annotationen für die Objekterkennung in das Format YOLO zu konvertieren, können Sie die convert_coco Dienstprogramm. Hier ist ein Beispiel-Code-Schnipsel:

from ultralytics.data.converter import convert_coco

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

Weitere Informationen finden Sie auf der Referenzseite von convert_coco.

Welchen Zweck erfüllt der YOLO Data Explorer im Paket Ultralytics ?

Die YOLO Entdecker ist ein leistungsfähiges Instrument, das in der 8.1.0 Update, um das Verständnis von Datensätzen zu verbessern. Es ermöglicht Ihnen die Verwendung von Textabfragen, um Objektinstanzen in Ihrem Datensatz zu finden und erleichtert so die Analyse und Verwaltung Ihrer Daten. Dieses Tool bietet wertvolle Einblicke in die Zusammensetzung und Verteilung von Datensätzen und hilft dabei, die Modellschulung und -leistung zu verbessern.

Wie kann ich in Ultralytics Boundingboxen in Segmente umwandeln?

So konvertieren Sie vorhandene Bounding-Box-Daten (in x y w h Format) zu Segmenten, können Sie die yolo_bbox2segment Funktion. Stellen Sie sicher, dass Ihre Dateien mit separaten Verzeichnissen für Bilder und Etiketten organisiert sind.

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

Weitere Informationen finden Sie auf der Referenzseiteyolo_bbox2segment.

📅 Erstellt vor 1 Jahr ✏️ Aktualisiert vor 5 Tagen
glenn-jocher RizwanMunawar UltralyticsAssistent Ehrgeizig-octopus IvorZhu331 Burhan-Q

Kommentare