Installieren Sie Ultralytics

Installieren oder aktualisieren Sie die ultralytics Paket mit pip durch Ausführen von pip install -U ultralytics. Für weitere Einzelheiten über die ultralytics Paket, besuchen Sie die Python (PyPI).

# Install the ultralytics package from PyPI
pip install ultralytics

Sie können auch Folgendes installieren ultralytics direkt vom Ultralytics GitHub-Repository. Dies kann nützlich sein, wenn Sie die neueste Entwicklungsversion benötigen. Vergewissern Sie sich, dass Sie das Git-Befehlszeilentool installiert haben, und führen Sie es dann aus:

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

Conda kann als alternativer Paketmanager zu pip verwendet werden. Weitere Einzelheiten finden Sie unter Anaconda. Das Ultralytics Feedstock-Repository für die Aktualisierung des Conda-Pakets ist auf GitHub verfügbar.

# 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 verfügbar unter DockerHub. Diese Bilder basieren auf Miniconda3 und bieten einen unkomplizierten Einstieg in die Nutzung 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

Klonen Sie die Ultralytics GitHub-Repository wenn Sie sich an der Entwicklung beteiligen 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 zur Ausführung der ultralytics Paket in einem isolierten Container, wodurch eine konsistente Leistung in verschiedenen Umgebungen gewährleistet wird. Durch die Auswahl eines der offiziellen ultralytics Bilder von Docker-HubMit Ultralytics vermeiden Sie die Komplexität einer lokalen Installation und erhalten Zugang zu einer verifizierten Arbeitsumgebung. Ultralytics bietet fünf unterstützte Docker-Images, die jeweils auf hohe Kompatibilität und Effizienz ausgelegt sind:

• Dockerfile: GPU image recommended for training.
• Dockerfile-arm64: Optimiert für ARM64-Architektur, geeignet für den Einsatz auf Geräten wie Raspberry Pi und anderen ARM64-basierten Plattformen.
• cpu: Ubuntu-basierte CPU, geeignet für Inferenzen und Umgebungen ohne GPUs.
• Dockerfile-Jetson: Maßgeschneidert für NVIDIA Jetson-Geräte, mit integrierter GPU , die für diese Plattformen optimiert ist.
• Dockerfile-python: Minimales Image mit nur Python und den notwendigen Abhängigkeiten, ideal für leichtgewichtige Anwendungen und Entwicklung.
• Dockerfile-conda: Basierend auf Miniconda3 mit einer conda-Installation der ultralytics Paket.

Hier sind 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 Website -it Flaggen weisen ein Pseudo-TTY zu und halten stdin offen, was eine Interaktion mit dem Container ermöglicht. Die --ipc=host setzt den IPC-Namensraum (Inter-Process Communication) auf den Host, der für die gemeinsame Nutzung von Speicher durch Prozesse unerlässlich ist. Die --gpus all Flagge ermöglicht den Zugriff auf alle verfügbaren GPUs innerhalb des Containers, was für Aufgaben, die GPU 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 einzuhängen:

# 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 mit dem gewünschten Pfad innerhalb des Docker-Containers.

Für die fortgeschrittene Verwendung von Docker lesen Sie bitte den Ultralytics Docker Guide.

Sie können die ultralytics Paketkern ohne jegliche Abhängigkeiten mit der Pip-Funktion --no-deps Flagge. In diesem Fall müssen Sie alle erforderlichen Abhängigkeiten manuell nachinstallieren.

1. Installieren Sie ultralytics Kern:

   pip install ultralytics --no-deps
   

2. Manuelle Installation von Abhängigkeiten: Sie müssen alle erforderlichen Pakete installieren, die in der pyproject.toml Datei und ersetzen oder ändern Sie die Versionen nach Bedarf. Für das OpenCV-Beispiel ohne Kopf:

   # Install other core dependencies
   pip install torch torchvision numpy matplotlib pandas pyyaml pillow psutil requests tqdm scipy seaborn ultralytics-thop
   
   # Install headless OpenCV instead of the default
   pip install opencv-python-headless
   

Wenn Sie dauerhafte benutzerdefinierte Änderungen benötigen (z. B. immer mit opencv-python-headless), können Sie das Ultralytics forken, Änderungen an pyproject.toml oder anderen Code, und installieren Sie von Ihrem Fork aus.

1. Forken Sie das Ultralytics GitHub-Repository auf Ihr eigenes GitHub-Konto.
2. Klonen Ihre Gabelung vor Ort:

   git clone https://github.com/YOUR_USERNAME/ultralytics.git
   cd ultralytics
   

3. Einen neuen Zweig erstellen für Ihre Änderungen:

   git checkout -b custom-opencv
   

4. Ändern Sie pyproject.toml: Öffnen Sie pyproject.toml in einem Texteditor und ersetzen Sie die Zeile mit "opencv-python>=4.6.0" mit "opencv-python-headless>=4.6.0" (Version nach Bedarf anpassen).
5. Commit und Push Ihre Änderungen:

   git add pyproject.toml
   git commit -m "Switch to opencv-python-headless"
   git push origin custom-opencv
   

6. Installieren Sie unter Verwendung von pip mit der git+https Syntax, die auf Ihren Zweig verweist:

   pip install git+https://github.com/YOUR_USERNAME/ultralytics.git@custom-opencv
   

Mit dieser Methode wird sichergestellt, dass Ihr benutzerdefinierter Abhängigkeitssatz immer dann verwendet wird, wenn Sie von dieser speziellen URL aus installieren. Siehe Methode 4 für die Verwendung dieser Methode in einer requirements.txt Datei.

Ähnlich wie bei 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.

1. Klonen das Ultralytics :

   git clone https://github.com/ultralytics/ultralytics
   cd ultralytics
   

2. Ändern Sie pyproject.toml: Bearbeiten Sie die Datei, um die gewünschten Änderungen vorzunehmen. Verwenden Sie zum Beispiel sed (unter Linux/macOS) oder einen Texteditor, um die opencv-python mit opencv-python-headless. Verwendung von sed (Überprüfen Sie die genaue Zeile in pyproject.toml zuerst):

   # 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
   

   Oder manuell bearbeiten pyproject.toml zu ändern "opencv-python>=... zu "opencv-python-headless>=...".
3. Installieren Sie das Paket im bearbeitbaren Modus (-e). Pip verwendet nun Ihre geänderte pyproject.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 festgeschrieben werden, oder um spezielle Entwicklungsumgebungen einzurichten.

Wenn Sie Ihre Projektabhängigkeiten mit einer requirements.txt Datei können Sie Ihren eigenen Ultralytics direkt darin angeben. Dadurch wird sichergestellt, dass jeder, der das Projekt einrichtet, Ihre spezielle Version mit ihren geänderten Abhängigkeiten (wie opencv-python-headless).

1. Erstellen oder bearbeiten requirements.txt: Fügen Sie eine Zeile hinzu, die auf Ihren benutzerdefinierten Fork und Branch verweist (wie in Methode 2 vorbereitet).
   Anforderungen.txt

   # Core dependencies
   numpy
   matplotlib
   pandas
   pyyaml
   Pillow
   psutil
   requests>=2.23.0
   tqdm
   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
   

   Hinweis: Sie müssen keine Abhängigkeiten auflisten, die bereits für Ihre benutzerdefinierte ultralytics gabel (wie opencv-python-headless) hier, da pip sie basierend auf dem Fork der pyproject.toml.
2. Installieren Sie Abhängigkeiten aus der Datei:

   pip install -r requirements.txt
   

Diese Methode fügt sich nahtlos in die Standardabläufe der Python ein und ermöglicht es Ihnen, die ultralytics zu Ihrer angepassten Git-Quelle.

Ultralytics yolo Befehle verwenden die folgende Syntax:

yolo TASK MODE ARGS

Alle sehen ARGS im vollen Leitfaden zur Konfiguration 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 mit Hilfe eines vortrainierten Segmentierungsmodells bei Bildgröße 320:

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

Validieren Sie ein vorab trainiertes Erkennungsmodell mit einer Stapelgröße von 1 und einer Bildgröße von 640:

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

Exportieren Sie ein YOLOv11n-Klassifizierungsmodell in das ONNX mit einer Bildgröße von 224x128 (kein TASK erforderlich):

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

Zählen Sie Objekte in einem Video oder Live-Stream mit YOLO11:

yolo solutions count show=True

yolo solutions count source="path/to/video.mp4" # specify video file path

Überwachen Sie Trainingsübungen mit einem YOLO11 :

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 Posenschä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 zu sehen, Einstellungen anzuzeigen, Prüfungen durchzuführen und vieles mehr:

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

Verwenden Sie Python , um Ihre Einstellungen anzuzeigen, indem Sie die settings Objekt aus dem ultralytics Modul. Mit diesen Befehlen können Sie Einstellungen drucken und zurückgeben:

from ultralytics import settings

# View all settings
print(settings)

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

Mit der Befehlszeilenschnittstelle können Sie Ihre Einstellungen überprüfen:

yolo settings

In Python verwenden Sie die update Methode auf der 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 die 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