Ultralytics installieren
Ultralytics bietet verschiedene Installationsmethoden an, darunter pip, conda und Docker. Sie können YOLO über die folgenden Wege installieren: ultralytics
pip-Paket für die neueste stabile Version oder durch Klonen des Ultralytics GitHub-Repositorys für die aktuellste Version. Docker ist auch eine Option, um das Paket in einem isolierten Container auszuführen, wodurch eine lokale Installation vermieden wird.
Ansehen: Ultralytics YOLO – Schnellstartanleitung
Installieren
Installieren oder aktualisieren Sie das ultralytics
Package mit pip durch Ausführen von pip install -U ultralytics
. Weitere Informationen zum ultralytics
Package zu installieren, besuchen Sie die Python Package Index (PyPI).
# Install the ultralytics package from PyPI
pip install ultralytics
Sie können auch installieren ultralytics
direkt aus dem Ultralytics GitHub-Repositorys. Dies kann nützlich sein, wenn Sie die neueste Entwicklungsversion wünschen. Stellen Sie sicher, dass Sie das Git-Befehlszeilentool installiert haben, und führen Sie dann Folgendes aus:
# Install the ultralytics package from GitHub
pip install git+https://github.com/ultralytics/ultralytics.git@main
Conda kann als alternative Paketverwaltung zu pip verwendet werden. Weitere Informationen finden Sie unter Anaconda. Das Ultralytics Feedstock-Repository zur Aktualisierung des Conda-Pakets ist auf GitHub verfügbar.
# Install the ultralytics package using conda
conda install -c conda-forge ultralytics
Hinweis
Wenn Sie in einer CUDA-Umgebung installieren, ist es am besten, ultralytics
, pytorch
und pytorch-cuda
im selben Befehl. Dies ermöglicht es dem Conda-Paketmanager, alle Konflikte zu lösen. Alternativ installieren Sie pytorch-cuda
zuletzt die CPU-spezifische Einstellung überschreiben pytorch
Paket bei Bedarf überschreiben kann.
# Install all packages together using conda
conda install -c pytorch -c nvidia -c conda-forge pytorch torchvision pytorch-cuda=11.8 ultralytics
Conda Docker Image
Ultralytics Conda Docker-Images sind auch von DockerHubverfügbar. Diese Images basieren auf und bieten eine unkomplizierte Möglichkeit, mit der Nutzung von ultralytics
in einer Conda-Umgebung zu beginnen.
# Set image name as a variable
t=ultralytics/ultralytics:latest-conda
# Pull the latest ultralytics image from Docker Hub
sudo docker pull $t
# Run the ultralytics image in a container with GPU support
sudo docker run -it --ipc=host --gpus all $t # all GPUs
sudo docker run -it --ipc=host --gpus '"device=2,3"' $t # specify GPUs
Klonen Sie das Ultralytics GitHub-Repositorys wenn Sie an einer Mitarbeit an der Entwicklung interessiert sind oder mit dem neuesten Quellcode experimentieren möchten. Navigieren Sie nach dem Klonen in das Verzeichnis und installieren Sie das Paket im bearbeitbaren Modus -e
mit pip.
# Clone the ultralytics repository
git clone https://github.com/ultralytics/ultralytics
# Navigate to the cloned directory
cd ultralytics
# Install the package in editable mode for development
pip install -e .
Verwenden Sie Docker, um die ultralytics
Package in einem isolierten Container, um eine konsistente Leistung in verschiedenen Umgebungen zu gewährleisten. Wählen Sie eines der offiziellen ultralytics
Images von Docker Hub, vermeiden Sie die Komplexität der lokalen Installation und erhalten Zugriff auf eine verifizierte Arbeitsumgebung. Ultralytics bietet fünf Haupt-Docker-Images mit Support, die jeweils auf hohe Kompatibilität und Effizienz ausgelegt sind:
- Dockerfile: Für das Training empfohlenes GPU-Image.
- Dockerfile-arm64: Optimiert für die ARM64-Architektur, geeignet für den Einsatz auf Geräten wie Raspberry Pi und anderen ARM64-basierten Plattformen.
- Dockerfile-cpu: Ubuntu-basierte CPU-only-Version, geeignet für Inferenz und Umgebungen ohne GPUs.
- Dockerfile-jetson: Zugeschnitten auf NVIDIA Jetson-Geräte, Integration von GPU-Unterstützung, optimiert für diese Plattformen.
- Dockerfile-python: Minimales Image mit nur Python und den notwendigen Abhängigkeiten, ideal für schlanke Anwendungen und Entwicklung.
- Dockerfile-conda: Basierend auf Miniconda3 mit einer Conda-Installation von
ultralytics
Package.
Hier sind die Befehle, um das neueste Image zu beziehen und auszuführen:
# Set image name as a variable
t=ultralytics/ultralytics:latest
# Pull the latest ultralytics image from Docker Hub
sudo docker pull $t
# Run the ultralytics image in a container with GPU support
sudo docker run -it --ipc=host --gpus all $t # all GPUs
sudo docker run -it --ipc=host --gpus '"device=2,3"' $t # specify GPUs
Der obige Befehl initialisiert einen Docker-Container mit dem neuesten ultralytics
Image. Der -it
weisen ein Pseudo-TTY zu und halten stdin offen, was die Interaktion mit dem Container ermöglicht. Das --ipc=host
Flag setzt den IPC-Namespace (Inter-Process Communication) auf den Host, was für die gemeinsame Nutzung von Speicher zwischen Prozessen unerlässlich ist. Der --gpus all
aktiviert den Zugriff auf alle verfügbaren GPUs innerhalb des Containers, was für Aufgaben, die GPU-Berechnungen erfordern, entscheidend ist.
Hinweis: Um mit Dateien auf Ihrem lokalen Rechner innerhalb des Containers zu arbeiten, verwenden Sie Docker-Volumes, um ein lokales Verzeichnis in den Container einzubinden:
# Mount local directory to a directory inside the container
sudo docker run -it --ipc=host --gpus all -v /path/on/host:/path/in/container $t
Ersetzen Sie /path/on/host
mit dem Verzeichnispfad auf Ihrem lokalen Rechner und /path/in/container
durch den gewünschten Pfad innerhalb des Docker-Containers.
Für die fortgeschrittene Docker-Nutzung erkunden Sie den Ultralytics Docker Guide.
Siehe die ultralytics
pyproject.toml Datei für eine Liste der Abhängigkeiten. Beachten Sie, dass alle obigen Beispiele alle erforderlichen Abhängigkeiten installieren.
Tipp
Die PyTorch-Anforderungen variieren je nach Betriebssystem und CUDA-Anforderungen. Installieren Sie PyTorch daher zuerst, indem Sie den Anweisungen unter PyTorch folgen.
Benutzerdefinierte Installationsmethoden
Während die Standardinstallationsmethoden die meisten Anwendungsfälle abdecken, benötigen Sie möglicherweise eine stärker angepasste Einrichtung. Dies könnte die Installation bestimmter Paketversionen, das Weglassen optionaler Abhängigkeiten oder das Ersetzen von Paketen wie dem Austausch von opencv-python
mit der GUI-losen opencv-python-headless
für Serverumgebungen.
Benutzerdefinierte Methoden
Sie können das installieren ultralytics
package core ohne Abhängigkeiten mit pip --no-deps
Flag. Dies erfordert, dass Sie anschließend alle notwendigen Abhängigkeiten manuell installieren.
-
Installieren
ultralytics
Kern:pip install ultralytics --no-deps
-
Abhängigkeiten manuell installieren: Sie müssen alle erforderlichen Pakete installieren, die in der
pyproject.toml
Datei, wobei Versionen nach Bedarf ersetzt oder modifiziert werden. Für das Headless OpenCV-Beispiel:# Install other core dependencies pip install torch torchvision numpy matplotlib polars pyyaml pillow psutil requests scipy seaborn ultralytics-thop # Install headless OpenCV instead of the default pip install opencv-python-headless
Dependency Management
Diese Methode bietet volle Kontrolle, erfordert aber eine sorgfältige Verwaltung der Abhängigkeiten. Stellen Sie sicher, dass alle erforderlichen Pakete mit kompatiblen Versionen installiert sind, indem Sie sich auf die ultralytics
pyproject.toml
Datei gespeichert werden.
Wenn Sie dauerhafte benutzerdefinierte Änderungen benötigen (z. B. immer opencv-python-headless
), können Sie das Ultralytics-Repository forken und Änderungen an pyproject.toml
oder anderen Code und installieren Sie ihn von Ihrem Fork.
- Forken Sie das Ultralytics GitHub-Repository in Ihr eigenes GitHub-Konto.
- Klonen Ihr Fork lokal:
git clone https://github.com/YOUR_USERNAME/ultralytics.git cd ultralytics
- Neuen Branch erstellen für Ihre Änderungen:
git checkout -b custom-opencv
- Ändern
pyproject.toml
: Öffnenpyproject.toml
in einem Texteditor verwalten und die Zeile ersetzen, die"opencv-python>=4.6.0"
mit"opencv-python-headless>=4.6.0"
(Version bei Bedarf anpassen). - Commit und Push Ihre Änderungen:
git add pyproject.toml git commit -m "Switch to opencv-python-headless" git push origin custom-opencv
- Installieren Verwendung von pip mit dem
git+https
Syntax, die auf Ihren Branch verweist:pip install git+https://github.com/YOUR_USERNAME/ultralytics.git@custom-opencv
Diese Methode stellt sicher, dass Ihr benutzerdefinierter Satz von Abhängigkeiten verwendet wird, wenn Sie von dieser bestimmten URL installieren. Siehe Methode 4 für die Verwendung in einem requirements.txt
Datei gespeichert werden.
Ähnlich der Standardmethode "Git Clone" für die Entwicklung können Sie das Repository lokal klonen, Abhängigkeitsdateien vor der Installation ändern und dann im bearbeitbaren Modus installieren.
- Klonen das Ultralytics-Repository:
git clone https://github.com/ultralytics/ultralytics cd ultralytics
- Ändern
pyproject.toml
: Bearbeiten Sie die Datei, um die gewünschten Änderungen vorzunehmen. Verwenden Sie beispielsweisesed
(unter Linux/macOS) oder einen Texteditor, umopencv-python
mitopencv-python-headless
. Verwendung vonsed
(die genaue Zeile in prüfenpyproject.toml
zuerst):Oder manuell bearbeiten# Example: Replace the line starting with "opencv-python..." # Adapt the pattern carefully based on the current file content sed -i'' -e 's/^\s*"opencv-python>=.*",/"opencv-python-headless>=4.8.0",/' pyproject.toml
pyproject.toml
um zu ändern"opencv-python>=...
zu"opencv-python-headless>=..."
. - Installieren das Paket im Editier-Modus (
-e
). Pip wird nun Ihre modifizierte Version verwendenpyproject.toml
um Abhängigkeiten aufzulösen und zu installieren:pip install -e .
Dieser Ansatz ist nützlich, um lokale Änderungen an Abhängigkeiten oder Build-Konfigurationen zu testen, bevor sie übernommen werden, oder um spezifische Entwicklungsumgebungen einzurichten.
Wenn Sie Ihre Projektabhängigkeiten mit einem requirements.txt
Datei können Sie Ihren benutzerdefinierten Ultralytics-Fork direkt darin angeben. Dies stellt sicher, dass jeder, der das Projekt einrichtet, Ihre spezifische Version mit ihren modifizierten Abhängigkeiten (wie opencv-python-headless
), oder Auto-Modus mit angegebener Auslastungsfraktion (
- Erstellen oder bearbeiten
requirements.txt
: Fügen Sie eine Zeile hinzu, die auf Ihren benutzerdefinierten Fork und Branch verweist (wie in Methode 2 vorbereitet).requirements.txtHinweis: Sie müssen keine Abhängigkeiten auflisten, die bereits von Ihrem benutzerdefinierten Code benötigt werden.# Core dependencies numpy matplotlib polars pyyaml Pillow psutil requests>=2.23.0 torch>=1.8.0 # Or specific version/variant torchvision>=0.9.0 # Or specific version/variant # Install ultralytics from a specific git commit or branch # Replace YOUR_USERNAME and custom-branch with your details git+https://github.com/YOUR_USERNAME/ultralytics.git@custom-branch # Other project dependencies flask # ... etc
ultralytics
Fork (wieopencv-python-headless
) hier, da pip diese basierend auf dem Fork installieren wird.pyproject.toml
. - Installieren Abhängigkeiten aus der Datei:
pip install -r requirements.txt
Diese Methode lässt sich nahtlos in Standard-Workflows zur Python-Projekt-Abhängigkeitsverwaltung integrieren und ermöglicht gleichzeitig das Pinnen von ultralytics
zu Ihrer angepassten Git-Quelle.
Ultralytics mit der CLI verwenden
Die Ultralytics-Befehlszeilenschnittstelle (CLI) ermöglicht einfache einzeilige Befehle, ohne dass eine Python-Umgebung erforderlich ist. CLI erfordert keine Anpassung oder Python-Code; führen Sie alle Aufgaben vom Terminal aus mit dem yolo
Befehl. Weitere Informationen zur Verwendung von YOLO über die Befehlszeile finden Sie in den CLI Guide an.
Beispiel
Ultralytics yolo
Befehle verwenden die folgende Syntax:
yolo TASK MODE ARGS
TASK
(optional) ist eines von (detect, segmentieren, klassifizieren, Pose, OBB)
- MODE
(erforderlich) ist eine von (trainieren, validieren, vorhersagen, exportieren, verfolgen, Benchmark)
- ARGS
(optional) sind arg=value
Paare wie imgsz=640
die Standardwerte überschreiben.
Alle anzeigen ARGS
im vollständigen Konfigurationsleitfaden oder mit dem yolo cfg
CLI-Befehl.
Trainieren Sie ein Erkennungsmodell für 10 Epochen mit einer anfänglichen Lernrate von 0,01:
yolo train data=coco8.yaml model=yolo11n.pt epochs=10 lr0=0.01
Vorhersage eines YouTube-Videos mithilfe eines vortrainierten Segmentierungsmodells bei einer Bildgröße von 320:
yolo predict model=yolo11n-seg.pt source='https://youtu.be/LNwODJXcvt4' imgsz=320
Validierung eines vortrainierten Erkennungsmodells mit einer Batch-Größe von 1 und einer Bildgröße von 640:
yolo val model=yolo11n.pt data=coco8.yaml batch=1 imgsz=640
Exportieren eines YOLOv11n-Klassifizierungsmodells in das ONNX-Format mit einer Bildgröße von 224x128 (keine TASK erforderlich):
yolo export model=yolo11n-cls.pt format=onnx imgsz=224,128
Objekte in einem Video oder Live-Stream mit YOLO11 zählen:
yolo solutions count show=True
yolo solutions count source="path/to/video.mp4" # specify video file path
Überwachen Sie Trainingsübungen mit einem YOLO11-Pose-Modell:
yolo solutions workout show=True
yolo solutions workout source="path/to/video.mp4" # specify video file path
# Use keypoints for ab-workouts
yolo solutions workout kpts="[5, 11, 13]" # left side
yolo solutions workout kpts="[6, 12, 14]" # right side
Verwenden Sie YOLO11, um Objekte in einer bestimmten Warteschlange oder Region zu zählen:
yolo solutions queue show=True
yolo solutions queue source="path/to/video.mp4" # specify video file path
yolo solutions queue region="[(20, 400), (1080, 400), (1080, 360), (20, 360)]" # configure queue coordinates
Führen Sie Objekterkennung, Instanzsegmentierung oder Pose-Schätzung in einem Webbrowser mit Streamlit durch:
yolo solutions inference
yolo solutions inference model="path/to/model.pt" # use model fine-tuned with Ultralytics Python package
Führen Sie spezielle Befehle aus, um die Version anzuzeigen, Einstellungen anzuzeigen, Prüfungen durchzuführen und mehr:
yolo help
yolo checks
yolo version
yolo settings
yolo copy-cfg
yolo cfg
yolo solutions help
Warnung
Argumente müssen als arg=value
Paare übergeben werden, getrennt durch ein Gleichheitszeichen =
Zeichen und durch Leerzeichen getrennt. Nicht verwenden --
Argumentpräfixe oder Kommas ,
zwischen Argumenten.
yolo predict model=yolo11n.pt imgsz=640 conf=0.25
✅yolo predict model yolo11n.pt imgsz 640 conf 0.25
❌ (fehlt=
)yolo predict model=yolo11n.pt, imgsz=640, conf=0.25
❌ (nicht verwenden,
)yolo predict --model yolo11n.pt --imgsz 640 --conf 0.25
❌ (nicht verwenden--
)yolo solution model=yolo11n.pt imgsz=640 conf=0.25
❌ (verwendensolutions
, nichtsolution
)
Ultralytics mit Python verwenden
Die Ultralytics YOLO Python-Schnittstelle bietet eine nahtlose Integration in Python-Projekte und erleichtert das Laden, Ausführen und Verarbeiten von Modellausgaben. Die Python-Schnittstelle ist auf Einfachheit ausgelegt und ermöglicht es Benutzern, schnell Objektdetektion, Segmentierung und Klassifizierung zu implementieren. Dies macht die YOLO Python-Schnittstelle zu einem unschätzbaren Werkzeug für die Integration dieser Funktionalitäten in Python-Projekte.
Benutzer können beispielsweise ein Modell laden, es trainieren, seine Leistung bewerten und es mit nur wenigen Codezeilen in das ONNX-Format exportieren. Erkunden Sie den Python-Leitfaden, um mehr über die Verwendung von YOLO in Ihren Python-Projekten zu erfahren.
Beispiel
from ultralytics import YOLO
# Create a new YOLO model from scratch
model = YOLO("yolo11n.yaml")
# Load a pretrained YOLO model (recommended for training)
model = YOLO("yolo11n.pt")
# Train the model using the 'coco8.yaml' dataset for 3 epochs
results = model.train(data="coco8.yaml", epochs=3)
# Evaluate the model's performance on the validation set
results = model.val()
# Perform object detection on an image using the model
results = model("https://ultralytics.com/images/bus.jpg")
# Export the model to ONNX format
success = model.export(format="onnx")
Ultralytics Einstellungen
Die Ultralytics-Bibliothek enthält eine SettingsManager
für eine detaillierte Kontrolle über Experimente, die es Benutzern ermöglicht, einfach auf Einstellungen zuzugreifen und diese zu ändern. Diese Einstellungen werden in einer JSON-Datei im Benutzerkonfigurationsverzeichnis der Umgebung gespeichert und können in der Python-Umgebung oder über die Befehlszeilenschnittstelle (CLI) angezeigt oder geändert werden.
Einstellungen überprüfen
So zeigen Sie die aktuelle Konfiguration Ihrer Einstellungen an:
Einstellungen anzeigen
Verwenden Sie Python, um Ihre Einstellungen anzuzeigen, indem Sie Folgendes importieren: settings
Objekts aus dem ultralytics
Modul. Einstellungen mit diesen Befehlen ausgeben und zurückgeben:
from ultralytics import settings
# View all settings
print(settings)
# Return a specific setting
value = settings["runs_dir"]
Über die Befehlszeilenschnittstelle können Sie Ihre Einstellungen wie folgt überprüfen:
yolo settings
Einstellungen ändern
Ultralytics vereinfacht die Änderung von Einstellungen auf folgende Weise:
Einstellungen aktualisieren
Verwenden Sie in python die update
Methode für das settings
Objekt:
from ultralytics import settings
# Update a setting
settings.update({"runs_dir": "/path/to/runs"})
# Update multiple settings
settings.update({"runs_dir": "/path/to/runs", "tensorboard": False})
# Reset settings to default values
settings.reset()
So ändern Sie Einstellungen über die Befehlszeilenschnittstelle:
# Update a setting
yolo settings runs_dir='/path/to/runs'
# Update multiple settings
yolo settings runs_dir='/path/to/runs' tensorboard=False
# Reset settings to default values
yolo settings reset
Einstellungen verstehen
Die folgende Tabelle gibt einen Überblick über die anpassbaren Einstellungen innerhalb von Ultralytics, einschließlich Beispielwerte, Datentypen und Beschreibungen.
Name | Beispielwert | Datentyp | Beschreibung |
---|---|---|---|
settings_version |
'0.0.4' |
str |
Ultralytics settings Version (unterscheidet sich von der Ultralytics pip Version) |
datasets_dir |
'/path/to/datasets' |
str |
Verzeichnis, in dem Datensätze gespeichert sind |
weights_dir |
'/path/to/weights' |
str |
Verzeichnis, in dem die Modellgewichte gespeichert werden |
runs_dir |
'/path/to/runs' |
str |
Verzeichnis, in dem die Experimentläufe gespeichert werden |
uuid |
'a1b2c3d4' |
str |
Eindeutige Kennung für die aktuellen Einstellungen |
sync |
True |
bool |
Option zur Synchronisierung von Analysen und Abstürzen mit Ultralytics HUB |
api_key |
'' |
str |
Ultralytics HUB API-Schlüssel |
clearml |
True |
bool |
Option zur Verwendung von ClearML-Protokollierung |
comet |
True |
bool |
Option zur Verwendung von Comet ML für Experimentverfolgung und Visualisierung |
dvc |
True |
bool |
Option zur Verwendung von DVC für die Experimentverfolgung und Versionskontrolle |
hub |
True |
bool |
Option zur Verwendung der Ultralytics HUB-Integration |
mlflow |
True |
bool |
Option zur Verwendung von MLFlow für die Experimentverfolgung |
neptune |
True |
bool |
Option zur Verwendung von Neptune für die Experimentverfolgung |
raytune |
True |
bool |
Option zur Verwendung von Ray Tune für Hyperparameter-Optimierung |
tensorboard |
True |
bool |
Option zur Verwendung von TensorBoard für die Visualisierung |
wandb |
True |
bool |
Option zur Verwendung der Weights & Biases-Protokollierung |
vscode_msg |
True |
bool |
Wenn ein VS Code-Terminal erkannt wird, wird eine Aufforderung zum Herunterladen der Erweiterung Ultralytics-Snippets aktiviert. |
Überprüfen Sie diese Einstellungen im Laufe Ihrer Projekte oder Experimente, um eine optimale Konfiguration sicherzustellen.
FAQ
Wie installiere ich Ultralytics mit pip?
Installieren Sie Ultralytics mit pip über:
pip install ultralytics
Dies installiert die neueste stabile Version von ultralytics
Paket von PyPI. So installieren Sie die Entwicklungsversion direkt von GitHub:
pip install git+https://github.com/ultralytics/ultralytics.git
Stellen Sie sicher, dass das Git-Befehlszeilentool auf Ihrem System installiert ist.
Kann ich Ultralytics YOLO mit Conda installieren?
Ja, installieren Sie Ultralytics YOLO mit conda:
conda install -c conda-forge ultralytics
Diese Methode ist eine großartige Alternative zu pip und gewährleistet die Kompatibilität mit anderen Paketen. Für CUDA-Umgebungen installieren Sie ultralytics
, pytorch
und pytorch-cuda
zusammen, um Konflikte zu lösen:
conda install -c pytorch -c nvidia -c conda-forge pytorch torchvision pytorch-cuda=11.8 ultralytics
Weitere Anweisungen finden Sie im Conda-Schnellstart-Leitfaden.
Welche Vorteile bietet die Verwendung von Docker zur Ausführung von Ultralytics YOLO?
Docker bietet eine isolierte, konsistente Umgebung für Ultralytics YOLO und gewährleistet eine reibungslose Leistung über verschiedene Systeme hinweg und vermeidet lokale Installationskomplexitäten. Offizielle Docker-Images sind auf Docker Hub verfügbar, mit Varianten für GPU, CPU, ARM64, NVIDIA Jetson und Conda. So ziehen und starten Sie das neueste Image:
# Pull the latest ultralytics image from Docker Hub
sudo docker pull ultralytics/ultralytics:latest
# Run the ultralytics image in a container with GPU support
sudo docker run -it --ipc=host --gpus all ultralytics/ultralytics:latest
Detaillierte Docker-Anweisungen finden Sie im Docker-Schnellstart-Leitfaden.
Wie clone ich das Ultralytics Repository für die Entwicklung?
Klonen Sie das Ultralytics-Repository und richten Sie eine Entwicklungsumgebung ein mit:
# Clone the ultralytics repository
git clone https://github.com/ultralytics/ultralytics
# Navigate to the cloned directory
cd ultralytics
# Install the package in editable mode for development
pip install -e .
Dies ermöglicht Beiträge zum Projekt oder das Experimentieren mit dem neuesten Quellcode. Einzelheiten finden Sie im Ultralytics GitHub Repository.
Warum sollte ich die Ultralytics YOLO CLI verwenden?
Die Ultralytics YOLO CLI vereinfacht die Ausführung von Objekterkennungsaufgaben ohne Python-Code und ermöglicht einzeilige Befehle für Training, Validierung und Vorhersage direkt von Ihrem Terminal aus. Die grundlegende Syntax lautet:
yolo TASK MODE ARGS
Um beispielsweise ein Erkennungsmodell zu trainieren:
yolo train data=coco8.yaml model=yolo11n.pt epochs=10 lr0=0.01
Weitere Befehle und Anwendungsbeispiele finden Sie im vollständigen CLI-Leitfaden.