Schnellstart

Installiere Ultralytics

Ultralytics provides various installation methods including pip, conda, and Docker. Install YOLO via the ultralytics pip-Paket für die letzte stabile Version oder durch Klonen der Ultralytics GitHub-Repository für die aktuellste Version. Docker kann verwendet werden, um das Paket in einem isolierten Container auszuführen und so eine lokale Installation zu vermeiden.

Pass auf: Ultralytics YOLO Schnellstart-Anleitung

Installiere

Pip installieren (empfohlen)Conda installierenGit-KlonDocker

Installieren Sie die ultralytics Paket mit pip oder aktualisieren Sie eine bestehende Installation, indem Sie pip install -U ultralytics. Besuchen Sie den Python Package Index (PyPI) für weitere Informationen über die ultralytics Paket: https://pypi.org/project/ultralytics/.

# Install the ultralytics package from PyPI
pip install ultralytics

Du kannst auch die ultralytics Paket direkt vom GitHub Repository. Das kann nützlich sein, wenn du die neueste Entwicklungsversion haben willst. Vergewissere dich, dass du das Git-Kommandozeilen-Tool auf deinem System installiert hast. Die @main Befehl installiert die main Zweig und kann in einen anderen Zweig geändert werden, d.h. @my-branchoder ganz entfernt, um die Standardeinstellung zu main Zweig.

# Install the ultralytics package from GitHub
pip install git+https://github.com/ultralytics/ultralytics.git@main

Conda ist ein alternativer Paketmanager zu pip, der ebenfalls für die Installation verwendet werden kann. Weitere Informationen zu Anaconda findest du unter https://anaconda.org/conda-forge/ultralytics. Ultralytics Das Feedstock-Repository zum Aktualisieren des Conda-Pakets findest du unter https://github.com/conda-forge/ultralytics-feedstock/.

# Install the ultralytics package using conda
conda install -c conda-forge ultralytics

Hinweis

Wenn du in einer CUDA Umgebung installierst, ist es am besten, wenn du ultralytics, pytorch und pytorch-cuda in demselben Befehl, damit der conda-Paketmanager etwaige Konflikte auflösen kann, oder um die pytorch-cuda zuletzt, damit es die CPU-spezifischen Einstellungen überschreibt. pytorch Paket, wenn nötig.

# 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 erhältlich bei DockerHub. Diese Bilder basieren auf Miniconda3 und sind ein einfacher Weg, um mit der ultralytics in einer Conda-Umgebung.

# 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

Klone die ultralytics Repository, wenn du dich an der Entwicklung beteiligen oder mit dem neuesten Quellcode experimentieren möchtest. Nach dem Klonen navigierst du in das Verzeichnis und installierst das Paket im Editiermodus -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 .

Verwende Docker, um mühelos die ultralytics Paket in einem isolierten Container, um eine konsistente und reibungslose Leistung in verschiedenen Umgebungen zu gewährleisten. Durch die Wahl eines der offiziellen ultralytics Bilder von Docker HubMit Ultralytics kannst du nicht nur die Komplexität einer lokalen Installation vermeiden, sondern auch auf eine verifizierte Arbeitsumgebung zugreifen. bietet 5 unterstützte Docker-Images, die jeweils für eine hohe Kompatibilität und Effizienz für verschiedene Plattformen und Anwendungsfälle ausgelegt sind:

Dockerfile: GPU image recommended for training.
Dockerfile-arm64: Optimiert für die ARM64-Architektur und ermöglicht den Einsatz auf Geräten wie dem Raspberry Pi und anderen ARM64-basierten Plattformen.
Dockerfile-cpu: Ubuntu-basierte CPU-only Version, die für Inferenz und Umgebungen ohne GPUs geeignet ist.
Dockerfile-Jetson: Maßgeschneidert für NVIDIA Jetson-Geräte, mit optimierter Unterstützung von GPU für diese Plattformen.
Dockerfile-python: Minimales Image mit nur Python und den notwendigen Abhängigkeiten, ideal für leichtgewichtige Anwendungen und Entwicklung.
Dockerfile-conda: Basiert auf Miniconda3 mit der conda-Installation des ultralytics Pakets.

Im Folgenden findest du die Befehle, um das neueste Image zu erhalten 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 der neuesten ultralytics Bild. Die -it Flag weist ein Pseudo-TTY zu und hält stdin offen, damit du mit dem Container interagieren kannst. Die --ipc=host Flag setzt den IPC (Inter-Process Communication) Namespace auf den Host, der für die gemeinsame Nutzung von Speicher zwischen Prozessen wichtig ist. Die --gpus all Flag ermöglicht 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 deinem lokalen Rechner innerhalb des Containers zu arbeiten, verwende Docker-Volumes, um ein lokales Verzeichnis in den Container zu mounten:

# 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

Alter /path/on/host mit dem Verzeichnispfad auf deinem lokalen Rechner, und /path/in/container mit dem gewünschten Pfad innerhalb des Docker-Containers für die Zugänglichkeit.

Für die fortgeschrittene Nutzung von Docker kannst du den Ultralytics Docker Guide lesen.

Siehe die ultralytics pyproject.toml Datei für eine Liste der Abhängigkeiten. Beachte, dass alle obigen Beispiele alle erforderlichen Abhängigkeiten installieren.

Tipp

PyTorch requirements vary by operating system and CUDA requirements, so it's recommended to install PyTorch first following instructions at https://pytorch.org/get-started/locally.

Verwende Ultralytics mit CLI

Die Ultralytics Befehlszeilenschnittstelle (CLI) ermöglicht einfache einzeilige Befehle, ohne dass eine Python Umgebung benötigt wird. CLI erfordert keine Anpassungen oder Python Code. Du kannst alle Aufgaben einfach vom Terminal aus mit der yolo Befehl. Schau dir die CLI Leitfaden to learn more about using YOLO from the command line.

Beispiel

SyntaxZugVorhersageValexportierenSpezial

Ultralytics yolo Befehle verwenden die folgende Syntax:

yolo TASK MODE ARGS

TASK (optional) ist eine von (erkennen., Segment, klassifizieren, Pose, obb)
MODE (erforderlich) ist eine von (Zug, val, vorhersagen., exportieren, Strecke, Benchmark)
ARGS (optional) sind arg=value Paare wie imgsz=640 die die Standardeinstellungen außer Kraft setzen.

Alle sehen ARGS in der vollen Konfigurationsleitfaden oder mit der yolo cfg CLI Befehl.

Train a detection model for 10 epochs with an initial learning_rate of 0.01

yolo train data=coco8.yaml model=yolo11n.pt epochs=10 lr0=0.01

Vorhersage eines YouTube-Videos mit einem trainierten Segmentierungsmodell bei Bildgröße 320:

yolo predict model=yolo11n-seg.pt source='https://youtu.be/LNwODJXcvt4' imgsz=320

Val ein vortrainiertes Erkennungsmodell bei Losgröße 1 und Bildgröße 640:

yolo val model=yolo11n.pt data=coco8.yaml batch=1 imgsz=640

Export a yolo11n classification model to ONNX format at image size 224 by 128 (no TASK required)

yolo export model=yolo11n-cls.pt format=onnx imgsz=224,128

Führe spezielle Befehle aus, um die Version zu sehen, Einstellungen anzuzeigen, Prüfungen durchzuführen und mehr:

yolo help
yolo checks
yolo version
yolo settings
yolo copy-cfg
yolo cfg

Warnung

Argumente müssen übergeben werden als arg=val Paare, getrennt durch ein Gleichheitszeichen = Zeichen und durch Leerzeichen zwischen den Paaren abgegrenzt. Verwenden Sie nicht -- Argument-Präfixe oder Kommas , zwischen den 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 --)

CLI Leitfaden

Verwende Ultralytics mit Python

YOLO's Python interface allows for seamless integration into your Python projects, making it easy to load, run, and process the model's output. Designed with simplicity and ease of use in mind, the Python interface enables users to quickly implement object detection, segmentation, and classification in their projects. This makes YOLO's Python interface an invaluable tool for anyone looking to incorporate these functionalities into their Python projects.

For example, users can load a model, train it, evaluate its performance on a validation set, and even export it to ONNX format with just a few lines of code. Check out the Python Guide to learn more about using YOLO within your Python projects.

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

Python Leitfaden

Ultralytics Einstellungen

Die Bibliothek Ultralytics bietet ein leistungsfähiges Einstellungsmanagement, mit dem du deine Experimente genauestens steuern kannst. Durch die Verwendung der SettingsManager untergebracht in der ultralytics.utils module, users can readily access and alter their settings. These are stored in a JSON file in the environment user configuration directory, and can be viewed or modified directly within the Python environment or via the Command-Line Interface (CLI).

Einstellungen inspizieren

Um einen Einblick in die aktuelle Konfiguration deiner Einstellungen zu erhalten, kannst du sie direkt einsehen:

Einstellungen ansehen

PythonCLI

Du kannst Python verwenden, um deine Einstellungen zu sehen. Beginne mit dem Importieren der settings Objekt aus dem ultralytics Modul. Drucke die Einstellungen mit den folgenden Befehlen aus und gib sie zurück:

from ultralytics import settings

# View all settings
print(settings)

# Return a specific setting
value = settings["runs_dir"]

Alternativ kannst du deine Einstellungen auch mit einem einfachen Befehl über die Kommandozeile überprüfen:

yolo settings

Ändern der Einstellungen

Ultralytics ermöglicht es den Nutzern, ihre Einstellungen einfach zu ändern. Änderungen können auf die folgenden Arten vorgenommen werden:

Einstellungen aktualisieren

PythonCLI

Rufen Sie innerhalb der Umgebung Python die update Methode auf der settings Objekt, um deine Einstellungen zu ändern:

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

Wenn du lieber die Befehlszeilenschnittstelle verwendest, kannst du mit den folgenden Befehlen deine Einstellungen ändern:

# 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 Einstellungen, die auf Ultralytics vorgenommen werden können. Jede Einstellung ist mit einem Beispielwert, dem Datentyp und einer kurzen Beschreibung versehen.

Name	Beispielwert	Datentyp	Beschreibung
`settings_version`	`'0.0.4'`	`str`	Ultralytics Version derEinstellungen (abweichend von Ultralytics pip version)
`datasets_dir`	`'/path/to/datasets'`	`str`	Das Verzeichnis, in dem die Datensätze gespeichert werden
`weights_dir`	`'/path/to/weights'`	`str`	Das Verzeichnis, in dem die Modellgewichte gespeichert werden
`runs_dir`	`'/path/to/runs'`	`str`	Das Verzeichnis, in dem die Experimentläufe gespeichert werden
`uuid`	`'a1b2c3d4'`	`str`	Der eindeutige Bezeichner für die aktuellen Einstellungen
`sync`	`True`	`bool`	Ob Analysen und Abstürze mit HUB synchronisiert werden sollen
`api_key`	`''`	`str`	Ultralytics HUB API Schlüssel
`clearml`	`True`	`bool`	Whether to use ClearML logging
`comet`	`True`	`bool`	Ob du Comet ML für die Verfolgung und Visualisierung von Experimenten nutzen willst
`dvc`	`True`	`bool`	Ob du DVC für die Versuchsverfolgung und Versionskontrolle nutzen willst
`hub`	`True`	`bool`	Ob die Ultralytics HUB-Integration verwendet werden soll
`mlflow`	`True`	`bool`	Whether to use MLFlow for experiment tracking
`neptune`	`True`	`bool`	Whether to use Neptune for experiment tracking
`raytune`	`True`	`bool`	Whether to use Ray Tune for hyperparameter tuning
`tensorboard`	`True`	`bool`	Whether to use TensorBoard for visualization
`wandb`	`True`	`bool`	Whether to use Weights & Biases logging
`vscode_msg`	`True`	`bool`	When VS Code terminal detected, enables prompt to download Ultralytics-Snippets extension.

Während du durch deine Projekte oder Experimente navigierst, solltest du diese Einstellungen immer wieder überprüfen, um sicherzustellen, dass sie optimal für deine Bedürfnisse konfiguriert sind.

FAQ

How do I install Ultralytics using pip?

To install Ultralytics with pip, execute the following command:

pip install ultralytics

Bei der letzten stabilen Version wird dadurch die ultralytics Paket direkt aus dem Python Package Index (PyPI). Für weitere Details besuche die ultralytics Paket auf PyPI.

Alternativ kannst du die neueste Entwicklungsversion auch direkt von GitHub installieren:

pip install git+https://github.com/ultralytics/ultralytics.git

Vergewissere dich, dass das Git-Kommandozeilentool auf deinem System installiert ist.

Can I install Ultralytics YOLO using conda?

Yes, you can install Ultralytics YOLO using conda by running:

conda install -c conda-forge ultralytics

Diese Methode ist eine hervorragende Alternative zu pip und gewährleistet die Kompatibilität mit anderen Paketen in deiner Umgebung. Für CUDA Umgebungen ist es am besten, die ultralytics, pytorch, und pytorch-cuda gleichzeitig, um eventuelle Konflikte zu lösen:

conda install -c pytorch -c nvidia -c conda-forge pytorch torchvision pytorch-cuda=11.8 ultralytics

Weitere Anweisungen findest du in der Conda Schnellstartanleitung.

What are the advantages of using Docker to run Ultralytics YOLO?

Using Docker to run Ultralytics YOLO provides an isolated and consistent environment, ensuring smooth performance across different systems. It also eliminates the complexity of local installation. Official Docker images from Ultralytics are available on Docker Hub, with different variants tailored for GPU, CPU, ARM64, NVIDIA Jetson, and Conda environments. Below are the commands to pull and run the latest 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

Ausführlichere Anweisungen zu Docker findest du in der Docker-Schnellstartanleitung.

Wie kann ich das Ultralytics Repository für die Entwicklung klonen?

Um das Repository Ultralytics zu klonen und eine Entwicklungsumgebung einzurichten, gehst du wie folgt vor:

# 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 .

Auf diese Weise kannst du zum Projekt beitragen oder mit dem neuesten Quellcode experimentieren. Weitere Informationen findest du im Ultralytics GitHub-Repository.

Why should I use Ultralytics YOLO CLI?

The Ultralytics YOLO command line interface (CLI) simplifies running object detection tasks without requiring Python code. You can execute single-line commands for tasks like training, validation, and prediction straight from your terminal. The basic syntax for yolo Befehle ist:

yolo TASK MODE ARGS

Zum Beispiel, um ein Erkennungsmodell mit bestimmten Parametern zu trainieren:

yolo train data=coco8.yaml model=yolo11n.pt epochs=10 lr0=0.01

Schau dir den vollständigen CLI Guide an, um mehr Befehle und Anwendungsbeispiele zu entdecken.

📅 Created 11 months ago ✏️ Updated 14 days ago