Zum Inhalt springen

Einfache Dienstprogramme

Code mit Perspektive

Die ultralytics Paket wird mit einer Vielzahl von Dienstprogrammen geliefert, die deine Arbeitsabläufe unterstützen, verbessern und beschleunigen können. Es gibt noch viele weitere, aber hier sind einige, die für die meisten Entwickler/innen nützlich sind. Sie sind auch ein guter Bezugspunkt, wenn du programmieren lernst.



Pass auf: Ultralytics Dienstprogramme | Auto Annotation, Explorer API und Dataset Conversion

Daten

YOLO Daten-Explorer

YOLO Entdecker wurde in der 8.1.0 und ist ein leistungsstarkes Werkzeug, mit dem du deinen Datensatz besser verstehen kannst. Eine der wichtigsten Funktionen von YOLO Explorer ist die Möglichkeit, mit Textabfragen Objektinstanzen in deinem Datensatz zu finden.

Automatische Beschriftung / Anmerkungen

Die Annotation von Datensätzen ist ein sehr ressourcenintensiver und zeitaufwändiger Prozess. Wenn du ein YOLO Objekterkennungsmodell hast, das auf einer angemessenen Menge von Daten trainiert wurde, kannst du es verwenden und SAM um zusätzliche Daten automatisch zu annotieren (Segmentierungsformat).

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. Von dieser Funktion kommt nichts zurĂĽck

  2. Siehe den Referenzabschnitt fĂĽr annotator.auto_annotate um mehr darĂĽber zu erfahren, wie die Funktion funktioniert.

  3. Verwendung in Kombination mit dem Funktion segments2boxes um auch Boundingboxen fĂĽr die Objekterkennung zu erstellen

Segmentierungsmasken in das Format YOLO umwandeln

Segmentierung Masken auf YOLO Format

Dient dazu, einen Datensatz von Segmentierungsmaskenbildern in die YOLO Segmentierungsformat. Diese Funktion nimmt das Verzeichnis, das die Maskenbilder im Binärformat enthält, und wandelt sie in das Segmentierungsformat YOLO um.

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 ins YOLO Format konvertieren

Konvertiert COCO JSON-Annotationen in das richtige YOLO Format. Für Datensätze zur Objekterkennung (Bounding Box), use_segments und use_keypoints sollten beide False

from ultralytics.data.converter import convert_coco

convert_coco(  # (1)!
    "../datasets/coco/annotations/",
    use_segments=False,
    use_keypoints=False,
    cls91to80=True,
)
  1. Von dieser Funktion kommt nichts zurĂĽck

Für zusätzliche Informationen über die convert_coco Funktion, besuche die Referenzseite

Bounding Box Abmessungen erhalten

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

Bounding Boxes in Segmente umwandeln

Mit bestehenden x y w h Bounding-Box-Daten, konvertiere sie in Segmente, indem du die yolo_bbox2segment Funktion. Die Dateien fĂĽr Bilder und Anmerkungen mĂĽssen wie folgt organisiert werden:

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. Von dieser Funktion kommt nichts zurĂĽck

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

Segmente in Bounding Boxes umwandeln

Wenn du einen Datensatz hast, der die Format des Segmentierungsdatensatzes kannst du diese ganz einfach in Up-Right (oder horizontale) Bounding Boxes 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, besuche die Referenzseite

Versorgungsunternehmen

Bildkomprimierung

Komprimiert eine einzelne Bilddatei auf eine geringere Größe, wobei das Seitenverhältnis und die Qualität des Bildes erhalten bleiben. Wenn das Eingangsbild 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)  # (1)!
  1. Von dieser Funktion kommt nichts zurĂĽck

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 nicht enthalten ist, wenn du fraction Argument fĂĽr die Ausbildung.

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. Von dieser Funktion kommt nichts zurĂĽck

Weitere Informationen zu dieser Funktion findest du 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. Polygon in Form von [N, 2] mit N als die Anzahl der (x, y) Punkte, die die Polygonkontur definieren.

Warnung

N muss immer gerade 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 Klasse hilft dir dabei, zwischen verschiedenen Koordinatenformaten zu konvertieren, die Abmessungen von Boxen zu skalieren, Flächen zu berechnen, Offsets zu berücksichtigen und vieles 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 Referenzabschnitt fĂĽr weitere verfĂĽgbare Attribute und Methoden.

Tipp

Auf viele der folgenden Funktionen (und mehr) kann mit der Bboxes Klasse Wenn du aber lieber direkt mit den Funktionen arbeiten möchtest, erfährst du in den nächsten Unterabschnitten, wie du sie unabhängig voneinander importieren kannst.

Skalierungsboxen

Wenn ein Bild nach oben oder unten skaliert wird, können die entsprechenden Bounding-Box-Koordinaten mithilfe von 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. Bounding Boxes skaliert für die neue Bildgröße

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 Umrechnungen

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 Docstring fĂĽr jede Funktion oder besuche die ultralytics.utils.ops Referenzseite um mehr ĂĽber jede Funktion zu erfahren.

Plotten

Anmerkungen zeichnen

Ultralytics enthält eine Annotator-Klasse, mit der du jede Art von Daten annotieren kannst. Am einfachsten ist es, sie für Bounding Boxes zur Objekterkennung, Pose Key Points und orientierte Bounding Boxes zu verwenden.

Horizontale Bounding Boxes

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. Namen können verwendet werden von model.names wenn Arbeit mit Aufdeckungsergebnissen

Oriented 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 Kreisbeschriftung(Circle Label)

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

Bounding Boxes Textbeschriftung(Text Label)

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

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

Sonstiges

Code Profiling

ĂśberprĂĽfe 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

Willst oder musst du die von Ultralytics unterstĂĽtzten Bild- oder Videoformate programmatisch verwenden? Verwende diese Konstanten, wenn du sie brauchst.

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

Berechnet die nächstliegende ganze Zahl zu x gleichmäßig teilbar zu machen, wenn es 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 beim maschinellen Lernen zu verbessern?

Das Paket Ultralytics enthält eine Reihe von Dienstprogrammen, die die Arbeitsabläufe beim maschinellen Lernen vereinfachen und optimieren. Zu den wichtigsten Werkzeugen gehören die automatische Beschriftung von Datensätzen, die Konvertierung von COCO in das Format YOLO mit convert_coco, die Komprimierung von Bildern und die automatische Aufteilung von Datensätzen. Diese Tools sollen den manuellen Aufwand reduzieren, Konsistenz gewährleisten und die Effizienz der Datenverarbeitung steigern.

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

Wenn du ein vortrainiertes Ultralytics YOLO Objekterkennungsmodell hast, kannst du es mit dem SAM Modell verwenden, um deinen 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="yolov8n.pt",
    sam_model="mobile_sam.pt",
    device="cuda",
    output_dir="path/to/save_labels",
)

Weitere Details findest du im Referenzabschnitt zu auto_annotate.

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, kannst du die convert_coco Dienstprogramm. Hier ist ein Beispiel fĂĽr einen Codeschnipsel:

from ultralytics.data.converter import convert_coco

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

Weitere Informationen findest du auf der convert_coco-Referenzseite.

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

Die YOLO Entdecker ist ein mächtiges Werkzeug, das in der 8.1.0 Update, um das Verständnis von Datensätzen zu verbessern. Es ermöglicht dir, Textabfragen zu verwenden, um Objektinstanzen in deinem Datensatz zu finden, was die Analyse und Verwaltung deiner Daten erleichtert. Dieses Tool bietet wertvolle Einblicke in die Zusammensetzung und Verteilung von Datensätzen und hilft dabei, das Training und die Leistung von Modellen zu verbessern.

Wie kann ich Boundingboxen in Ultralytics in Segmente umwandeln?

So konvertieren Sie vorhandene Bounding-Box-Daten (in x y w h Format) zu Segmenten, kannst du die yolo_bbox2segment Funktion. Achte darauf, dass deine 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 findest du auf der Referenzseiteyolo_bbox2segment.


📅 Created 6 months ago ✏️ Updated 16 days ago
RizwanMunawar glenn-jocher Ehrgeizig-octopus IvorZhu331 Burhan-Q

Kommentare