Schnellstart

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

# 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 für die Ausbildung empfohlen.
• 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-Version, die sich für Inferenzen und Umgebungen ohne GPUs eignet.
• Dockerfile-Jetson: Maßgeschneidert für NVIDIA Jetson-Geräte, mit einer für diese Plattformen optimierten GPU-Unterstützung.
• 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 Flagge 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.

Ultralytics yolo Befehle verwenden die folgende Syntax:

yolo TASK MODE ARGS

• TASK (optional) ist eine von (erkennen., Segment, klassifizieren, Pose)
• MODE (erforderlich) ist eine von (Zug, val, vorhersagen., exportieren, Strecke)
• 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.

Trainiere ein Erkennungsmodell für 10 Epochen mit einer anfänglichen learning_rate von 0,01

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

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

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

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

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

Exportiere ein Klassifizierungsmodell von YOLOv8n in das Format ONNX mit der Bildgröße 224 x 128 (kein TASK erforderlich)

yolo export model=yolov8n-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

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

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