Ultralytics 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 or upgrade the ultralytics package from PyPI
pip install -U 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

# 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 auf Docker Hubverfü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 --runtime=nvidia --gpus all $t            # all GPUs
sudo docker run -it --ipc=host --runtime=nvidia --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 --runtime=nvidia --gpus all $t            # all GPUs
sudo docker run -it --ipc=host --runtime=nvidia --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 --runtime=nvidia --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.

Wenn Sie dauerhafte benutzerdefinierte Änderungen benötigen, können Sie das Ultralytics forken und Änderungen an pyproject.toml oder anderen Code und installieren Sie ihn von Ihrem Fork.

1. Forken Sie das Ultralytics GitHub-Repository in Ihr eigenes GitHub-Konto.
2. Klonen Ihr Fork lokal:

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

3. Neuen Branch erstellen für Ihre Änderungen:

   git checkout -b my-custom-branch
   

4. Nehmen Sie Ihre Änderungen vor. zu pyproject.toml oder andere Dateien, je nach Bedarf.
5. Commit und Push Ihre Änderungen:

   git add .
   git commit -m "My custom changes"
   git push origin my-custom-branch
   

6. Installieren Verwendung von pip mit dem git+https Syntax, die auf Ihren Branch verweist:

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

Klonen Sie das Repository lokal, ändern Sie die Dateien nach Bedarf und installieren Sie sie im bearbeitbaren Modus.

1. Klonen das Ultralytics-Repository:

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

2. Nehmen Sie Ihre Änderungen vor. zu pyproject.toml oder andere Dateien, je nach Bedarf.
3. Installieren das Paket im Editier-Modus (-e). Pip wird Ihre geänderte pyproject.toml Um Abhängigkeiten zu lösen:

   pip install -e .
   

Dieser Ansatz ist nützlich für die Entwicklung oder das Testen lokaler Änderungen vor dem Commit.

Geben Sie eine benutzerdefinierte Ultralytics in Ihrer requirements.txt Datei, um einheitliche Installationen in Ihrem Team sicherzustellen.

# Install ultralytics from a specific git branch
git+https://github.com/YOUR_USERNAME/ultralytics.git@my-custom-branch

# Other project dependencies
flask

Installieren Sie Abhängigkeiten aus der Datei:

pip install -r requirements.txt

Ultralytics yolo Befehle verwenden die folgende Syntax:

yolo TASK MODE ARGS

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

Ein YOLO11n-Klassifizierungsmodell im ONNX-Format mit einer Bildgröße von 224x128 exportieren (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

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

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