Objekterkennung

Objekterkennung ist eine Aufgabe, die das Identifizieren der Position und der Klasse von Objekten in einem Bild- oder Videostrom umfasst.

Die Ausgabe eines Objektdetektors ist eine Menge von Begrenzungsrahmen (Bounding Boxes), die die Objekte im Bild umschließen, zusammen mit Klassenbeschriftungen und Konfidenzwerten für jeden Rahmen. Objekterkennung ist eine gute Wahl, wenn du Objekte von Interesse in einer Szene identifizieren musst, aber nicht genau wissen musst, wo sich das Objekt befindet oder welche Form es exakt hat.

Modelle

YOLO26 vortrainierte Detect-Modelle werden hier gezeigt. Detect-, Segment- und Pose-Modelle sind auf dem COCO-Datensatz vortrainiert, Semantic-Modelle sind auf Cityscapes vortrainiert und Classify-Modelle sind auf dem ImageNet-Datensatz vortrainiert.

Modelle werden bei der ersten Verwendung automatisch vom neuesten Ultralytics Release heruntergeladen.

• mAP^val-Werte gelten für ein Einzelmodell mit Einzelskalierung auf dem COCO val2017-Datensatz.
  Reproduziere dies mit yolo val detect data=coco.yaml device=0
• Geschwindigkeit gemittelt über COCO val-Bilder unter Verwendung einer Amazon EC2 P4d-Instanz.
  Reproduziere dies mit yolo val detect data=coco.yaml batch=1 device=0|cpu
• Parameter und FLOPs-Werte beziehen sich auf das fusionierte Modell nach model.fuse(), das Conv- und BatchNorm-Schichten zusammenführt und bei End-to-End-Modellen den zusätzlichen One-to-Many-Erkennungskopf entfernt. Vortrainierte Checkpoints behalten die vollständige Trainingsarchitektur bei und können höhere Zahlen aufweisen.

Trainieren

Trainiere YOLO26n auf dem COCO8-Datensatz für 100 Epochen bei einer Bildgröße von 640. Eine vollständige Liste der verfügbaren Argumente findest du auf der Seite Konfiguration.

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n.yaml")  # build a new model from YAML
model = YOLO("yolo26n.pt")  # load a pretrained model (recommended for training)
model = YOLO("yolo26n.yaml").load("yolo26n.pt")  # build from YAML and transfer weights

# Train the model
results = model.train(data="coco8.yaml", epochs=100, imgsz=640)

Siehe vollständige train-Modus-Details auf der Seite Trainieren. Detection-Modelle können auch über die Ultralytics Plattform auf Cloud-GPUs trainiert werden.

Datensatzformat

Das YOLO-Detection-Datensatzformat ist im Detail im Datensatz-Leitfaden beschrieben. Um deinen bestehenden Datensatz aus anderen Formaten (wie COCO usw.) in das YOLO-Format zu konvertieren, verwende bitte das JSON2YOLO-Tool von Ultralytics. Du kannst Detection-Datensätze auch direkt auf der Ultralytics Plattform mit KI-gestützten Labeling-Tools annotieren und verwalten.

Validieren

Validiere die Genauigkeit des trainierten YOLO26n-Modells auf dem COCO8-Datensatz. Es sind keine Argumente erforderlich, da das model seine Trainings-data und Argumente als Modellattribute behält.

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n.pt")  # load an official model
model = YOLO("path/to/best.pt")  # load a custom model

# Validate the model
metrics = model.val()  # no arguments needed, dataset and settings remembered
metrics.box.map  # map50-95
metrics.box.map50  # map50
metrics.box.map75  # map75
metrics.box.maps  # a list containing mAP50-95 for each category
metrics.box.image_metrics  # per-image metrics dictionary with precision, recall, F1, TP, FP, and FN

Vorhersagen

Verwende ein trainiertes YOLO26n-Modell, um Vorhersagen auf Bildern auszuführen.

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n.pt")  # load an official model
model = YOLO("path/to/best.pt")  # load a custom model

# Predict with the model
results = model("https://ultralytics.com/images/bus.jpg")  # predict on an image

# Access the results
for result in results:
    xywh = result.boxes.xywh  # center-x, center-y, width, height
    xywhn = result.boxes.xywhn  # normalized
    xyxy = result.boxes.xyxy  # top-left-x, top-left-y, bottom-right-x, bottom-right-y
    xyxyn = result.boxes.xyxyn  # normalized
    names = [result.names[cls.item()] for cls in result.boxes.cls.int()]  # class name of each box
    confs = result.boxes.conf  # confidence score of each box

Siehe vollständige predict-Modus-Details auf der Seite Vorhersagen.

Ergebnisausgabe

Die Objekterkennung gibt ein Results-Objekt pro Bild zurück. Das primäre Vorhersagefeld ist result.boxes, das die Box-Koordinaten, Klassen-IDs und Konfidenzwerte für jedes erkannte Objekt enthält.

Für aufgabenspezifische Results-Felder über alle Aufgaben hinweg siehe den Abschnitt Vorhersageergebnisse nach Aufgabe.

Exportieren

Exportiere ein YOLO26n-Modell in ein anderes Format wie ONNX, CoreML usw.

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n.pt")  # load an official model
model = YOLO("path/to/best.pt")  # load a custom-trained model

# Export the model
model.export(format="onnx")

Verfügbare YOLO26-Exportformate sind in der Tabelle unten aufgeführt. Du kannst mit dem format-Argument in jedes Format exportieren, d. h. format='onnx' oder format='engine'. Du kannst direkt auf exportierten Modellen vorhersagen oder validieren, d. h. yolo predict model=yolo26n.onnx. Verwendungsbeispiele werden für dein Modell nach Abschluss des Exports angezeigt.

Details zu export findest du auf der Seite Export.

FAQ

Kann ich Erkennungsmodelle ohne Programmieren trainieren und bereitstellen?

Ja. Die Ultralytics Platform bietet einen browserbasierten Workflow zur Annotation von Datensätzen, zum Training von Erkennungsmodellen auf Cloud-GPUs und zur Bereitstellung an Inference-Endpoints. Siehe den Platform-Schnellstart, um loszulegen.

Wie trainiere ich ein YOLO26-Modell mit meinem eigenen Datensatz?

Das Training eines YOLO26-Modells mit einem benutzerdefinierten Datensatz umfasst einige Schritte:

1. Datensatz vorbereiten: Stelle sicher, dass dein Datensatz im YOLO-Format vorliegt. Hinweise findest du in unserem Datensatz-Leitfaden.
2. Modell laden: Verwende die Ultralytics YOLO-Bibliothek, um ein vortrainiertes Modell zu laden oder ein neues Modell aus einer YAML-Datei zu erstellen.
3. Modell trainieren: Führe die train-Methode in Python oder den yolo detect train-Befehl im CLI aus.

from ultralytics import YOLO

# Load a pretrained model
model = YOLO("yolo26n.pt")

# Train the model on your custom dataset
model.train(data="my_custom_dataset.yaml", epochs=100, imgsz=640)

Detaillierte Konfigurationsoptionen findest du auf der Seite Konfiguration.

Welche vortrainierten Modelle sind in YOLO26 verfügbar?

Ultralytics YOLO26 bietet verschiedene vortrainierte Modelle für Objekterkennung, Instanzsegmentierung, semantische Segmentierung und Pose-Schätzung. Diese Modelle wurden auf dem COCO-Datensatz, Cityscapes für semantische Segmentierung oder ImageNet für Klassifizierungsaufgaben vortrainiert. Hier sind einige der verfügbaren Modelle:

• YOLO26n
• YOLO26s
• YOLO26m
• YOLO26l
• YOLO26x

Eine detaillierte Liste und Leistungsmetriken findest du im Abschnitt Modelle.

Wie kann ich die Genauigkeit meines trainierten YOLO-Modells validieren?

Um die Genauigkeit deines trainierten YOLO26-Modells zu validieren, kannst du die .val()-Methode in Python oder den yolo detect val-Befehl im CLI verwenden. Dies liefert Metriken wie mAP50-95, mAP50 und mehr.

from ultralytics import YOLO

# Load the model
model = YOLO("path/to/best.pt")

# Validate the model
metrics = model.val()
print(metrics.box.map)  # mAP50-95

Weitere Details zur Validierung findest du auf der Seite Val.

In welche Formate kann ich ein YOLO26-Modell exportieren?

Ultralytics YOLO26 ermöglicht den Export von Modellen in verschiedene Formate wie ONNX, TensorRT, CoreML und mehr, um die Kompatibilität über verschiedene Plattformen und Geräte hinweg zu gewährleisten.

from ultralytics import YOLO

# Load the model
model = YOLO("yolo26n.pt")

# Export the model to ONNX format
model.export(format="onnx")

Die vollständige Liste der unterstützten Formate und Anleitungen findest du auf der Seite Export.

Warum sollte ich Ultralytics YOLO26 für die Objekterkennung verwenden?

Ultralytics YOLO26 wurde entwickelt, um erstklassige Leistung für Objekterkennung, Instanzsegmentierung, semantische Segmentierung und Pose-Schätzung zu bieten. Hier sind einige wichtige Vorteile:

1. Vortrainierte Modelle: Nutze Modelle, die auf populären Datensätzen wie COCO und ImageNet vortrainiert wurden, für eine schnellere Entwicklung.
2. Hohe Genauigkeit: Erzielt beeindruckende mAP-Werte und sorgt so für eine zuverlässige Objekterkennung.
3. Geschwindigkeit: Optimiert für Echtzeit-Inferenz, ideal für Anwendungen, die eine schnelle Verarbeitung erfordern.
4. Flexibilität: Exportiere Modelle in verschiedene Formate wie ONNX und TensorRT für die Bereitstellung auf mehreren Plattformen.

Entdecke unseren Blog für Anwendungsfälle und Erfolgsgeschichten, in denen YOLO26 im Einsatz ist.